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

namespace AdminService.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;

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

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



        public async Task<(bool isok, string msg)> AddTask(GameTask param)
        {
            if (string.IsNullOrWhiteSpace(param.Id))
            {
                param.Id = Guid.NewGuid().ToString("N");
                return await _gameTaskMongo.InsertOneAsync(param);
            }
            else
                return await _gameTaskMongo.ReplaceOneAsync(param);
        }
        public async Task<(bool isok, string msg)> DeleteTask(string id)
        {

            return await _gameTaskMongo.DeleteByIdAsync(id);
        }
        public async Task<(bool isok, string msg)> UpdateTaskState(string id, int state)
        {
            var model = await _gameTaskMongo.FindByIdAsync(id);
            if (model == null)
                return (false, "任务不存在");
            model.State = state;
            return await _gameTaskMongo.ReplaceOneAsync(model);
        }
        public async Task<GameTask> GetTask(string id)
        {
            return await _gameTaskMongo.FindByIdAsync(id);
        }

        public async Task<(List<GameTask> list, int count)> GetTaskList(GetTaskListParam param)
        {
            var where = LinqExtensions.True<GameTask>().And(e => e.IsDelete == false);
            if (!string.IsNullOrWhiteSpace(param.KeyWord))
                where = where.And(e => e.Remark.Contains(param.KeyWord));

            if (param.State > -1)
            {
                where = where.And(e => e.State == param.State);
            }
            if (param.TaskType > -1)
            {
                where = where.And(e => (int)e.TaskType == param.TaskType);
            }
            if (param.TaskEvent > -1)
            {
                where = where.And(e => (int)e.TaskEvent == param.TaskEvent);
            }
            var result = await _gameTaskMongo.QueryPageAsync(where, c => c.Number, false, param.PageSize ?? 0, param.PageIndex ?? 0);

            return (result.list, (int)result.count);
        }

        public async Task<(bool isok, string msg)> UpdateTask(GameTask param)
        {
            if (string.IsNullOrWhiteSpace(param.Id))
                return (false, "任务ID不能为空");
            var existing = await _gameTaskMongo.FindByIdAsync(param.Id);
            if (existing == null)
                return (false, "任务不存在");
            param.CreateInfo = existing.CreateInfo;
            return await _gameTaskMongo.ReplaceOneAsync(param);
        }
        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 "没有已启用的每日任务配置，请在任务管理中添加任务";

            var deleteTask = _userTaskMongo.DeleteManyAsync(c => c.TaskType == TaskType.每日任务 || c.TaskType == TaskType.在线时长任务);
            var totalUsers = await _userEntityMongo.CountAsync(LinqExtensions.True<UserEntity>());
            await deleteTask;

            var now = DateTime.Now.Date.ToTimeStamp();
            var tomorrow = now + 86400;
            var pageSize = 500;
            var pageCount = (int)Math.Ceiling((double)totalUsers / pageSize);
            var totalCreated = 0;
            var lockObj = new object();

            await Parallel.ForEachAsync(Enumerable.Range(0, pageCount), new ParallelOptions { MaxDegreeOfParallelism = 4 }, async (page, ct) =>
            {
                var list = await _userEntityMongo.QueryPageAsync(LinqExtensions.True<UserEntity>(), c => c.Id, false, pageSize, page + 1);
                if (list.list.Count == 0) return;

                var batch = new List<UserTask>(list.list.Count * tasks.Count);
                foreach (var user in list.list)
                {
                    foreach (var task in tasks)
                    {
                        batch.Add(new UserTask
                        {
                            Id = Guid.NewGuid().ToString("N"),
                            UserId = user.Id,
                            Number = task.Number,
                            Remark = task.Remark,
                            TaskType = task.TaskType,
                            TaskEvent = task.TaskEvent,
                            TaskCount = task.TaskCount,
                            Exp = task.Exp,
                            Count = 0,
                            IsFinish = false,
                            IsGet = false,
                            TaskAddTime = now,
                            TaskEndTime = tomorrow
                        });
                    }
                }

                if (batch.Count > 0)
                {
                    await _userTaskMongo.InsertManyAsync(batch);
                    lock (lockObj) { totalCreated += batch.Count; }
                }
            });

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

        public async void 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 void 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 Task<string> InitDefaultTasks()
        {
            var defaultTasks = new List<GameTask>
            {
                new GameTask { Id = "", Number = "90001", Remark = "领取整点在线奖励", State = 1, TaskCount = 1, TaskEvent = TaskEvent.整点在线奖励, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90002", Remark = "单次在线30分钟", State = 1, TaskCount = 30, TaskEvent = TaskEvent.在线时长, TaskType = TaskType.在线时长任务 },
                new GameTask { Id = "", Number = "90003", Remark = "捕获任意鱼100只", State = 1, TaskCount = 100, TaskEvent = TaskEvent.捕获任意鱼, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90004", Remark = "捕获黄金鱼5只", State = 1, TaskCount = 5, TaskEvent = TaskEvent.捕获黄金鱼, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90005", Remark = "捕获BOSS鱼1只", State = 1, TaskCount = 1, TaskEvent = TaskEvent.捕获Boss鱼, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90006", Remark = "在游戏内赢取20万金币", State = 1, TaskCount = 200000, TaskEvent = TaskEvent.赢取金币, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90007", Remark = "使用技能狂暴5次", State = 1, TaskCount = 5, TaskEvent = TaskEvent.使用狂暴, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90008", Remark = "游戏内发射炮弹1000发", State = 1, TaskCount = 1000, TaskEvent = TaskEvent.开炮任务, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90009", Remark = "每日登陆游戏一次", State = 1, TaskCount = 1, TaskEvent = TaskEvent.登录任务, TaskType = TaskType.每日任务 },
                new GameTask { Id = "", Number = "90010", Remark = "游戏充值100元", State = 1, TaskCount = 100, TaskEvent = TaskEvent.充值任务, TaskType = TaskType.每日任务 }
            };

            foreach (var task in defaultTasks)
            {
                await AddTask(task);
            }

            return "初始化成功";
        }

    }
}