using System.Collections;
using System.Collections.Generic;
using UnityEngine;

using System;
using UnityEngine.UI;
using LitJson;

namespace vnxbqy.UI
{

    public class SkillModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk
    {
        public override void Init()
        {
            ParseConfig();
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            TaskModel.Event_TaskInformation += TaskInformationUpdate;
        }

        public override void UnInit()
        {
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            TaskModel.Event_TaskInformation -= TaskInformationUpdate;
        }

        public void OnBeforePlayerDataInitialize()
        {
            PlayerDatas.Instance.skill.ClearSkillData();
            equipPassSkills.Clear();
            playerLoginOk = false;
            equipPassPage = false;
            taskHoleCondition = 0;
        }

        #region 配置
        public const int ACT_SKILL_NUM = 8;
        public const int PASS_SKILL_TYPE = 2;
        public const int ACT_SKILL_TYPE = 1;
        public const int PASS_SKILL_NUM = 12;
        public const int QUICK_SKILL_COUNT = 8;
        private Dictionary<int, int[]> quickBaseSkillDic = new Dictionary<int, int[]>();
        private Dictionary<int, int> xpSkillsDic = new Dictionary<int, int>();
        public List<PassSkillLimit> passSkillLimits = new List<PassSkillLimit>();
        public int passEquipCnt { get; private set; }
        public Dictionary<int, int[]> passEquipGetWays = new Dictionary<int, int[]>();
        public Dictionary<int, string> passEquipGetWayTxts;
        public Dictionary<int, Dictionary<int, List<int>>> skillActDict { get; private set; }
        public List<int> betterPassSkills { get; private set; }
        public bool jumpToPass { get; set; }
        public int minTaskHole { get; private set; }
        public int maxTaskHole { get; private set; }

        public bool skillMatchRedpointable {
            get { return LocalSave.GetBool("SkillMatchRedpointable_" + PlayerDatas.Instance.baseData.PlayerID); }
            set {
                LocalSave.SetBool("SkillMatchRedpointable_" + PlayerDatas.Instance.baseData.PlayerID, value);
                UpdateSkillMatchRedpoint();
            }
        }

        public readonly Redpoint redpoint = new Redpoint(103, 10301);
        public readonly Redpoint skillMatchRedpoint = new Redpoint(10301, 1030101);

        void ParseConfig()
        {
            for (int i = 1; i <= 3; i++)
            {
                var cfg = FuncConfigConfig.Get(StringUtility.Contact("QuickJobSkill", i));
                if (cfg != null)
                {
                    quickBaseSkillDic.Add(i, ConfigParse.GetMultipleStr<int>(cfg.Numerical1));
                }
            }
            FuncConfigConfig funcCfg = FuncConfigConfig.Get("XpSkillID");
            if (funcCfg != null)
            {
                xpSkillsDic = ConfigParse.GetDic<int, int>(funcCfg.Numerical1);
            }
            funcCfg = FuncConfigConfig.Get("PassSkillEquipLimit");
            if (funcCfg != null)
            {
                JsonData jsonData = JsonMapper.ToObject(funcCfg.Numerical1);
                foreach (string key in jsonData.Keys)
                {
                    PassSkillLimit limit = JsonMapper.ToObject<PassSkillLimit>(jsonData[key].ToJson());
                    limit.hole = int.Parse(key);
                    passSkillLimits.Add(limit);
                    if (minTaskHole == 0 && limit.OpenSkillSlots > 0)
                    {
                        minTaskHole = limit.OpenSkillSlots;
                    }
                    if (limit.OpenSkillSlots > maxTaskHole)
                    {
                        maxTaskHole = limit.OpenSkillSlots;
                    }
                }
                passEquipCnt = int.Parse(funcCfg.Numerical2);
                taskHoleDict = ConfigParse.GetDic<int, int>(funcCfg.Numerical4);
            }
            funcCfg = FuncConfigConfig.Get("PassSkillEquipGetWay");
            if (funcCfg != null)
            {
                JsonData jsonData = JsonMapper.ToObject(funcCfg.Numerical1);
                foreach (string key in jsonData.Keys)
                {
                    int[] intarray = JsonMapper.ToObject<int[]>(jsonData[key].ToJson());
                    passEquipGetWays.Add(int.Parse(key), intarray);
                }
                passEquipGetWayTxts = ConfigParse.GetDic<int, string>(funcCfg.Numerical2);
            }
            funcCfg = FuncConfigConfig.Get("SkillActTypeIdSort");
            skillActDict = new Dictionary<int, Dictionary<int, List<int>>>();
            var _JobTypeIds = ConfigParse.GetMultipleStr<int>(funcCfg.Numerical1);
            var _dict = new Dictionary<int, List<int>>();
            for (int i = 0; i < _JobTypeIds.Length; i++)
            {
                var _list = SkillConfig.GetSkills(2, ACT_SKILL_TYPE, _JobTypeIds[i]);
                if (_list != null)
                {
                    _dict.Add(_JobTypeIds[i], _list);
                }
            }
            skillActDict.Add(2, _dict);
            _JobTypeIds = ConfigParse.GetMultipleStr<int>(funcCfg.Numerical2);
            _dict = new Dictionary<int, List<int>>();
            for (int i = 0; i < _JobTypeIds.Length; i++)
            {
                var _list = SkillConfig.GetSkills(4, ACT_SKILL_TYPE, _JobTypeIds[i]);
                if (_list != null)
                {
                    _dict.Add(_JobTypeIds[i], _list);
                }
            }
            skillActDict.Add(4, _dict);
            _JobTypeIds = ConfigParse.GetMultipleStr<int>(funcCfg.Numerical3);
            _dict = new Dictionary<int, List<int>>();
            for (int i = 0; i < _JobTypeIds.Length; i++)
            {
                var _list = SkillConfig.GetSkills(8, ACT_SKILL_TYPE, _JobTypeIds[i]);
                if (_list != null)
                {
                    _dict.Add(_JobTypeIds[i], _list);
                }
            }
            skillActDict.Add(8, _dict);
            funcCfg = FuncConfigConfig.Get("SpecialPassSkills");
            betterPassSkills = new List<int>();
            var _array = ConfigParse.GetMultipleStr<int>(funcCfg.Numerical1);
            if (_array != null)
            {
                betterPassSkills.AddRange(_array);
            }

            for (int i = 0; i < passEquipCnt; i++)
            {
                passSkillHoleRedpoints.Add(new Redpoint(10302, 10302 * 100 + i));
            }
        }

        public int[] GetQuickBaseSkillArray(int occupy)
        {
            int[] array = null;
            quickBaseSkillDic.TryGetValue(occupy, out array);
            return array;
        }

        public int GetQuickSkillIdByPos(int pos)
        {
            int skillid = 0;
            PlayerSkillData data = PlayerDatas.Instance.skill.GetQuickSkillByPos(pos);
            if (data == null)
            {
                var intarray = quickBaseSkillDic[PlayerDatas.Instance.baseData.Job];
                if (pos < intarray.Length)
                {
                    skillid = intarray[pos];
                }
            }
            else
            {
                skillid = data.id;
            }
            return skillid;
        }

        public int GetXpSkillID()
        {
            int skillID;
            xpSkillsDic.TryGetValue(PlayerDatas.Instance.baseData.Job, out skillID);

            var model = ModelCenter.Instance.GetModel<TreasureSkillModel>();
            TreasureSkill skill;
            if (model.TryGetSkill(skillID, out skill))
            {
                return skill.GetSkillConfig(skill.level).SkillID;
            }
            return skillID;
        }

        public bool IsXpSkill(int skillId)
        {
            var config = SkillConfig.Get(skillId);
            if (config != null)
            {
                var job = PlayerDatas.Instance.baseData.Job;
                if (xpSkillsDic.ContainsKey(job))
                {
                    return xpSkillsDic[job] == config.SkillTypeID;
                }
            }
            return false;
        }

        void VerifyQuickSkillExistXp()
        {
            var quickSkills = PlayerDatas.Instance.skill.GetQuickSkills();
            var existXp = false;
            var lastIndex = 0;
            foreach (var index in quickSkills.Keys)
            {
                if (quickSkills[index] != null)
                {
                    if (IsXpSkill(quickSkills[index].id))
                    {
                        existXp = true;
                        QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.Skill, "***", index);
                        continue;
                    }
                    if (existXp)
                    {
                        var temp = QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.Skill, index);
                        QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.Skill, temp, index - 1);
                        QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.Skill, "***", index);
                    }
                    lastIndex = index;
                }
            }
            if (existXp)
            {
                if (lastIndex == QUICK_SKILL_COUNT - 1)
                {
                    var skills = GetActSkills();
                    for (int i = 0; i < skills.Count; i++)
                    {
                        if (PlayerDatas.Instance.skill.GetSKillById(skills[i]) != null
                            && !IsXpSkill(skills[i]) && PlayerDatas.Instance.skill.ContainsQuickSkill(skills[i]) == -1)
                        {
                            string value = MathUtils.Convert10To64(skills[i]);
                            QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.Skill, value, lastIndex);
                            break;
                        }
                    }
                }

                QuickSetting.Instance.SendPackage();
                PlayerDatas.Instance.skill.SetQuickSkills();
            }
        }

        List<int> GetActSkills()
        {
            List<int> skills = new List<int>();
            var skillType = (int)Math.Pow(2, PlayerDatas.Instance.baseData.Job);
            Dictionary<int, List<int>> dict = skillActDict[skillType];
            foreach (int key in dict.Keys)
            {
                List<int> list = dict[key];
                var skillId = list[0];
                foreach (var id in list)
                {
                    if (PlayerDatas.Instance.skill.GetSKillById(id) != null)
                    {
                        skillId = id;
                        break;
                    }
                }
                if (PlayerDatas.Instance.skill.GetFilterPlayerSkill(PlayerDatas.Instance.baseData.Job).Contains(skillId))
                {
                    continue;
                }
                skills.Add(skillId);
            }
            return skills;
        }
        #endregion

        #region 主动技能
        public int presentSltSkillID = 0;
        public event Action OnRefreshSltSkill;
        public void RefreshSltSkill()
        {
            if (OnRefreshSltSkill != null)
                OnRefreshSltSkill();
        }
        public bool skillDraging = false;
        public int skillDragId = 0;
        public float onDragDelay = 0.1f;
        private Skill m_XpSkill;
        public Skill xpSkill {
            get {
                return m_XpSkill ?? (m_XpSkill = PlayerDatas.Instance.hero.SkillMgr.Get(GetXpSkillID()));
            }
        }

        public event Action OnAutoUseXpEvent;
        public bool AutoUseXp()
        {
            return QuickSetting.Instance.GetQuickSettingBool(QuickSetting.QuickSettingType.AutoUseXp, 0, true);
        }

        public void SetAutoUseXp(bool _auto)
        {
            if (_auto != AutoUseXp())
            {
                QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.AutoUseXp, _auto);
                QuickSetting.Instance.SendPackage();
                if (OnAutoUseXpEvent != null)
                {
                    OnAutoUseXpEvent();
                }
            }
        }


        #endregion

        #region 被动技能
        public int presentSltPage = 0;
        public int presentEquipPage { get; private set; }
        public bool playerLoginOk = false;
        private Dictionary<int, Dictionary<int, int>> equipPassSkills = new Dictionary<int, Dictionary<int, int>>();
        public Dictionary<int, int> taskHoleDict { get; private set; }
        public event Action UpdatePassEquipSkillEvent;
        public bool equipPassPage { get; set; }
        public bool TryGetEquipPassSkills(int page, int hole, out int _skillId)
        {
            _skillId = 0;
            if (equipPassSkills.ContainsKey(page))
            {
                Dictionary<int, int> dic = equipPassSkills[page];
                if (dic.ContainsKey(hole))
                {
                    _skillId = dic[hole];
                    if (_skillId != 0)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        public void SendEquipPassSkills(int _skillId, int _hole)
        {
            PlayerSkillData data = PlayerDatas.Instance.skill.GetSKillById(_skillId);
            if (data != null && data.skillCfg.FuncType == PASS_SKILL_TYPE)
            {
                Dictionary<int, int> dic = null;
                if (equipPassSkills.TryGetValue(presentSltPage, out dic))
                {
                    int _preHole = -1;
                    if (dic.ContainsKey(_hole) && dic[_hole] == _skillId)
                    {
                        return;
                    }
                    foreach (var _key in dic.Keys)
                    {
                        if (_skillId == dic[_key] && (!dic.ContainsKey(_hole) || dic[_hole] == 0))
                        {
                            _preHole = _key;
                            break;
                        }
                        else if (_skillId == dic[_key])
                        {
                            SysNotifyMgr.Instance.ShowTip("PassSkillSameError");
                            return;
                        }
                    }
                    if (_preHole != -1)
                    {
                        SendEquipPassSkill(presentSltPage, _preHole, 0);
                    }
                }
                int _skill = 0;
                if (TryGetEquipPassSkills(presentSltPage, _hole, out _skill) && betterPassSkills.Contains(_skill))
                {
                    ConfirmCancel.ShowPopConfirm(Language.Get("TeamPrepare1"), Language.Get("ReBetterSkill"), (bool isOk) =>
                      {
                          if (isOk)
                          {
                              SoundPlayer.Instance.PlayUIAudio(28);
                              SendEquipPassSkill(presentSltPage, _hole, _skillId);
                          }
                      });
                }
                else
                {
                    SoundPlayer.Instance.PlayUIAudio(28);
                    SendEquipPassSkill(presentSltPage, _hole, _skillId);
                }

            }
        }

        public event Action taskUnlockUpdate;

        public uint taskHoleCondition { get; private set; }

        public const string TASKHOLEKEY = "OpenSkillSlots";

        public int UnlockPassHole {
            get { return LocalSave.GetInt(StringUtility.Contact(TASKHOLEKEY, "_", PlayerDatas.Instance.baseData.PlayerID)); }
            set { LocalSave.SetInt(StringUtility.Contact(TASKHOLEKEY, "_", PlayerDatas.Instance.baseData.PlayerID), value); }
        }

        public bool IsTaskHoleUnlock(int condition)
        {
            if (task._DicTaskInformation.ContainsKey(1)
                && task._DicTaskInformation[1].ContainsKey(TASKHOLEKEY))
            {
                uint value = 0;
                uint.TryParse(task._DicTaskInformation[1][TASKHOLEKEY], out value);
                return MathUtility.GetBitValue(value, (ushort)condition);
                //return value >= condition;
            }
            return false;
        }

        private void TaskInformationUpdate(int _id, Dictionary<int, Dictionary<string, string>> _Dic)
        {
            if (_Dic != null && _Dic.ContainsKey(1))
            {
                var dict = _Dic[1];
                if (dict.ContainsKey(TASKHOLEKEY))
                {
                    uint result = 0;
                    uint.TryParse(dict[TASKHOLEKEY], out result);
                    if (playerLoginOk)
                    {
                        for (int k = minTaskHole; k <= maxTaskHole; k++)
                        {
                            if (!MathUtility.GetBitValue(taskHoleCondition, (ushort)k)
                                && MathUtility.GetBitValue(result, (ushort)k))
                            {
                                UnlockPassHole = k;
                            }
                        }
                        if (taskUnlockUpdate != null)
                        {
                            taskUnlockUpdate();
                        }
                    }
                    taskHoleCondition = result;
                }
            }
            //UpdateTaskHoleRedpoint();
        }

        RolePromoteModel m_PromoteModel;
        RolePromoteModel promoteModel {
            get {
                return m_PromoteModel ?? (m_PromoteModel = ModelCenter.Instance.GetModel<RolePromoteModel>());
            }
        }

        TaskModel task { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }
        PlayerMainDate mainData { get { return ModelCenter.Instance.GetModel<PlayerMainDate>(); } }
        public void SendEquipPassSkill(int _page, int _index, int _skillId)
        {
            var pak = new CB407_tagCMPassiveSet();
            pak.Page = (byte)_page;
            pak.Index = (byte)_index;
            pak.SkillID = (uint)_skillId;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void SendEquipPage()
        {
            if (presentSltPage == presentEquipPage)
            {
                return;
            }
            equipPassPage = true;
            CB408_tagCMPassivePage pak = new CB408_tagCMPassivePage();
            pak.Page = (byte)presentSltPage;
            GameNetSystem.Instance.SendInfo(pak);
        }

        public bool IsPassSkillHoleOpen(int _hole)
        {
            PassSkillLimit limit;
            if (TryGetPassSkillLimit(_hole, out limit))
            {
                if (limit.level > 0)
                {
                    if (PlayerDatas.Instance.baseData.LV < limit.level)
                    {
                        return false;
                    }
                }
                else if (limit.vipLv > 0)
                {
                    if (PlayerDatas.Instance.baseData.VIPLv < limit.vipLv)
                    {
                        return false;
                    }
                }
                else if (limit.MountLv > 0)
                {
                    if (promoteModel.GetMountTotallv() < limit.MountLv)
                    {
                        return false;
                    }
                }
                else if (limit.OpenSkillSlots > 0)
                {
                    if (!IsTaskHoleUnlock(limit.OpenSkillSlots))
                    {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }

        public int PassOpenHoleCount()
        {
            var count = 0;
            for (int i = 0; i < passEquipCnt; i++)
            {
                if (IsPassSkillHoleOpen(i))
                {
                    count++;
                }
            }
            return count;
        }

        public bool TryGetPassSkillLimit(int _hole, out PassSkillLimit _limit)
        {
            _limit = default(PassSkillLimit);
            int index = passSkillLimits.FindIndex((x) =>
            {
                return x.hole == _hole;
            });
            if (index == -1)
            {
                return false;
            }
            _limit = passSkillLimits[index];
            return true;
        }

        public void UpdateEquipPassSkills(HB406_tagMCPassiveSet package)
        {
            if (package.PageCnt == 0)
            {
                return;
            }
            for (int i = 0; i < package.PassiveSkills.Length; i++)
            {
                if (package.PassiveSkills[i].Count == 0)
                {
                    continue;
                }
                for (int j = 0; j < package.PassiveSkills[i].Count; j++)
                {
                    SetEquipPassSkill(i, j, (int)package.PassiveSkills[i].SkillIDList[j]);
                }
            }
            if (UpdatePassEquipSkillEvent != null)
            {
                UpdatePassEquipSkillEvent();
            }
            UpdateRedpoint();
        }

        public void UpdateEquipPassPage(HB407_tagMCPassivePage package)
        {
            presentEquipPage = package.Page;
            if (equipPassPage)
            {
                SysNotifyMgr.Instance.ShowTip("SetPassEquipPageSuccess", presentEquipPage + 1);
            }
            equipPassPage = false;
            UpdateRedpoint();
        }

        public void UpdateEquipPassSkill(HB408_tagMCPassiveSetAnswer package)
        {
            SetEquipPassSkill(package.Page, package.Index, (int)package.SkillID);
            if (UpdatePassEquipSkillEvent != null)
            {
                UpdatePassEquipSkillEvent();
            }
        }

        public void SetEquipPassSkill(int _page, int _index, int _skillId)
        {
            Dictionary<int, int> dic = null;
            if (!equipPassSkills.TryGetValue(_page, out dic))
            {
                dic = new Dictionary<int, int>();
                equipPassSkills.Add(_page, dic);
            }
            dic[_index] = _skillId;
        }

        public void OnPlayerLoginOk()
        {
            if (GetEquipPassSkillCnt() == 0)
            {
                Dictionary<int, PlayerSkillData> playerskills = PlayerDatas.Instance.skill.GetAllSkill();
                var _cnt = 0;
                presentSltPage = 0;
                foreach (var _skill in playerskills.Values)
                {
                    if (_cnt >= 2)
                    {
                        break;
                    }
                    if (_skill.skillCfg.FuncType == PASS_SKILL_TYPE)
                    {
                        SendEquipPassSkills(_skill.id, _cnt);
                        _cnt++;
                    }
                }
            }
            playerLoginOk = true;
            UpdateRedpoint();
            //VerifyQuickSkillExistXp();
            UpdateSkillMatchRedpoint();
            //UpdateTaskHoleRedpoint();
        }

        public void CheckEquipPassSkill(PlayerSkillData _skill)
        {
            if (!playerLoginOk)
            {
                return;
            }
            if (_skill.skillCfg.FuncType != PASS_SKILL_TYPE)
            {
                return;
            }
            var _cnt = GetEquipPassSkillCnt();
            if (_cnt < 2)
            {
                for (int i = 0; i < passEquipCnt; i++)
                {
                    var _id = 0;
                    if (!TryGetEquipPassSkills(0, i, out _id))
                    {
                        SendEquipPassSkills(_skill.id, i);
                        break;
                    }
                }
            }
        }

        public bool ContainsEquipPassSkill(int _skillId)
        {
            foreach (var _dict in equipPassSkills.Values)
            {
                foreach (var _id in _dict.Values)
                {
                    if (_skillId == _id)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public int GetEquipPassSkillCnt()
        {
            var _totalCnt = 0;
            foreach (var _dict in equipPassSkills.Values)
            {
                foreach (var _id in _dict.Values)
                {
                    if (_id != 0)
                    {
                        _totalCnt += 1;
                    }
                }
            }
            return _totalCnt;
        }

        public int GetEquipPassSkillCount(int _page)
        {
            if (!equipPassSkills.ContainsKey(_page))
            {
                return 0;
            }
            var _dict = equipPassSkills[_page];
            var count = 0;
            foreach (var _id in _dict.Values)
            {
                if (_id != 0)
                {
                    count += 1;
                }
            }
            return count;
        }
        #endregion

        #region 红点
        public Redpoint skillRedpoint = new Redpoint(1, 103);
        //public Redpoint passSkillRedpoint = new Redpoint(103, 10302);
        public List<Redpoint> passSkillHoleRedpoints = new List<Redpoint>();

        void UpdateRedpoint()
        {
            //for (int i = 0; i < passSkillHoleRedpoints.Count; i++)
            //{
            //    passSkillHoleRedpoints[i].state = RedPointState.None;
            //}
            //if (!FuncOpen.Instance.IsFuncOpen(109))
            //{
            //    return;
            //}
            //if (DayRemind.Instance.GetDayRemind(DayRemind.PASS_SKILL_REDPOINT))
            //{
            //    return;
            //}
            //var _count = GetEquipPassSkillCount(presentEquipPage);
            //if (PlayerDatas.Instance.skill.GetSkillCountByType(PASS_SKILL_TYPE) > _count
            //    && PassOpenHoleCount() > _count)
            //{
            //    for (int i = 0; i < passEquipCnt; i++)
            //    {
            //        var _skillId = 0;
            //        if (!TryGetEquipPassSkills(presentEquipPage, i, out _skillId)
            //            && IsPassSkillHoleOpen(i))
            //        {
            //            passSkillHoleRedpoints[i].state = RedPointState.Simple;
            //            return;
            //        }
            //    }
            //}
        }

        void UpdateSkillMatchRedpoint()
        {
            skillMatchRedpoint.state = skillMatchRedpointable ? RedPointState.Simple : RedPointState.None;
        }

        public void SetDayRemind()
        {
            //DayRemind.Instance.SetDayRemind(DayRemind.PASS_SKILL_REDPOINT, true);
            UpdateRedpoint();
        }

        //public Redpoint taskHoleRedpoint = new Redpoint(10302, 1030299);
        //void UpdateTaskHoleRedpoint()
        //{
        //    taskHoleRedpoint.state = RedPointState.None;
        //    if (DayRemind.Instance.GetDayRemind(DayRemind.TASK_SKILL_HOLE))
        //    {
        //        return;
        //    }
        //    foreach (var hole in taskHoleDict.Keys)
        //    {
        //        var taskId = taskHoleDict[hole];
        //        if (IsImmediatelyUnlock(hole))
        //        {
        //            var config = PyTaskConfig.Get(taskId);
        //            if (PlayerDatas.Instance.baseData.LV >= config.lv
        //                && !IsTaskHoleUnlock(hole))
        //            {
        //                taskHoleRedpoint.state = RedPointState.Simple;
        //            }
        //            return;
        //        }
        //    }
        //}

        public bool IsImmediatelyUnlock(int hole)
        {
            if (taskHoleDict.ContainsKey(hole))
            {
                var taskId = taskHoleDict[hole];
                return mainData.TaskId_Skill.Contains(taskId);
            }
            return false;
        }

        public void SetTaskHoleRemind()
        {
            DayRemind.Instance.SetDayRemind(DayRemind.TASK_SKILL_HOLE, true);
            //UpdateTaskHoleRedpoint();
        }
        #endregion

        private void OnFuncStateChangeEvent(int _id)
        {
            if (_id == 109)
            {
                UpdateRedpoint();
                //UpdateTaskHoleRedpoint();
            }
        }

        public event Action onSkillMatchPageUpdate;

        public void OnSkillMatchPageUpdate()
        {
            if (onSkillMatchPageUpdate != null)
            {
                onSkillMatchPageUpdate();
            }
        }

        public List<int> GetSkillMatchs()
        {
            return SkillMatchModel.Instance.GetSkills();
        }
    }

    public struct PassSkillLimit
    {
        public int hole;
        public int level;
        public int vipLv;
        public int MountLv;
        public int OpenSkillSlots;
    }

    [Serializable]
    public class SkillData
    {
        [HideInInspector]
        public int skillId;
        [HideInInspector]
        public SkillConfig skillCfg;
        public Image m_LockImg;
        public Image m_SelectImg;
        public Button m_SkillBtn;
        public Text m_SkillNameTxt;
        [SerializeField] Image m_BottomImg;
        [SerializeField] Image m_SkillIcon;
        [SerializeField] Text m_SkillSourceTxt;

        public void SetSkillData(int _id)
        {
            this.skillId = _id;
            if (skillId == 0)
            {
                m_SkillIcon.SetActive(false);
                return;
            }
            m_SkillIcon.SetActive(true);
            skillCfg = SkillConfig.Get(_id);
            m_SkillIcon.SetSprite(skillCfg.IconName);

            if (m_SkillNameTxt != null)
            {
                m_SkillNameTxt.text = skillCfg.SkillName;
            }
            if (m_SkillSourceTxt != null)
            {
                m_SkillSourceTxt.text = skillCfg.Skillsource;
            }
        }

        public void SetActive(bool _active)
        {
            m_SkillIcon.material = _active ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();
            if (m_BottomImg != null)
            {
                m_BottomImg.material = _active ? MaterialUtility.GetUIDefaultGraphicMaterial() : MaterialUtility.GetDefaultSpriteGrayMaterial();
            }
        }
    }

    public interface ISkillMatch
    {
        List<int> GetSkills();
        event Action onSkillMatchPageUpdate;
    }
}