using AutoMapper;
using Common;
using Common.Utils;
using CommonDomain;
using CommonDomain.BaseModel;
using CommonDomain.Enum;
using DotNetCore.CAP;
using MongoRepository;
using RedisService;
using UserDomain;
using UserDomain.Entity;
using UserDomain.Enum;
using UserService.BattleOrder;
using UserService.Param;
using UserService.Tasks.Param;

namespace UserService.Tasks
{
    public class TaskService : ITaskService
    {

        private readonly IMongoBaseRepository<GameTask> _gameTaskMongo;
        private readonly IMongoBaseRepository<UserTask> _userTaskMongo;
        private readonly IMongoBaseRepository<UserEntity> _userEntityMongo;
        private readonly IMapper _mapper;
        private readonly IRedisService _redisService;
        private readonly ICapPublisher _capPublisher;
        private readonly IBattleOrderService _battleOrderService;

        public TaskService(IMongoBaseRepository<GameTask> gameTaskMongo, IMongoBaseRepository<UserTask> userTaskMongo, IMongoBaseRepository<UserEntity> userEntityMongo, IMapper mapper, IRedisService redisService, ICapPublisher capPublisher, IBattleOrderService battleOrderService)
        {

            _gameTaskMongo = gameTaskMongo;
            _userTaskMongo = userTaskMongo;
            _userEntityMongo = userEntityMongo;
            _mapper = mapper;
            _redisService = redisService;
            _capPublisher = capPublisher;
            _battleOrderService = battleOrderService;
        }


        public async Task<string> DayTaskReward()
        {
            var tasks = _gameTaskMongo.FilterBy(c => (c.TaskType == TaskType.每日任务 || c.TaskType == TaskType.在线时长任务) && c.State == 1)?.ToList();
            if (tasks == null || tasks.Count == 0)
                return "没有已启用的每日任务配置";

            await _userTaskMongo.DeleteManyAsync(c => c.TaskType == TaskType.每日任务 || c.TaskType == TaskType.在线时长任务);

            int totalUsers = 0, totalCreated = 0;
            int i = 0;
            while (true)
            {
                i++;
                List<UserTask> res = new List<UserTask>();
                var list = await _userEntityMongo.QueryPageAsync(LinqExtensions.True<UserEntity>(), c => c.Id, false, 100, i);
                if (list.count == 0 || list.list == null || list.list.Count == 0)
                    break;
                totalUsers += list.list.Count();
                foreach (var user in list.list)
                {
                    foreach (var task in tasks)
                    {
                        var model = _mapper.Map<UserTask>(task);
                        model.Id = Guid.NewGuid().ToString("N");
                        model.UserId = user.Id;
                        model.IsGet = false;
                        model.Count = 0;
                        model.IsFinish = false;
                        model.TaskAddTime = DateTime.Now.Date.ToTimeStamp();
                        model.TaskEndTime = DateTime.Now.Date.AddDays(1).ToTimeStamp();
                        res.Add(model);
                    }
                }
                if (res.Count > 0)
                {
                    await _userTaskMongo.InsertManyAsync(res);
                    totalCreated += res.Count;
                }
            }

            return $"发放完成：找到 {tasks.Count} 个任务，处理 {totalUsers} 个玩家，共创建 {totalCreated} 条任务记录";
        }

        public async Task HourTaskReward()
        {
            var userIds = _redisService.GetAllLoginUserIds();
            if (userIds == null || userIds.Count() == 0)
                return;
            userIds = userIds.Distinct().ToArray();
            var task = await _gameTaskMongo.FindOneAsync(c => (c.TaskEvent == TaskEvent.整点在线奖励) && c.State == 1);
            if (task == null)
                return;
            List<UserTask> res = new List<UserTask>();

            var now = DateTime.Now.Hour;


            foreach (var id in userIds)
            {

                var model = _mapper.Map<UserTask>(task);
                model.Id = Guid.NewGuid().ToString("N");
                model.UserId = id;
                model.Remark = $"{now}点在线奖励";
                model.IsGet = false;
                model.Count = 0;
                model.IsFinish = true;
                model.TaskAddTime = DateTime.Now.Date.ToTimeStamp();
                model.TaskEndTime = DateTime.Now.Date.AddDays(1).ToTimeStamp();
                res.Add(model);

            }
            if (res.Count > 0)
                await _userTaskMongo.InsertManyAsync(res);

        }


        public async Task RegisterTaskReward(string userId)
        {
            var tasks = _gameTaskMongo.FilterBy(c => c.State == 1);
            List<UserTask> res = new List<UserTask>();
            foreach (var task in tasks)
            {
                var model = _mapper.Map<UserTask>(task);
                model.Id = Guid.NewGuid().ToString("N");
                model.UserId = userId;
                model.IsGet = false;
                model.Count = 0;
                model.IsFinish = false;
                model.TaskAddTime = DateTime.Now.Date.ToTimeStamp();
                if (model.TaskType == TaskType.每日任务 || model.TaskType == TaskType.在线时长任务)
                    model.TaskEndTime = DateTime.Now.Date.AddDays(1).ToTimeStamp();
                else
                    model.TaskEndTime = DateTime.Now.Date.AddYears(100).ToTimeStamp();
                res.Add(model);
            }
            if (res.Count > 0)
                await _userTaskMongo.InsertManyAsync(res);
        }


        public async Task<List<UserTask>> GetUserTaskList(GetUserTaskListParam param, string userId)
        {
            var where = LinqExtensions.True<UserTask>().And(e => e.IsDelete == false);


            if (param.TaskType > -1)
            {
                where = where.And(e => (int)e.TaskType == param.TaskType);
            }
            if (!string.IsNullOrEmpty(userId))
                where = where.And(e => e.UserId == userId);

            var result = _userTaskMongo.FilterBy(where).ToList();
            if (result != null && result.Count() > 0)
                result = result.OrderByDescending(c => c.IsFinish ? 1 : 0).ThenByDescending(c => c.IsGet ? 1 : 0).ToList();
            return result;
        }
        public async void CompletedTask(CompletedTaskParam param)
        {

            var list = _userTaskMongo.FilterBy(c => c.TaskEvent == param.taskEvent && c.UserId == param.userId && c.IsFinish == false);
            if (list == null || list.Count() == 0)
                return;

            foreach (var item in list)
            {
                item.Count += param.count;
                if (item.Count >= item.TaskCount)
                {
                    item.IsFinish = true;
                    item.TaskFinishTime = DateTime.Now.ToTimeStamp();
                    
                    if (item.Exp > 0 && _battleOrderService != null)
                    {
                        await _battleOrderService.AddExpAsync(param.userId, item.Exp);
                    }
                }
                else
                    continue;
                item.OtherId = param.otherId;
                await _userTaskMongo.ReplaceOneAsync(item);

                if (item.TaskType == TaskType.在线时长任务)
                {
                    await DistributeRewards(item.Id, param.userId);
                }
            }
        }


        public async Task<(bool isok, string msg)> DistributeRewards(string id, string userId)
        {
            var model = await _userTaskMongo.FindByIdAsync(id);
            if (model == null)
                return (false, "任务不存在");
            if (model.IsFinish == false)
                return (false, "任务未完成");
            if (model.IsGet)
                return (false, "奖励已领取");   GiftResponse result = new GiftResponse();

            model.IsGet = true;
            {
                if (model.Exp > 0 && _battleOrderService != null)
                {
                    var expResult = await _battleOrderService.AddExpAsync(userId, model.Exp);
                    result.Exp = model.Exp;
                }
            }

            var re = await _userTaskMongo.ReplaceOneAsync(model);

            return (re.ok, re.message);

        }

        public async Task<(bool success, string message, long totalExp)> ReceiveAllTaskRewardsAsync(string userId)
        {
            var tasks = _userTaskMongo.FilterBy(c => c.UserId == userId 
                && c.IsFinish == true && c.IsGet == false && c.Exp > 0);

            if (tasks == null || !tasks.Any())
                return (false, "没有可领取的任务", 0);

            long totalExp = 0;
            var taskList = tasks.ToList();
            foreach (var task in taskList)
            {
                task.IsGet = true;
                totalExp += task.Exp;
                await _userTaskMongo.ReplaceOneAsync(task);
            }

            if (totalExp > 0 && _battleOrderService != null)
            {
                await _battleOrderService.AddExpAsync(userId, totalExp);
            }

            return (true, $"领取成功，共获得{totalExp}战令经验", totalExp);
        }


    }
}