using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace Snxxz.UI
{
    public class TaskFeedbackModel : Model
    {
        Dictionary<int, TaskFeedback> m_TaskFeedbacks = new Dictionary<int, TaskFeedback>();

        public readonly List<int> taskFeedbackFuncs = new List<int>();

        ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        AlchemyModel alchemyModel { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }
        EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
        EquipStrengthModel equipStrengthModel { get { return ModelCenter.Instance.GetModel<EquipStrengthModel>(); } }

        public override void Init()
        {
            ParseConfig();
        }

        public override void UnInit()
        {
        }

        void ParseConfig()
        {
            var configs = TaskFeedbackConfig.GetValues();
            foreach (var config in configs)
            {
                if (config.type == 100)
                {
                    continue;
                }

                var feedback = new TaskFeedback()
                {
                    taskId = config.taskId,
                    type = (TaskFeedbackType)config.type,
                };

                switch (feedback.type)
                {
                    case TaskFeedbackType.SideTask:
                    case TaskFeedbackType.FightPowerSideTask:
                        {
                            var array = LitJson.JsonMapper.ToObject<int[][]>(config.sideTasks);
                            if (array != null)
                            {
                                List<int[]> sideTasks = new List<int[]>(array.Length);
                                for (int i = 0; i < array.Length; i++)
                                {
                                    sideTasks.Add(array[i]);
                                }
                                feedback.sideTasks = sideTasks;
                            }
                        }
                        break;
                    case TaskFeedbackType.Equip:
                        {
                            var array = LitJson.JsonMapper.ToObject<int[]>(config.equips);
                            feedback.equipCondition = array;
                        }
                        break;
                    case TaskFeedbackType.ItemCount:
                    case TaskFeedbackType.AlchemyItem:
                        {
                            var array = LitJson.JsonMapper.ToObject<int[][]>(config.items);
                            if (array != null)
                            {
                                List<Item> items = new List<Item>();
                                for (int i = 0; i < array.Length; i++)
                                {
                                    items.Add(new Item()
                                    {
                                        id = array[i][0],
                                        count = array[i][1],
                                    });
                                }
                                feedback.items = items;
                            }
                        }
                        break;
                    case TaskFeedbackType.ReikiPoint:
                        {
                            if (!string.IsNullOrEmpty(config.reikiRoot))
                            {
                                var json = LitJson.JsonMapper.ToObject(config.reikiRoot);
                                feedback.reikiRoots = new Dictionary<int, List<int[]>>();
                                foreach (var jobKey in json.Keys)
                                {
                                    var job = int.Parse(jobKey);
                                    var intArray = LitJson.JsonMapper.ToObject<int[][]>(json[jobKey].ToJson());
                                    feedback.reikiRoots.Add(job, new List<int[]>());
                                    for (int i = 0; i < intArray.Length; i++)
                                    {
                                        feedback.reikiRoots[job].Add(intArray[i]);
                                    }
                                }
                            }
                        }
                        break;
                }

                if (!string.IsNullOrEmpty(config.failFuncs))
                {
                    var funcArray = LitJson.JsonMapper.ToObject<int[][]>(config.failFuncs);
                    if (funcArray != null)
                    {
                        List<int[]> failFuncs = new List<int[]>(funcArray.Length);
                        for (int i = 0; i < funcArray.Length; i++)
                        {
                            failFuncs.Add(funcArray[i]);
                        }
                        feedback.failFuns = failFuncs;
                    }
                }

                m_TaskFeedbacks.Add(config.taskId, feedback);
            }
        }

        public bool TryGetTaskFeedback(int taskId, out TaskFeedback feedback)
        {
            return m_TaskFeedbacks.TryGetValue(taskId, out feedback);
        }

        public void ExecuteTaskFeedback(int taskId)
        {
            if (NewBieCenter.Instance.inGuiding || FunctionalGuideCenter.Instance.ExistAnyUnderwayGuide())
            {
                return;
            }

            TaskFeedback feedback;
            if (TryGetTaskFeedback(taskId, out feedback))
            {
                var config = TaskFeedbackConfig.Get(taskId);

                switch (feedback.type)
                {
                    case TaskFeedbackType.FightPower:
                    case TaskFeedbackType.Copper:
                    case TaskFeedbackType.ReikiPoint:
                    case TaskFeedbackType.Guide:
                    case TaskFeedbackType.Equip:
                    case TaskFeedbackType.ItemCount:
                    case TaskFeedbackType.SkyTowerFightPoint:
                    case TaskFeedbackType.DemonTreasure:
                        {
                            int condition = 0;
                            if (IsSatisfyCondition(feedback, out condition))
                            {
                                ExecuteSuccFeedback(taskId);
                            }
                            else
                            {
                                if (config.remind != null && config.remind.Length > 0)
                                {
                                    var index = Mathf.Min(condition, config.remind.Length - 1);
                                    SysNotifyMgr.Instance.ShowTip(config.remind[index]);
                                }
                                if (feedback.failFuns != null)
                                {
                                    var index = Mathf.Min(condition, feedback.failFuns.Count - 1);
                                    List<int> succFuncs;
                                    if (TryGetSatisfyConditionFuncs(feedback.failFuns[index], out succFuncs))
                                    {
                                        taskFeedbackFuncs.Clear();
                                        taskFeedbackFuncs.AddRange(succFuncs);
                                        WindowCenter.Instance.Open<TaskFeedbackFuncWin>();
                                    }
                                }
                            }
                        }
                        break;
                    case TaskFeedbackType.AlchemyItem:
                        {
                            int condition = 0;
                            if (IsSatisfyCondition(feedback, out condition))
                            {
                                ExecuteSuccFeedback(taskId);
                            }
                            else
                            {
                                Int2 position;
                                if (alchemyModel.IsStoveAlcheming((AlchemyType)config.condition, out position))
                                {
                                    if (config.jump != 0)
                                    {
                                        WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)config.jump);
                                        return;
                                    }
                                }
                                if (config.remind != null && config.remind.Length > 0)
                                {
                                    var index = Mathf.Min(condition, config.remind.Length - 1);
                                    SysNotifyMgr.Instance.ShowTip(config.remind[index]);
                                }
                                if (feedback.failFuns != null)
                                {
                                    var index = Mathf.Min(condition, feedback.failFuns.Count - 1);
                                    List<int> succFuncs;
                                    if (TryGetSatisfyConditionFuncs(feedback.failFuns[index], out succFuncs))
                                    {
                                        taskFeedbackFuncs.Clear();
                                        taskFeedbackFuncs.AddRange(succFuncs);
                                        WindowCenter.Instance.Open<TaskFeedbackFuncWin>();
                                    }
                                }
                            }
                        }
                        break;
                    case TaskFeedbackType.SideTask:
                        {
                            int condition = 0;
                            if (IsSatisfyCondition(feedback, out condition))
                            {
                                ExecuteSuccFeedback(taskId);
                            }
                            else
                            {
                                if (config.remind != null && config.remind.Length > 0)
                                {
                                    var taskIndex = feedback.IndexOfSideTasks(condition);
                                    var index = Mathf.Min(taskIndex, config.remind.Length - 1);
                                    SysNotifyMgr.Instance.ShowTip(config.remind[index]);
                                }
                                if (feedback.failFuns != null)
                                {
                                    var taskIndex = feedback.IndexOfSideTasks(condition);
                                    var index = Mathf.Min(taskIndex, feedback.failFuns.Count - 1);
                                    List<int> succFuncs;
                                    if (TryGetSatisfyConditionFuncs(feedback.failFuns[index], out succFuncs))
                                    {
                                        taskFeedbackFuncs.Clear();
                                        taskFeedbackFuncs.AddRange(succFuncs);
                                        WindowCenter.Instance.Open<TaskFeedbackFuncWin>();
                                    }
                                }
                            }
                        }
                        break;
                    case TaskFeedbackType.FightPowerSideTask:
                        {
                            int condition = 0;
                            if (IsSatisfyCondition(feedback, out condition))
                            {
                                ExecuteSuccFeedback(taskId);
                            }
                            else
                            {
                                if (config.remind != null && config.remind.Length > 0)
                                {
                                    var index = Mathf.Min(condition, config.remind.Length - 1);
                                    SysNotifyMgr.Instance.ShowTip(config.remind[index]);
                                }
                                if (feedback.failFuns != null)
                                {
                                    var sideTaskId = 0;
                                    IsSatisfySideTask(feedback.sideTasks, out sideTaskId);
                                    var taskIndex = feedback.IndexOfSideTasks(sideTaskId);
                                    var index = Mathf.Min(taskIndex, feedback.failFuns.Count - 1);
                                    List<int> succFuncs;
                                    if (TryGetSatisfyConditionFuncs(feedback.failFuns[index], out succFuncs))
                                    {
                                        taskFeedbackFuncs.Clear();
                                        taskFeedbackFuncs.AddRange(succFuncs);
                                        WindowCenter.Instance.Open<TaskFeedbackFuncWin>();
                                    }
                                }
                            }
                        }
                        break;
                }
            }
        }

        public void ExecuteSuccFeedback(int id)
        {
            var config = TaskFeedbackConfig.Get(id);
            var guide = config.succGuide;
            if (guide != 0 && !NewBieCenter.Instance.IsGuideCompleted(guide))
            {
                ExecuteGuide(guide);
            }
            else
            {
                if (config.jump != 0)
                {
                    WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)config.jump);
                }
            }
        }

        public void ExecuteGuide(int id)
        {
            if (id == 0)
            {
                return;
            }
            var config = GuideConfig.Get(id);
            if (config == null)
            {
                DebugEx.LogFormat("引导<color=#ff0000>{0}</color>未添加", id);
                return;
            }
            switch ((GuideType)config.Type)
            {
                case GuideType.Functional:
                    FunctionalGuideCenter.Instance.StartGuide(id);
                    break;
                default:
                    NewBieCenter.Instance.StartNewBieGuide(id);
                    break;
            }
        }

        public bool IsSatisfyCondition(TaskFeedback feedback, out int condition)
        {
            var config = TaskFeedbackConfig.Get(feedback.taskId);
            condition = 0;
            switch (feedback.type)
            {
                case TaskFeedbackType.FightPower:
                    return PlayerDatas.Instance.baseData.FightPoint >= config.condition;
                case TaskFeedbackType.SideTask:
                    return IsSatisfySideTask(feedback.sideTasks, out condition);
                case TaskFeedbackType.ReikiPoint:
                    {
                        if (reikiRootModel.GetReikiRootTotalPointWithFree() < config.condition)
                        {
                            return false;
                        }
                        if (feedback.reikiRoots != null)
                        {
                            var job = PlayerDatas.Instance.baseData.Job;
                            var reikiRoots = feedback.reikiRoots[job];
                            foreach (var reikiRoot in reikiRoots)
                            {
                                if (reikiRootModel.GetReikiRootPoint(reikiRoot[0]) < reikiRoot[1])
                                {
                                    condition = 1;
                                    return false;
                                }
                            }
                        }
                    }
                    return true;
                case TaskFeedbackType.Equip:
                    {
                        var items = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
                        {
                            levels = new List<int>() { feedback.equipCondition[0] },
                            qualitys = new List<int>() { feedback.equipCondition[1] },
                            equipTypes = EquipModel.realmEquipTypes,
                            jobs = new List<int>() { PlayerDatas.Instance.baseData.Job },
                        });
                        return items != null && items.Count > 0;
                    }
                case TaskFeedbackType.Copper:
                    return PlayerDatas.Instance.baseData.allCopper >= (ulong)config.condition;
                case TaskFeedbackType.Guide:
                    return true;
                case TaskFeedbackType.FightPowerSideTask:
                    return PlayerDatas.Instance.baseData.FightPoint >= config.condition;
                case TaskFeedbackType.AlchemyItem:
                case TaskFeedbackType.ItemCount:
                    {
                        if (feedback.items != null)
                        {
                            foreach (var item in feedback.items)
                            {
                                if (packModel.GetItemCountByID(PackType.Item, item.id) < item.count)
                                {
                                    return false;
                                }
                            }
                        }
                        return true;
                    }
                case TaskFeedbackType.SkyTowerFightPoint:
                    {
                        var skyTowerConfig = SkyTowerConfig.Get(config.condition);
                        if (skyTowerConfig != null)
                        {
                            return PlayerDatas.Instance.baseData.FightPoint >= skyTowerConfig.fightPower;
                        }
                    }
                    break;
                case TaskFeedbackType.DemonTreasure:
                    {
                        TreasureDungeon treasureDungeon;
                        if (treasureModel.TryGetTreasureDungeon(config.condition, out treasureDungeon))
                        {
                            var dungeonInfo = treasureDungeon.Get(treasureDungeon.currentLevel + 1);
                            if (!dungeonInfo.Equals(default(TreasureDungeonInfo)))
                            {
                                return UIHelper.GetPropertyValue(PropertyType.DEF) >= dungeonInfo.defense;
                            }
                            return true;
                        }
                    }
                    break;
            }
            return false;
        }

        public bool IsSatisfySideTask(List<int[]> sideTasks, out int condition)
        {
            condition = 0;
            foreach (var taskId in taskModel.SideQuestsDic.Keys)
            {
                for (int i = 0; i < sideTasks.Count; i++)
                {
                    if (taskId >= sideTasks[i][0]
                        && taskId <= sideTasks[i][1])
                    {
                        condition = taskId;
                        return false;
                    }
                }
            }
            return true;
        }

        public bool TryGetSatisfyConditionFuncs(int[] funcs, out List<int> succFuncs)
        {
            succFuncs = null;
            if (funcs != null && funcs.Length > 0)
            {
                succFuncs = new List<int>();
                for (int i = 0; i < funcs.Length; i++)
                {
                    if (IsSatisfyFuncConfition(funcs[i]))
                    {
                        succFuncs.Add(funcs[i]);
                    }
                }
                return succFuncs.Count > 0;
            }
            return false;
        }

        public bool IsSatisfyFuncConfition(int func)
        {
            var config = TaskFeedbackFuncConfig.Get(func);
            if (config != null)
            {
                switch (config.type)
                {
                    case 1:
                        foreach (var item in config.itemCondition)
                        {
                            var count = packModel.GetItemCountByID(PackType.Item, item.x);
                            if (count < item.y)
                            {
                                return false;
                            }
                        }
                        return true;
                    case 2:
                        return reikiRootModel.freePoint > 0;
                    case 3:
                        foreach (var equipSet in equipModel.GetUnLockedEquipSets())
                        {
                            if (equipModel.ExistBetterEquip(equipSet, EquipModel.realmEquipTypes))
                            {
                                return true;
                            }
                        }
                        return false;
                    case 4:
                        MissionDetailDates taskData;
                        if (taskModel.TryGetTaskData(config.condition, out taskData))
                        {
                            return taskData.MissionState != 3;
                        }
                        return false;
                    case 5:
                        return equipStrengthModel.ExistAnySatisfyStrengh();
                    default:
                        return true;
                }
            }
            return false;
        }
    }

    public struct TaskFeedback
    {
        public int taskId;
        public TaskFeedbackType type;
        public List<int[]> sideTasks;
        public int[] equipCondition;
        public List<Item> items;
        public Dictionary<int, List<int[]>> reikiRoots;
        public List<int[]> failFuns;

        public int IndexOfSideTasks(int taskId)
        {
            var index = 0;
            for (int i = 0; i < sideTasks.Count; i++)
            {
                if (taskId >= sideTasks[i][0]
                   && taskId <= sideTasks[i][1])
                {
                    index += taskId - sideTasks[i][0];
                    break;
                }
                index += (sideTasks[i][1] - sideTasks[i][0] + 1);
            }
            return index;
        }
    }

    public enum TaskFeedbackType
    {
        FightPower = 1,
        SideTask = 2,
        ReikiPoint = 3,
        Equip = 4,
        Copper = 5,
        Guide = 6,
        FightPowerSideTask = 7,
        ItemCount = 8,
        SkyTowerFightPoint = 9,
        DemonTreasure = 10,
        AlchemyItem = 11,
    }
}