using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using System;
using System.Threading.Tasks;
using Common.Utility.CombatEvent;
using Excel2Json;
using Fort23.Core;
using Fort23.Mono;
using Fort23.UTool;
using GameLogic.Bag;
using GameLogic.Combat;
using GameLogic.Combat.CombatTool;
using GameLogic.Player;
using Utility;

public class TaskManager : Singleton<TaskManager>
{
    private List<TaskConfig> allTasks;
    private Dictionary<int, AccountFileInfo.TaskData> allTsk;


    public TaskManager()
    {
        allTasks = ConfigComponent.Instance.GetAll<TaskConfig>().ToList();
        allTsk = new Dictionary<int, AccountFileInfo.TaskData>();

        foreach (var playerDataTask in AccountFileInfo.Instance.playerData.tasks)
        {
            allTsk.Add(playerDataTask.taskID, playerDataTask);
        }

        EventManager.Instance.AddEventListener(CustomEventType.ItemUpdate, ItemUpdate);
        EventManager.Instance.AddEventListener(CustomEventType.JingJieUpgrade, JingJieUpgrade);
    }

    private void JingJieUpgrade(IEventData e)
    {
        CeekTaskComplete(4, 0);
    }

    private void ItemUpdate(IEventData e)
    {
        ItemUpdateData data = e as ItemUpdateData;
        CeekTaskComplete(1, data.ItemInfo.itemID);
        CeekTaskComplete(5, data.ItemInfo.itemID);
    }


    // 接取任务
    public void AcceptTask(int taskID)
    {
        if (!allTsk.ContainsKey(taskID))
        {
            AccountFileInfo.TaskData taskData = new AccountFileInfo.TaskData();
            taskData.taskID = taskID;
            allTsk.Add(taskID, taskData);
            AccountFileInfo.Instance.playerData.tasks.Clear();
            AccountFileInfo.Instance.playerData.tasks.AddRange(allTsk.Values);
            AccountFileInfo.Instance.SavePlayerData();
            EventManager.Instance.Dispatch(CustomEventType.TaskUpdate, null);

            CeekTaskComplete(4, 0);
        }
    }


    public void TriggerTask(int taskId)
    {
        if (allTsk.ContainsKey(taskId))
        {
            TaskConfig taskConfig = ConfigComponent.Instance.Get<TaskConfig>(taskId);
            EventSystemManager.Instance.isOpenUi = true;
            if (taskConfig.finishConditionType == 3)
            {
                if (!IsTaskTrigger(taskId))
                {
                    return;
                }

                //触发对话
                DialoguePanel.OpenDialoguePanel(taskConfig.finishVlaue, null, ShowDialogueEventData.MessageShowType.Verbatim, (int? s) =>
                {
                    CeekTaskComplete(3, taskConfig.ID);
                    EventSystemManager.Instance.isOpenUi = false;
                });
            }
            else if (taskConfig.finishConditionType == 2)
            {
                if (!IsTaskTrigger(taskId))
                {
                    return;
                }

                CombatDrive.Instance.LoadLevelBattleCombat(taskConfig.finishVlaue[0], (iswin) =>
                {
                    if (iswin)
                    {
                        CeekTaskComplete(2, taskConfig.finishVlaue[0]);
                        CombatDrive.Instance.CombatController.ChangeState(CombatController.update);
                        EventSystemManager.Instance.isOpenUi = false;
                    }
                });
                //进入战斗
            }
            //不能直接做任务 通过其他系统检测完成任务条件
            //这里直接弹出提示
            else
            {
                EventSystemManager.Instance.isOpenUi = false;
                TaskInfoPanel.OpenPanel(taskId, "任务信息");
            }
        }
    }


    public void CeekTaskComplete(int type, int value)
    {
        List<AccountFileInfo.TaskData> tasks = allTsk.Values.ToList();
        foreach (var taskData in tasks)
        {
            //任务完成了跳过检测
            if (IsTaskComplete(taskData.taskID))
                continue;
            TaskConfig taskConfig = ConfigComponent.Instance.Get<TaskConfig>(taskData.taskID);
            switch (type)
            {
                //获得道具
                case 1:
                    if (taskConfig.finishConditionType == 1 && taskConfig.finishVlaue[0] == value)
                    {
                        taskData.fishCount++;

                        if (IsTaskComplete(taskData.taskID))
                        {
                            CompleteTask(taskData.taskID);
                        }
                    }

                    break;
                //战斗胜利
                case 2:
                    if (taskConfig.finishConditionType == 2 && taskConfig.finishVlaue[0] == value)
                    {
                        taskData.fishCount++;

                        if (IsTaskComplete(taskData.taskID))
                        {
                            CompleteTask(taskData.taskID);
                        }
                    }

                    break;
                //对话 
                case 3:
                    if (taskConfig.finishConditionType == 3 && taskConfig.ID == value)
                    {
                        taskData.fishCount++;

                        if (IsTaskComplete(taskData.taskID))
                        {
                            CompleteTask(taskData.taskID);
                        }
                    }

                    break;
                //境界检测
                case 4:
                    if (taskConfig.finishConditionType == 4 && PlayerManager.Instance.myHero.powerUpConfig.ID >= taskConfig.finishVlaue[0])
                    {
                        taskData.fishCount++;

                        if (IsTaskComplete(taskData.taskID))
                        {
                            CompleteTask(taskData.taskID);
                        }
                    }

                    break;
                //检测背包道具
                case 5:
                    if (taskConfig.finishConditionType == 5)
                    {
                        taskData.fishCount += (int)PlayerManager.Instance.BagController.GetItemCount(taskConfig.finishVlaue[0]);

                        if (IsTaskComplete(taskData.taskID))
                        {
                            CompleteTask(taskData.taskID);
                        }
                    }

                    break;
            }
        }


        AccountFileInfo.Instance.SavePlayerData();
    }

    // 完成任务
    private async void CompleteTask(int taskID)
    {
        TaskConfig taskConfig = ConfigComponent.Instance.Get<TaskConfig>(taskID);


        List<ItemInfo> awardList = GrantReward(taskID);
        //可能需要处理弹出任务完成ui
        if (awardList != null)
        {
            TaskInfoPanel taskInfoPanel = await TaskInfoPanel.OpenPanel(taskID, "任务完成");
            // await taskInfoPanel.UIClosed();
        }


        // 触发下一个任务（主线）
        if (taskConfig.nextTaskID != 0)
        {
            AcceptTask(taskConfig.nextTaskID);
        }
    }


    // 发放奖励
    private List<ItemInfo> GrantReward(int taskID)
    {
        TaskConfig taskConfig = ConfigComponent.Instance.Get<TaskConfig>(taskID);
        if (taskConfig.awardItemId != null && taskConfig.awardItemId.Length > 0)
        {
            List<ItemInfo> itemInfos = new List<ItemInfo>();
            for (var i = 0; i < taskConfig.awardItemId.Length; i++)
            {
                DropConfig dropConfig = ConfigComponent.Instance.Get<DropConfig>(taskConfig.awardItemId[i]);
                if (dropConfig.dropType == 3)
                {
                    ItemInfo itemInfo = new ItemInfo(dropConfig.dropGroupID[0], taskConfig.awardItemCount[i]);
                    itemInfos.Add(itemInfo);
                }
                else
                {
                    List<ItemInfo> items = DropManager.Instance.DropItem(taskConfig.awardItemCount[i]);
                    itemInfos.AddRange(items);
                }
            }

            return itemInfos;
        }

        return null;
    }

    private bool IsTaskTrigger(int taskId)
    {
        TaskConfig taskConfig = ConfigComponent.Instance.Get<TaskConfig>(taskId);
        if (taskConfig.unlockType == 1)
        {
            return PlayerManager.Instance.myHero.powerUpConfig.ID >= taskConfig.unlockLevel;
        }

        return true;
    }

    //获取任务数据
    public AccountFileInfo.TaskData GetTaskData(int taskID)
    {
        if (allTsk.ContainsKey(taskID))
        {
            return allTsk[taskID];
        }

        return null;
    }

    //任务是否完成
    public bool IsTaskComplete(int taskID)
    {
        if (allTsk.ContainsKey(taskID))
        {
            TaskConfig taskConfig = ConfigComponent.Instance.Get<TaskConfig>(taskID);
            return allTsk[taskID].fishCount >= taskConfig.finishCount;
        }

        return false;
    }

    //获得主线任务
    public AccountFileInfo.TaskData GetMainTaskData()
    {
        foreach (var keyValuePair in allTsk)
        {
            TaskConfig taskConfig = ConfigComponent.Instance.Get<TaskConfig>(keyValuePair.Key);
            if (taskConfig.taskType == 10 && !IsTaskComplete(keyValuePair.Key))
            {
                return keyValuePair.Value;
            }
        }

        return null;
    }
}