using Microsoft.CodeAnalysis.CSharp.Syntax;
using Cal.DataTable;
using System;
using System.Collections.Generic;
using System.Text;

namespace ET
{
    namespace EventType
    {
        public struct CompleteTask
        {
            public Unit unit;
            public TaskBase taskBase;
            public System.Collections.Generic.List<int> indexList;
        }
    }
    public class TaskComponentAwakeSystem : AwakeSystem<TaskComponent>
    {
        public override void Awake(TaskComponent self)
        {
            TaskComponent.Instance = self;
            self.Awake();
        }
    }
    public class TaskComponentLoadSystem : LoadSystem<TaskComponent>
    {
    	public override void Load(TaskComponent self)
    	{
    		self.Load();
    	}
    }
    public static class TaskComponentSystem
    {
        public static void Awake(this TaskComponent self)
        {
            self.Load();
        }
        public static void Load(this TaskComponent self)
        {
            self.TaskBaseNpcIdDic.Clear();
            IEnumerable<TaskBase> arr = DataTableHelper.GetAll<TaskBase>();
            foreach (TaskBase taskBase in arr)
            {
                self.TaskBaseNpcIdDic.Add(taskBase.GiveNPCId, taskBase);
                self.TaskBaseNpcIdDic.Add(taskBase.SubmitNPCId, taskBase);
            }
        }
        public static void SendTaskState(this TaskComponent self, Unit unit, int npcId)
        {
            M2C_SendTaskState sendTaskState = new M2C_SendTaskState();
            sendTaskState.NPCState = new NPCTask();
            self.GetNPCState(unit, npcId, sendTaskState.NPCState);
            MessageHelper.SendActor(unit, sendTaskState);
        }
        public static void GetNPCState(this TaskComponent self, Unit unit, System.Collections.Generic.List<NPCTask> npcList)
        {
            foreach (KeyValuePair<int, List<TaskBase>> kp in self.TaskBaseNpcIdDic.GetDictionary())
            {
                NPCTask npcTask = new NPCTask();
                self.GetNPCState(unit, kp.Key, npcTask);
                npcList.Add(npcTask);
            }
        }
        public static void GetNPCState(this TaskComponent self, Unit unit, int npcId, NPCTask npcTask)
        {
            UnitTask unitTask = unit.GetComponent<UnitTask>();
            NumericComponent num = unit.GetComponent<NumericComponent>();
            List<TaskBase> list = self.TaskBaseNpcIdDic[npcId];
            if (list == null)
            {
                return;
            }
            npcTask.Id = npcId;
            bool isFinish = false, isRunning = false, isWaitting = false;
            foreach (TaskBase taskBase in list)
            {
                //!前置条件
                if (taskBase.PreTaskId != 0 &&
                    !unitTask.FinishTaskIdList.Contains(taskBase.PreTaskId))
                {
                    continue;
                }
                //!限制等级
                if (num.GetAsInt(NumericType.Level) < taskBase.Level)
                {
                    continue;
                };
                //!日常任务特殊处理
                switch (taskBase.TaskFinishCount)
                {
                    case 0:
                        break;
                    case -1:
                        //!多次
                        break;
                    case 1:
                        if (unitTask.FinishTaskIdList.Contains((int)taskBase.Id))
                        {
                            continue;
                        }
                        break;
                }
                bool ___isRuning = false;
                //!是否完成了
                if (unitTask.CompleteTaskIdList.Contains((int)taskBase.Id))
                {
                    isFinish = true;
                }
                else
                {
                    //!是否进行中
                    foreach (Task item in unitTask.RunningTaskList)
                    {
                        if (item.Id == taskBase.Id)
                        {
                            isRunning = true;
                            ___isRuning = true;
                            break;
                        }
                    }
                }
                isWaitting = !___isRuning;
            }
            if (isRunning)
            {
                npcTask.TaskState = TaskState.TaskRunning;
            }
            if (isWaitting)
            {
                npcTask.TaskState = TaskState.TaskWaiting;
            }
            if (isFinish)
            {
                npcTask.TaskState = TaskState.TaskCompleted;
            }
        }
        /// <summary>
        /// 获取能够接受和能够领取奖励的任务
        /// </summary>
        /// <param name="self"></param>
        /// <param name="unit"></param>
        /// <param name="inpcId">NPCId</param>
        /// <returns></returns>
        public static List<NPCTask> CanAcceptTask(this TaskComponent self, Unit unit, int inpcId)
        {
            List<NPCTask> _list = new List<NPCTask>();
            List<TaskBase> taskList = self.TaskBaseNpcIdDic[inpcId];
            if (taskList != null)
            {
                UnitTask unitTask = unit.GetComponent<UnitTask>();
                NumericComponent num = unit.GetComponent<NumericComponent>();
                foreach (TaskBase taskBase in taskList)
                {
                    //!前置条件
                    if (taskBase.PreTaskId != 0 &&
                        !unitTask.FinishTaskIdList.Contains(taskBase.PreTaskId)) continue;
                    //!限制等级
                    if (num.GetAsInt(NumericType.Level) < taskBase.Level) continue;
                    //!日常任务特殊处理
                    switch (taskBase.TaskFinishCount)
                    {
                        case 0:
                            break;
                        case -1:
                            //!多次
                            break;
                        case 1:
                            if (unitTask.FinishTaskIdList.Contains((int)taskBase.Id))
                                continue;
                            break;
                    }
                    bool isDitast = false;
                    //!判断重复
                    foreach (NPCTask item in _list)
                    {
                        if (item.Id == taskBase.Id) isDitast = true;
                    }
                    if (isDitast) continue;
                    NPCTask nPCTask = new NPCTask
                    {
                        Id = (int)taskBase.Id,
                        TaskState = TaskState.TaskWaiting
                    };
                    //!是否完成了
                    if (unitTask.CompleteTaskIdList.Contains((int)taskBase.Id))
                        nPCTask.TaskState = TaskState.TaskCompleted;
                    else
                    {
                        //!是否进行中
                        foreach (Task item in unitTask.RunningTaskList)
                        {
                            if (item.Id == taskBase.Id)
                            {
                                nPCTask.TaskState = TaskState.TaskRunning;
                                break;
                            }
                        }
                    }
                    _list.Add(nPCTask);
                }
            }
            return _list;
        }

        /// <summary>
        /// 接受任务
        /// </summary>
        /// <param name="self"></param>
        /// <param name="unitTask"></param>
        public static bool AcceptTask(this TaskComponent self, Unit unit, int taskId)
        {
            UnitTask unitTask = unit.GetComponent<UnitTask>();
            TaskBase taskBase = DataTableHelper.Get<TaskBase>(taskId);
            if (taskBase == null) return false;
            NumericComponent num = unit.GetComponent<NumericComponent>();
            //!前置条件
            if (taskBase.PreTaskId != 0 &&
                !unitTask.FinishTaskIdList.Contains(taskBase.PreTaskId)) return false;
            //!限制等级
            if (num.GetAsInt(NumericType.Level) < taskBase.Level) return false;
            //!日常任务特殊处理
            switch (taskBase.TaskFinishCount)
            {
                case 0:
                    DateTime lastDate = DateTimeOffset.FromUnixTimeMilliseconds(unitTask.DateTimeArr[taskBase.DaliyTaskIndex]).UtcDateTime.Date;
                    if (DateTime.UtcNow < lastDate.AddDays(1))
                    {
                        return false;
                    }
                    unitTask.DateTimeArr[taskBase.DaliyTaskIndex] = TimeHelper.ClientNow();
                    break;
                case 1:
                    if (unitTask.FinishTaskIdList.Contains(taskId))
                        return false;
                    break;
            }
            if (unitTask.CompleteTaskIdList.Contains(taskId)) return false;
            foreach (Task item in unitTask.RunningTaskList)
            {
                if (item.Id == taskId) return false;
            }
            Task task = unitTask.CreateTask(taskBase);
            unitTask.RunningTaskList.Add(task);
            UnitHelper.SaveComponenet(unitTask).Coroutine();

            //!更新客户端
            self.SendTaskState(unit, taskBase.GiveNPCId);
            return true;
        }
        /// <summary>
        /// 放弃任务
        /// </summary>
        /// <param name="self"></param>
        /// <param name="unitId"></param>
        /// <param name="taskId"></param>
        public static void AbandonTask(this TaskComponent self, long unitId, int taskId)
        {
        }
        /// <summary>
        /// 完成任务/领取奖励
        /// </summary>
        /// <param name="self"></param>
        /// <param name="unit"></param>
        /// <param name="taskId"></param>
        public static string CompleteTask(this TaskComponent self, Unit unit, int taskId, System.Collections.Generic.List<int> indexList)
        {
            TaskBase taskBase = DataTableHelper.Get<TaskBase>(taskId);
            if (taskBase == null)
            {
                Log.Error($"taskBase ==null where id ={taskId}");
                return "系统错误";
            }
            if (taskBase.RwardCount != indexList.Count) return "请选择相应数量的奖励！";


            UnitTask unitTask = unit.GetComponent<UnitTask>();
            if (unitTask.CompleteTaskIdList.Remove(taskId))
            {
                unitTask.FinishTaskIdList.Add(taskId);
                UnitHelper.SaveComponenet(unitTask).Coroutine();
                string ret = GetReward(unit, taskBase, indexList);
                if (ret != null)
                {
                    unitTask.CompleteTaskIdList.Add(taskId);
                    unitTask.FinishTaskIdList.Remove(taskId);
                    UnitHelper.SaveComponenet(unitTask).Coroutine();
                    return ret;
                }
                return string.Empty;
            }
            return "系统错误";
        }
        private static string GetReward(Unit unit,TaskBase taskBase,List<int> indexList)
        {
            using ListComponent<(int, long)> listComponent = ListComponent<(int, long)>.Create();
            //!发送奖励信息
            for (int i = 0; i < taskBase.RewardArr.Length; i++)
            {
                if (indexList.Count != 0 && !indexList.Contains(i)) continue;
                TaskBase.Reward reward = taskBase.RewardArr[i];
                listComponent.List.Add((reward.Reward_Id, reward.Reward_Count));
            }
            if(!ItemComponent.Instance.CanAddItem(unit, listComponent.List))
            {
                return ConstDefine.BagFullError;
            }
            for (int i = 0; i < taskBase.RewardArr.Length; i++)
            {
                if (indexList.Count != 0 && !indexList.Contains(i)) continue;
                TaskBase.Reward reward = taskBase.RewardArr[i];
                string ret = BagHelper.AddItem(unit, reward.Reward_Id, reward.Reward_Count, true, getSource: "任务奖励");
                if (ret != null)
                {
                    Log.Error($"{ret}");
                    return ret;
                }
            }

            //!更新客户端
            TaskComponent.Instance.SendTaskState(unit, taskBase.SubmitNPCId);
            return null;
        }

        private static void DeleteGaveItem(Unit unit, List<(int, long)> list)
        {
            foreach ((int id, long count) in list)
            {
                try
                {
                    BagHelper.DeleteItem(unit, id, count);
                }
                catch (Exception e)
                {
                	Log.Error(e);
                }
            }
        }
    }

}