using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using AdminService.User.Param;
using Common;
using Common.Utils;
using CommonDomain.BaseModel;
using CommonInfrastructure;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using MongoDB.Driver;
using MongoRepository;
using UserDomain.Entity;
using UserDomain.Enum;

namespace AdminApi.UserAssetChanges
{
    [ApiController, Route("adminapi/[controller]")]
    [Authorize]
    public class UserAssetChangeController : BaseController
    {
        private readonly IMongoBaseRepository<UserReward> _rewardMongo;
        private readonly IMongoBaseRepository<UserEntity> _userMongo;

        public UserAssetChangeController(IMongoBaseRepository<UserReward> rewardMongo, IMongoBaseRepository<UserEntity> userMongo)
        {
            _rewardMongo = rewardMongo;
            _userMongo = userMongo;
        }

        [HttpPost("list")]
        public async Task<PageResponse<UserAssetChangeDto>> GetList([FromBody] UserAssetChangeQueryParam param)
        {
            var filter = Builders<UserReward>.Filter.Empty;

            filter &= Builders<UserReward>.Filter.Nin(x => x.Source, new List<RewardSource>() {  RewardSource.开炮, RewardSource.击杀鱼});

            if (!string.IsNullOrWhiteSpace(param.UserId))
            {
                filter &= Builders<UserReward>.Filter.Eq(x => x.UserId, param.UserId);
            }

            if (param.CurrencyTypes != null && param.CurrencyTypes.Count > 0)
            {
                filter &= Builders<UserReward>.Filter.In(x => x.CurrencyType, param.CurrencyTypes);
            }

            if (param.ChangeTypes != null && param.ChangeTypes.Count > 0)
            {
                filter &= Builders<UserReward>.Filter.In(x => x.Type, param.ChangeTypes);
            }

            if (param.Sources != null && param.Sources.Count > 0)
            {
                var sourceEnums = param.Sources.Select(s => Enum.TryParse<RewardSource>(s, out var src) ? src : (RewardSource?)null)
                                                  .Where(x => x.HasValue)
                                                  .Select(x => x.Value)
                                                  .ToList();
                if (sourceEnums.Count > 0)
                {
                    filter &= Builders<UserReward>.Filter.In(x => x.Source, sourceEnums);
                }
            }

           

            if (param.CurrencyType.HasValue)
            {
                filter &= Builders<UserReward>.Filter.Eq(x => x.CurrencyType, param.CurrencyType.Value);
            }

            if (param.TimeStart.HasValue)
            {
                filter &= Builders<UserReward>.Filter.Gte(x => x.CreateTime, param.TimeStart.Value);
            }
            if (param.TimeEnd.HasValue)
            {
                filter &= Builders<UserReward>.Filter.Lte(x => x.CreateTime, param.TimeEnd.Value);
            }

            var sort = Builders<UserReward>.Sort.Descending(x => x.CreateTime);
            var result = await _rewardMongo.QueryPageAsync(
                filter,
                sort,
                true,
                param.PageSize.Value,
                param.PageIndex.Value
            );

            var list = result.list ?? new List<UserReward>();
            var userIds = list.Select(x => x.UserId).Distinct().ToList();
            var users = await _userMongo.FilterByAsync(x => userIds.Contains(x.Id));
            var userDict = users.ToDictionary(u => u.Id, u => u.BaseInfo?.UserName ?? "");

            if (list == null)
                return this.ToPageResult(new List<UserAssetChangeDto>(), 0);
            var dtos = list.Select(x => new UserAssetChangeDto
            {
                Id = x.Id,
                UserId = x.UserId,
                UserName = userDict.TryGetValue(x.UserId, out var name) ? name : "",
                Type = x.Type,
                ChangeTypeText = x.Type == 1 ? "增加" : "减少",
                Source = x.Source.ToString(),
                CurrencyType = x.CurrencyType,
                CurrencyTypeText = x.CurrencyType == 1 ? "金币" : x.CurrencyType == 2 ? "保险箱金币" : "钻石",
                BeforeCount = x.BeforeCount,
                ChangeCount = x.ChangeCount,
                AfterCount = x.AfterCount,
                Remark = x.Remark,
                CreateTime = x.CreateTime.ToDateTime()
            });

            return this.ToPageResult(dtos, (int)result.count);
        }

        [HttpGet("sources")]
        public BaseResponse<List<SourceOptionDto>> GetSources()
        {
            var sources = Enum.GetValues<RewardSource>()
                .Select(x => new SourceOptionDto { Value = x.ToString(), Label = x.ToString() })
                .ToList();
            return this.ToResult(sources);
        }
    }

    public class UserAssetChangeDto
    {
        public string Id { get; set; }
        public string UserId { get; set; }
        public string UserName { get; set; }
        public int Type { get; set; }
        public string ChangeTypeText { get; set; }
        public string Source { get; set; }
        public int CurrencyType { get; set; }
        public string CurrencyTypeText { get; set; }
        public long BeforeCount { get; set; }
        public long ChangeCount { get; set; }
        public long AfterCount { get; set; }
        public string Remark { get; set; }
        public DateTime CreateTime { get; set; }
    }

    public class SourceOptionDto
    {
        public string Value { get; set; }
        public string Label { get; set; }
    }
}