//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, October 09, 2017
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using TableConfig;
using System;
using System.Text.RegularExpressions;

namespace Snxxz.UI
{

    public class TreasureModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
    {
        public const int TREASURE_DATAMAPID = 41110;
        public const int TREASURE_MAPID = 41110;
        public const int TREASURE_GUIDE_ID = 102;
        public const int TREASURE_SOUL_ID = 115;

        const int TREASURE_REDPOINTID = 7000;
        readonly static int[] CATEGORY_REDPOINTIDS = { 7001, 7002, 7003, 7004, 7005 };
        const int TREASURE_REDPOINTBASE = 7100;

        public static int redpointIndex = 1;

        Redpoint treasureRedpoint = new Redpoint(TREASURE_REDPOINTID);
        Redpoint humanRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Human - 1]);
        Redpoint demonRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Demon - 1]);
        Redpoint fairypoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Fairy - 1]);
        Redpoint elderGodRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.ElderGod - 1]);
        Redpoint zergRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Zerg - 1]);

        public Redpoint stoveRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[(int)TreasureCategory.Fairy - 1], 7200);
        public Redpoint treasureSoulRedpoint = new Redpoint(1, TREASURE_SOUL_ID);

        public event Action<int> treasureCollectProgressUpdateEvent;
        public event Action<int> treasureSelectedEvent;
        public event Action<int> potentialBookSelectEvent;
        public event Action<TreasureCategory> collectingTreasureChangeEvent;
        public event Action<int> treasureStateChangeEvent;
        public event Action<int, int, bool> onPotentialLevelUpResultEvent;
        public event Action<int, int> potentialLevelChangeEvent;
        public event Action<int, int> potentialLevelUpdate;
        public event Action vipKillNPCTreasureEvent;
        public event Action<int> treasureLevelProgressUpdateEvent;
        public event Action<int> treasureStageUpEvent;
        public event Action<int> humanTreasureStateChangeEvent;

        bool m_WaitOpenDetailsWin = false;
        public bool waitOpenDetailsWin {
            get { return m_WaitOpenDetailsWin; }
            set { m_WaitOpenDetailsWin = value; }
        }

        int m_SelectedTreasure = 0;
        public int selectedTreasure {
            get { return m_SelectedTreasure; }
            set {
                if (m_SelectedTreasure != value)
                {
                    m_SelectedTreasure = value;
                    if (treasureSelectedEvent != null)
                    {
                        treasureSelectedEvent(m_SelectedTreasure);
                    }
                }
            }
        }

        int m_SelectedPotential = 0;
        public int selectedPotential {
            get { return m_SelectedPotential; }
            set {
                if (m_SelectedPotential != value)
                {
                    m_SelectedPotential = value;
                }
            }
        }

        int m_SelectedStage = 0;
        public int selectedStage {
            get { return m_SelectedStage; }
            set {
                m_SelectedStage = value;
            }
        }

        private bool m_TreasureStepUpShow = false;
        public bool treasureStepUpShow {
            get {
                return m_TreasureStepUpShow;
            }
            set {
                m_TreasureStepUpShow = value;
            }
        }

        private bool m_TreasureStageUpShow = false;
        public bool treasureStageUpShow
        {
            get
            {
                return m_TreasureStageUpShow;
            }
            set
            {
                m_TreasureStageUpShow = value;
            }
        }

        TreasureCategory m_CurrentCategory = TreasureCategory.Human;
        public TreasureCategory currentCategory {
            get { return m_CurrentCategory; }
            set { m_CurrentCategory = value; }
        }

        int m_CollectingHuman = 0;
        public int collectingHuman {
            get { return m_CollectingHuman; }
            set {
                if (m_CollectingHuman != value)
                {
                    m_CollectingHuman = value;
                    if (collectingTreasureChangeEvent != null)
                    {
                        collectingTreasureChangeEvent(TreasureCategory.Human);
                    }
                }
            }
        }

        int m_CollectingDemon = 0;
        public int collectingDemon {
            get { return m_CollectingDemon; }
            set {
                if (m_CollectingDemon != value)
                {
                    m_CollectingDemon = value;
                    if (collectingTreasureChangeEvent != null)
                    {
                        collectingTreasureChangeEvent(TreasureCategory.Demon);
                    }
                }
            }
        }

        int m_SelectedPotentialBook = 0;
        public int selectedPotentialBook {
            get { return m_SelectedPotentialBook; }
            set {
                if (m_SelectedPotentialBook != value)
                {
                    m_SelectedPotentialBook = value;
                    if (potentialBookSelectEvent != null)
                    {
                        potentialBookSelectEvent(m_SelectedPotentialBook);
                    }
                }
            }
        }

        int levelUpTreasureIdBuf = 0;
        int levelUpPotentialBuf = 0;

        Dictionary<int, List<int>> skillLevelUpTypes = new Dictionary<int, List<int>>();
        Dictionary<int, Treasure> treasures = new Dictionary<int, Treasure>();
        Dictionary<TreasureCategory, List<int>> treasureCategory = new Dictionary<TreasureCategory, List<int>>();
        Dictionary<int, int> treasureMapDict = new Dictionary<int, int>();
        Dictionary<int, int> treasureAchievementDict = new Dictionary<int, int>();
        List<int> eightFurnacesAchievements = new List<int>();
        List<int> m_CacheGotAchievements = new List<int>();
        Dictionary<int, int> treasureStageShowDict = new Dictionary<int, int>();
        List<int> treasureUnOpens = new List<int>();//版本未开放法宝

        public Dictionary<int, int> fairyTreasureGetDict { get; private set; }

        public bool serverInited { get; private set; }
        public int newGotTreasureId {
            get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_NewGotTreasureId")); }
            set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_NewGotTreasureId"), value); }
        }

        public bool newGotShowing {
            get { return newGotTreasureId > 0; }
        }

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

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

        public int treasureGotoId { get; set; }

        public bool openFromTreasureSoul { get; set; }
        public bool openFromTreasureUnlockShow { get; set; }
        public bool openFromTreasureCollect { get; set; }
        public bool openFromTreasureList { get; set; }
        public int openFromTaskId = 0;

        public List<int> castSoulGuideTaskIds { get; private set; }
        public List<int> guideTreasures { get; private set; }

        public int treasureBackLvLimit { get; private set; }
        public float treasureBackPercent { get; private set; }
        public int treasureExitLvLimit { get; private set; }
        public int exitRecord { get; set; }

        public List<int> cacheGotAchievements {
            get { return m_CacheGotAchievements; }
        }

        AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
        PlayerPackModel packageModel { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }

        VIPKillNPCTreasure m_VIPKillNPCTreasure;
        public VIPKillNPCTreasure vipKillNPCTreasure {
            get { return m_VIPKillNPCTreasure; }
            set {
                m_VIPKillNPCTreasure = value;
                if (vipKillNPCTreasureEvent != null)
                {
                    vipKillNPCTreasureEvent();
                }
            }
        }

        public override void Init()
        {
            ParseConfigs();
            ParseSkillLevelUpConfig();
            ParsePotentialSkillConfig();

            achievementModel.achievementProgressUpdateEvent += OnAchievementProgressUpdate;
            achievementModel.achievementAwardableEvent += OnAchievementAwardable;
            achievementModel.achievementCompletedEvent += OnAchievementCompleted;

            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += OnGetSkillLevelUpResult;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += OnTreasurePotentialSPChange;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
            packageModel.RefreshItemCountAct += OnPackageItemChange;
            WindowCenter.Instance.windowAfterOpenEvent += OnWindowOpen;
            NewBieCenter.Instance.guideCompletedEvent += GuideComplete;
            StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
        }

        public override void UnInit()
        {
            achievementModel.achievementProgressUpdateEvent -= OnAchievementProgressUpdate;
            achievementModel.achievementAwardableEvent -= OnAchievementAwardable;
            achievementModel.achievementCompletedEvent -= OnAchievementCompleted;
            NewBieCenter.Instance.guideCompletedEvent -= GuideComplete;

            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= OnGetSkillLevelUpResult;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= OnTreasurePotentialSPChange;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
            packageModel.RefreshItemCountAct -= OnPackageItemChange;
            WindowCenter.Instance.windowAfterOpenEvent -= OnWindowOpen;
            StageManager.Instance.onStageLoadFinish -= OnStageLoadFinish;
        }

        public void OnAfterPlayerDataInitialize()
        {
            collectingDemon = 0;
            collectingHuman = 0;
        }

        public void OnBeforePlayerDataInitialize()
        {
            serverInited = false;
            needDisplayReguluLevelUp = false;
            treasureUnlockShowDict.Clear();
            cacheGotAchievements.Clear();
            foreach (var treasure in treasures.Values)
            {
                treasure.state = TreasureState.Locked;
                treasure.UpdateTreasureLevelExp(0, 0, false);
                if ((treasure is HumanTreasure))
                {
                    var humanTreasure = treasure as HumanTreasure;
                    humanTreasure.UpdateTreasureState();
                }
            }
        }

        public void OnPlayerLoginOk()
        {
            serverInited = true;
            UpdateAchievementRedpoints();
            UpdateCastSoulRedpoints();
            UpdateSkillLevelUpRedpoints();
        }

        private bool needDisplayReguluLevelUp = false;
        public void CheckReguluPop()
        {
            if (serverInited)
            {
                if (WindowCenter.Instance.CheckOpen<MainInterfaceWin>() && !WindowCenter.Instance.ExitAnyFullScreenOrMaskWin())
                {
                    if (!WindowCenter.Instance.CheckOpen<TreasureRegulusPopWin>())
                    {
                        WindowCenter.Instance.Open<TreasureRegulusPopWin>();
                    }
                    needDisplayReguluLevelUp = false;
                }
                else
                {
                    needDisplayReguluLevelUp = true;
                }
            }
        }

        private void OnStageLoadFinish()
        {
            if (!(StageManager.Instance.CurrentStage is DungeonStage))
            {
                exitRecord = 0;
            }
        }

        Dictionary<TreasureCategory, int> treasureUnlockShowDict = new Dictionary<TreasureCategory, int>();
        public int GetTreasureUnlockShow(TreasureCategory _type)
        {
            if (!treasureUnlockShowDict.ContainsKey(_type))
            {
                var _playerId = PlayerDatas.Instance.baseData.PlayerID;
                var _id = LocalSave.GetInt(StringUtility.Contact(_playerId, _type, "_TreasureUnlockShow"));
                treasureUnlockShowDict.Add(_type, _id);
            }
            return treasureUnlockShowDict[_type];
        }

        public bool GetPotentialUnlockShow(int _treasureId)
        {
            var _playerId = PlayerDatas.Instance.baseData.PlayerID;
            return LocalSave.GetBool(StringUtility.Contact(_playerId, "_PotentialUnlockShow_", _treasureId));
        }

        public void SetPotentialUnlockShow(int _treasureId, bool _value = false)
        {
            var _playerId = PlayerDatas.Instance.baseData.PlayerID;
            LocalSave.SetBool(StringUtility.Contact(_playerId, "_PotentialUnlockShow_", _treasureId), _value);
        }

        public bool GetSpAnim(int _treasureId)
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            var index = list.IndexOf(_treasureId);
            if (index == -1)
            {
                return false;
            }
            uint value = 0;
            uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.SpAnim, 0), out value);
            return MathUtility.GetBitValue(value, (ushort)index);
        }

        public void SetSpAnim(int _treasureId, bool anim = true)
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            var index = list.IndexOf(_treasureId);
            if (index == -1)
            {
                return;
            }
            uint value = 0;
            uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.SpAnim, 0), out value);
            int bitValue = MathUtility.SetBitValue((int)value, (ushort)index, anim);
            QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.SpAnim, bitValue);
            QuickSetting.Instance.SendPackage();
        }

        public bool TryGetUnlockShowTreasure(out int _id)
        {
            _id = 0;
            if ((_id = GetTreasureUnlockShow(TreasureCategory.Human)) != 0)
            {
                return true;
            }
            else if ((_id = GetTreasureUnlockShow(TreasureCategory.Demon)) != 0)
            {
                return true;
            }
            else if ((_id = GetTreasureUnlockShow(TreasureCategory.Fairy)) != 0)
            {
                return true;
            }
            return false;
        }

        public void SetTreasureUnlockShow(TreasureCategory _type, int _id)
        {
            if (treasureUnlockShowDict.ContainsKey(_type))
            {
                treasureUnlockShowDict[_type] = _id;
            }
            var _playerId = PlayerDatas.Instance.baseData.PlayerID;
            LocalSave.SetInt(StringUtility.Contact(_playerId, _type, "_TreasureUnlockShow"), _id);
        }

        public void SetTreasureStageShow(int _id, int _stage)
        {
            LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID,
                "_TreasureStageShow_", _id), _stage);
        }

        public int GetTreasureStageShow(int _id)
        {
            var _stage = LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID,
                "_TreasureStageShow_", _id), -1);
            return _stage;
        }

        public bool TryGetTreasure(int _id, out Treasure _treasure)
        {
            return treasures.TryGetValue(_id, out _treasure);
        }

        public bool TryGetTreasureUnlockAchievement(int _treasureId, out int achievement)
        {
            return treasureAchievementDict.TryGetValue(_treasureId, out achievement);
        }

        public List<int> GetAllTreasure()
        {
            return new List<int>(treasures.Keys);
        }

        public List<int> GetTreasureCategory(TreasureCategory _category)
        {
            if (treasureCategory.ContainsKey(_category))
            {
                return treasureCategory[_category];
            }
            else
            {
                return null;
            }
        }

        public int GetActiveTreasureCategory(TreasureCategory _category)
        {
            var list = GetTreasureCategory(_category);
            if (list == null)
            {
                return 0;
            }

            var count = 0;
            for (int i = 0; i < list.Count; i++)
            {
                Treasure treasure;
                if (TryGetTreasure(list[i], out treasure) && treasure.state == TreasureState.Collected)
                {
                    count++;
                }
            }

            return count;
        }

        public int GetTreasureIdByMapIdAndLineId(int _mapId, int _lineId)
        {
            var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
            var dataMapId = dungeonModel.GetDataMapIdByMapId(_mapId);
            var allConfigs = Config.Instance.GetAllValues<TreasureConfig>();
            foreach (var config in allConfigs)
            {
                if (config.MapId == dataMapId && config.LineId == _lineId)
                {
                    return config.ID;
                }
            }

            return 0;
        }

        /// <summary>
        /// 获得技能的升级类型
        /// </summary>
        /// <param name="_skillId"></param>
        /// <returns></returns>
        public int GetSkillLevelUpType(int _skillId)
        {
            foreach (var key in skillLevelUpTypes.Keys)
            {
                if (skillLevelUpTypes[key].Contains(_skillId))
                {
                    return key;
                }
            }

            return 0;
        }

        public void RequestPotentialUpgrade(int _treasureId, int _potentialId, int _costIndex)
        {
            levelUpTreasureIdBuf = _treasureId;
            levelUpPotentialBuf = _potentialId;

            var info = new CA50D_tagCMMagicWeaponSkillUp();
            info.SkillTypeID = (ushort)_potentialId;
            info.CostIndex = (byte)_costIndex;

            GameNetSystem.Instance.SendInfo(info);
        }

        public void UpdateTreasureCollectState(uint[] _gotTreasures)
        {
            for (int i = 0; i < _gotTreasures.Length; i++)
            {
                var id = (int)_gotTreasures[i];
                Treasure treasure;
                if (TryGetTreasure(id, out treasure))
                {
                    if (treasure.state != TreasureState.Collected)
                    {
                        treasure.state = TreasureState.Collected;
                        if (treasure is HumanTreasure)
                        {
                            var humanTreasure = treasure as HumanTreasure;
                            humanTreasure.UpdateTreasureState();
                            UpdateCastSoulRedpoint(treasure.id);
                            if (GetTreasureUnlockShow(TreasureCategory.Human) == treasure.id)
                            {
                                SetTreasureUnlockShow(TreasureCategory.Human, 0);
                            }
                        }
                        if (serverInited)
                        {
                            newGotTreasureId = id;
                            treasureEntranceShowId = id;

                            OpenTreasureNewGot();
                        }

                        if (treasureCollectingShowId == id)
                        {
                            treasureCollectingShowId = 0;
                        }

                        if (treasureStateChangeEvent != null)
                        {
                            treasureStateChangeEvent(id);
                        }
                    }
                }
            }

            foreach (var key in treasures.Keys)
            {
                var treasure = treasures[key];
                if (treasure.state != TreasureState.Locked)
                {
                    continue;
                }

                var config = Config.Instance.Get<TreasureConfig>(key);
                if (config.PreTreasure == 0 || treasures[config.PreTreasure].state == TreasureState.Collected)
                {
                    switch ((TreasureCategory)config.Category)
                    {
                        case TreasureCategory.Human:
                        case TreasureCategory.Demon:
                            if (treasure.state == TreasureState.Locked)
                            {
                                int _unlockAchievement = 0;
                                Achievement _achievement;
                                treasureAchievementDict.TryGetValue(treasure.id, out _unlockAchievement);
                                achievementModel.TryGetAchievement(_unlockAchievement, out _achievement);
                                if (_achievement == null || _achievement.completed)
                                {
                                    if (serverInited)
                                    {
                                        SetTreasureUnlockShow((TreasureCategory)config.Category, treasure.id);
                                    }
                                    treasure.state = TreasureState.Collecting;
                                    if ((TreasureCategory)config.Category == TreasureCategory.Human)
                                    {
                                        (treasure as HumanTreasure).UpdateTreasureState();
                                    }
                                    if ((TreasureCategory)config.Category == TreasureCategory.Demon)
                                    {
                                        collectingDemon = key;
                                    }
                                    else if ((TreasureCategory)config.Category == TreasureCategory.Human)
                                    {
                                        collectingHuman = key;
                                    }
                                }
                            }
                            break;
                        default:
                            break;
                    }

                    if (treasureStateChangeEvent != null)
                    {
                        treasureStateChangeEvent(key);
                    }
                }
            }

            UpdateStoveRedpoint();
            UpdateSkillLevelUpRedpoints();
        }

        public void UpdateTreasurePotentialInfo(int _oldSkillId, int _newSkillId)
        {
            var config = Config.Instance.Get<SkillConfig>(_newSkillId);
            foreach (var key in treasures.Keys)
            {
                var treasure = treasures[key];
                if (treasure.GetPotential(config.SkillTypeID) != null)
                {
                    treasure.UpdatePotentialLevel(config.SkillTypeID, config.SkillLV);
                    if (potentialLevelUpdate != null)
                    {
                        potentialLevelUpdate(config.SkillTypeID, config.SkillLV);
                    }
                    if (potentialLevelChangeEvent != null)
                    {
                        potentialLevelChangeEvent(key, config.SkillTypeID);
                    }
                    if (FuncOpen.Instance.IsFuncOpen(82))
                    {
                        UpdateSkillLevelUpRedpoint(treasure.id);
                    }
                    break;
                }
            }

        }

        private void OnAchievementProgressUpdate(int _achievement)
        {
            foreach (var treasure in treasures.Values)
            {
                int[] achievements = null;
                var config = Config.Instance.Get<TreasureConfig>(treasure.id);
                if ((TreasureCategory)config.Category == TreasureCategory.Human)
                {
                    achievements = treasure.achievements.ToArray();
                }
                else
                {
                    achievements = config.Achievements;
                }
                if (achievements == null)
                {
                    return;
                }
                if (Array.IndexOf(achievements, _achievement) != -1)
                {
                    UpdateTreasureCollectProgress(treasure);
                }
            }

            if (eightFurnacesAchievements.Contains(_achievement))
            {
                UpdateStoveRedpoint();
            }
        }

        private void UpdateTreasureCollectProgress(Treasure _treasure)
        {
            var config = Config.Instance.Get<TreasureConfig>(_treasure.id);
            var oldProgress = _treasure.progress;
            var tempProgress = 0;
            Achievement achievement;
            //if (achievementModel.TryGetAchievement(config.MainID, out achievement))
            //{
            //    if (achievement.completed)
            //    {
            //        tempProgress++;
            //    }
            //}

            int[] achievements = config.Achievements;
            if ((TreasureCategory)config.Category == TreasureCategory.Human)
            {
                achievements = _treasure.achievements.ToArray();
            }
            else
            {
                achievements = config.Achievements;
            }

            for (int i = 0; i < achievements.Length; i++)
            {
                if (achievementModel.TryGetAchievement(achievements[i], out achievement))
                {
                    if (achievement.completed)
                    {
                        tempProgress++;
                    }
                }
            }

            if (oldProgress != tempProgress)
            {
                _treasure.progress = tempProgress;
                if (treasureCollectProgressUpdateEvent != null)
                {
                    treasureCollectProgressUpdateEvent(_treasure.id);
                }
            }
        }

        private void OnGetSkillLevelUpResult(H0721_tagMakeItemAnswer _result)
        {
            switch ((MakeType)_result.MakeType)
            {
                case MakeType.Def_treasureSkillEquip:
                    if (onPotentialLevelUpResultEvent != null)
                    {
                        onPotentialLevelUpResultEvent(levelUpTreasureIdBuf, levelUpPotentialBuf, _result.Result == 1);
                    }

                    levelUpTreasureIdBuf = 0;
                    levelUpPotentialBuf = 0;
                    break;
            }
        }

        private void OnTreasurePotentialSPChange(PlayerDataRefresh refreshType)
        {
            switch (refreshType)
            {
                case PlayerDataRefresh.ExAttr7:
                case PlayerDataRefresh.ExAttr8:
                    UpdateSkillLevelUpRedpoints();
                    break;
                case PlayerDataRefresh.LV:
                    UpdateAchievementRedpoints();
                    break;
            }
        }

        private void OnPackageItemChange(PackType _type, int _index, int _itemId)
        {
            if (_type == PackType.rptItem)
            {
                var config = Config.Instance.Get<ItemConfig>(_itemId);
                if (config.Type == 6)
                {
                    UpdateSkillLevelUpRedpoints();
                }
            }
        }

        private void OnFunctionStateChange(int _functionId)
        {
            if (_functionId == 82)
            {
                UpdateSkillLevelUpRedpoints();
                if (!FuncOpen.Instance.IsFuncOpen(82))
                {
                    return;
                }
                var list = treasureCategory[TreasureCategory.Human];
                for (int i = 0; i < list.Count; i++)
                {
                    Treasure treasure;
                    TryGetTreasure(list[i], out treasure);
                    var humanTreasure = treasure as HumanTreasure;
                    humanTreasure.UpdateTreasureState();
                    if (!serverInited || !treasure.IsHighestStage)
                    {
                        continue;
                    }
                    if (IsPotentialUnlock(list[i], treasure.potentials[0].id))
                    {
                        SetPotentialUnlockShow(list[i], true);
                    }
                }
            }
        }

        private void UpdateSkillLevelUpRedpoints()
        {
            var functionOpen = FuncOpen.Instance.IsFuncOpen(82);
            if (functionOpen)
            {
                foreach (var id in treasures.Keys)
                {
                    UpdateSkillLevelUpRedpoint(id);
                }
            }
        }

        private void UpdateAchievementRedpoints()
        {
            foreach (var id in treasures.Keys)
            {
                UpdateAchievementRedpoint(id);
            }
        }

        private void UpdateCastSoulRedpoints()
        {
            foreach (var id in treasures.Keys)
            {
                UpdateCastSoulRedpoint(id);
            }
        }

        private void UpdateStoveRedpoint()
        {
            Treasure treasure;
            if (TryGetTreasure(301, out treasure))
            {
                stoveRedpoint.state = RedPointState.None;
                return;
            }
        }

        public bool TreasureStageUpLimit(int _treasureId, bool _tip = true)
        {
            if (PlayerDatas.Instance.baseData.LV >= treasureExitLvLimit)
            {
                return false;
            }
            Treasure _treasure;
            if (TryGetTreasure(_treasureId, out _treasure))
            {
                var human = _treasure as HumanTreasure;
                if (human != null && human.castSoulRedpoint.state == RedPointState.Simple)
                {
                    if (_tip)
                    {
                        SysNotifyMgr.Instance.ShowTip("FabaoAwaken");
                    }
                    return true;
                }
            }
            return false;
        }

        private void OnWindowOpen(Window _window)
        {
            if (_window is MainInterfaceWin)
            {
                SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
                if (needDisplayReguluLevelUp)
                {
                    CheckReguluPop();
                }
            }
        }

        void GuideComplete(int _id)
        {
            SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
        }

        IEnumerator Co_OpenTreasureNewGot()
        {
            yield return WaitingForSecondConst.WaitMS600;
            OpenTreasureNewGot();
        }

        public void CheckOpenTreasureNewGot()
        {
            SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
        }

        private void OpenTreasureNewGot()
        {
            if (!(StageManager.Instance.CurrentStage is DungeonStage) || !serverInited)
            {
                return;
            }
            if (!PreFightMission.Instance.IsFinished() || newGotTreasureId == 0
                || NewBieCenter.Instance.inGuiding || !WindowCenter.Instance.CheckOpen<MainInterfaceWin>()
                || WindowCenter.Instance.ExitAnyFullScreenOrMaskWinLEqual(WindowType.Base)
                || WindowCenter.Instance.CheckOpen<TreasureNewGotWin>())
            {
                return;
            }
            var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
            var mapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if (mapId == 41110)
            {
                return;
            }
            WindowCenter.Instance.Open<TreasureNewGotWin>();
        }

        private void UpdateSkillLevelUpRedpoint(int _treasureId)
        {
            if (treasures.ContainsKey(_treasureId))
            {
                var treasure = treasures[_treasureId];
                if (treasure.skillLevelUpRedpoint == null)
                {
                    return;
                }
                var anyPointialLevelupAble = false;
                if (treasure.state == TreasureState.Collected && treasure.IsHighestStage)
                {
                    for (int i = 0; i < treasure.potentials.Count; i++)
                    {
                        var potential = treasure.potentials[i];
                        if (SatisyPotentialLevelUp(treasure.id, potential.id))
                        {
                            anyPointialLevelupAble = true;
                            break;
                        }
                    }
                }
                treasure.skillLevelUpRedpoint.state = anyPointialLevelupAble ? RedPointState.Simple : RedPointState.None;
            }
        }

        public bool SatisyPotentialLevelUp(int treasureId, int potentialId)
        {
            var treasure = treasures[treasureId];
            var potential = treasure.GetPotential(potentialId);
            if (potential == null)
            {
                return false;
            }
            var config = Config.Instance.Get<SkillConfig>(potential.id);
            if (potential.level >= config.SkillMaxLV)
            {
                return false;
            }

            if (config.LearnSkillReq > 0)
            {
                var preSkillLevelRequirement = config.LearnSkillLV;
                var preSkill = PlayerDatas.Instance.skill.GetSkillBySkillTypeID(config.LearnSkillReq);
                var preSkillLevel = preSkill == null ? 0 : preSkill.level;

                if (preSkillLevel < preSkillLevelRequirement)
                {
                    return false;
                }
            }

            if (PlayerDatas.Instance.baseData.LV < config.LearnLVReq)
            {
                return false;
            }

            var levelUpType = GetSkillLevelUpType(potential.id);
            var levelupId = GetSkillLevelUpId(levelUpType, potential.level + 1);
            var treasureSkillConfig = Config.Instance.Get<TreasureSkillConfig>(levelupId);
            var spOwn = PlayerDatas.Instance.baseData.treasurePotentialSp;
            var spNeed = treasureSkillConfig.MeterialNum1;

            if (spOwn < spNeed)
            {
                return false;
            }

            if (treasureSkillConfig.InitialRate >= 8000)
            {
                return true;
            }
            else
            {
                for (int j = 0; j < treasureSkillConfig.MeterialNum2.Length; j++)
                {
                    var rate = treasureSkillConfig.Rate[j];
                    if (rate >= 6000)
                    {
                        var itemId = treasureSkillConfig.Meterial2ID[j];
                        var own = packageModel.GetItemCountByID(PackType.rptItem, itemId);
                        if (own >= treasureSkillConfig.MeterialNum2[j])
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        private void OnAchievementAwardable(int _achievementId)
        {
            foreach (var treasure in treasures.Values)
            {
                if (treasure.achievements.Contains(_achievementId))
                {
                    UpdateAchievementRedpoint(treasure.id);
                }

            }
        }

        private void OnAchievementCompleted(int _achievementId)
        {
            foreach (var treasure in treasures.Values)
            {
                if (treasure.achievements.Contains(_achievementId))
                {
                    UpdateAchievementRedpoint(treasure.id);
                }

                var config = Config.Instance.Get<TreasureConfig>(treasure.id);
                if (treasure.achievements.Contains(_achievementId))
                {
                    UpdateTreasureCollectProgress(treasure);
                }

                if (treasure.state == TreasureState.Locked)
                {
                    Achievement achievement = null;
                    int _lockAchievement = 0;
                    if (TryGetTreasureUnlockAchievement(treasure.id, out _lockAchievement))
                    {
                        if (achievementModel.TryGetAchievement(_lockAchievement, out achievement)
                            && achievement.completed)
                        {
                            Treasure _pretreasure;
                            switch ((TreasureCategory)config.Category)
                            {
                                case TreasureCategory.Human:
                                    TryGetTreasure(config.PreTreasure, out _pretreasure);
                                    if (_pretreasure == null || _pretreasure.state == TreasureState.Collected)
                                    {
                                        treasure.state = TreasureState.Collecting;
                                        (treasure as HumanTreasure).UpdateTreasureState();
                                        collectingHuman = treasure.id;
                                        if (serverInited)
                                        {
                                            SetTreasureUnlockShow((TreasureCategory)config.Category, config.ID);
                                        }
                                    }
                                    break;
                                case TreasureCategory.Demon:
                                    TryGetTreasure(config.PreTreasure, out _pretreasure);
                                    if (_pretreasure == null || _pretreasure.state == TreasureState.Collected)
                                    {
                                        treasure.state = TreasureState.Collecting;
                                        collectingDemon = treasure.id;
                                        if (serverInited)
                                        {
                                            SetTreasureUnlockShow((TreasureCategory)config.Category, config.ID);
                                        }
                                    }
                                    break;
                                case TreasureCategory.Fairy:
                                    break;
                            }

                            if (treasureStateChangeEvent != null)
                            {
                                treasureStateChangeEvent(treasure.id);
                            }
                        }
                    }
                }
            }

            if (eightFurnacesAchievements.Contains(_achievementId))
            {
                UpdateStoveRedpoint();
            }
        }

        private void UpdateAchievementRedpoint(int _treasureId)
        {
            if (!treasures.ContainsKey(_treasureId))
            {
                return;
            }

            var treasure = treasures[_treasureId];
            var config = Config.Instance.Get<TreasureConfig>(_treasureId);
            treasure.achievementRedpoint.state = RedPointState.None;
            if ((TreasureCategory)config.Category == TreasureCategory.Human && treasure.state != TreasureState.Collected)
            {
                return;
            }

            if ((TreasureCategory)config.Category == TreasureCategory.Demon && !FuncOpen.Instance.IsFuncOpen(107))
            {
                return;
            }

            if((TreasureCategory)config.Category == TreasureCategory.Human && treasure.IsHighestStage)
            {
                return;
            }

            foreach (var achievementGroup in treasure.achievementGroups.Values)
            {
                if (achievementGroup.IsAwardable())
                {
                    treasure.achievementRedpoint.state = RedPointState.Simple;
                    break;
                }

                treasure.achievementRedpoint.state = RedPointState.None;
            }

        }

        private void UpdateCastSoulRedpoint(int _treasureId)
        {
            if (!treasures.ContainsKey(_treasureId))
            {
                return;
            }

            var treasure = treasures[_treasureId] as HumanTreasure;
            if (treasure == null)
            {
                return;
            }
            treasure.castSoulRedpoint.state = RedPointState.None;
            if (treasure.state != TreasureState.Collected ||
                treasure.humanState != HumanTreasureState.CastSoul)
            {
                return;
            }

            var _nextStage = treasure.treasureStages.Find((x) =>
            {
                return x.stage == treasure.stage + 1;
            });
            if (_nextStage != null)
            {
                if (treasure.exp >= _nextStage.exp)
                {
                    treasure.castSoulRedpoint.state = RedPointState.Simple;
                }
            }
        }

        public void UpdateTreasureLevelInfo(HA352_tagMCMagicWeaponLVInfo package)
        {
            for (int i = 0; i < package.Count; i++)
            {
                Treasure treasure;
                if (TryGetTreasure((int)package.InfoList[i].MWID, out treasure))
                {
                    bool _up = false;
                    if (treasure.stage < package.InfoList[i].LV)
                    {
                        _up = true;
                    }
                    treasure.UpdateTreasureLevelExp(package.InfoList[i].LV, (int)package.InfoList[i].Exp, package.InfoList[i].State == 1);
                    if (treasureLevelProgressUpdateEvent != null)
                    {
                        treasureLevelProgressUpdateEvent(treasure.id);
                    }
                    UpdateCastSoulRedpoint(treasure.id);
                    UpdateAchievementRedpoint(treasure.id);
                    if (serverInited && _up && treasureStageUpEvent != null)
                    {
                        treasureStageUpEvent(treasure.id);
                    }
                }
            }
        }

        public void HumanTreasureStateChange(int _id)
        {
            if (humanTreasureStateChangeEvent != null)
            {
                humanTreasureStateChangeEvent(_id);
            }
        }

        public List<int> GetFurnacesAchievements()
        {
            return eightFurnacesAchievements;
        }

        public bool IsVersionUnOpenTreasure(int _id)
        {
            return treasureUnOpens.Contains(_id);
        }

        private void ParseConfigs()
        {
            var treasureConfigs = Config.Instance.GetAllValues<TreasureConfig>();
            foreach (var config in treasureConfigs)
            {
                var category = (TreasureCategory)config.Category;
                List<int> categoryTreasures = null;
                if (!treasureCategory.ContainsKey(category))
                {
                    treasureCategory[category] = categoryTreasures = new List<int>();
                }
                else
                {
                    categoryTreasures = treasureCategory[category];
                }

                categoryTreasures.Add(config.ID);
                var skillLevelUpRedpoint = config.Potentials.Length > 0 ? new Redpoint(CATEGORY_REDPOINTIDS[config.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++) : null;
                var achievementRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[config.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++);
                Treasure treasure;
                if (category == TreasureCategory.Human)
                {
                    var caseSoulRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[config.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++);
                    treasure = new HumanTreasure(config.ID, config.Potentials, skillLevelUpRedpoint, achievementRedpoint, caseSoulRedpoint);
                }
                else
                {
                    treasure = new Treasure(config.ID, config.Potentials, skillLevelUpRedpoint, achievementRedpoint);
                }

                treasures[config.ID] = treasure;

                for (int i = 0; i < config.Achievements.Length; i++)
                {
                    var achieveConfig = Config.Instance.Get<SuccessConfig>(config.Achievements[i]);
                    if (achieveConfig == null)
                    {
                        continue;
                    }
                    if (config.Category == (int)TreasureCategory.Human
                        && (achieveConfig.Type == 3 || achieveConfig.Type == 1))
                    {
                        treasureAchievementDict.Add(config.ID, config.Achievements[i]);
                        break;
                    }
                    else if (config.Category == (int)TreasureCategory.Demon
                        && (achieveConfig.Type == 3 || achieveConfig.Type == 1))
                    {
                        treasureAchievementDict.Add(config.ID, config.Achievements[i]);
                        break;
                    }
                    //else if (config.Category == (int)TreasureCategory.Fairy && config.ID == 301)
                    //{
                    //    eightFurnacesAchievements.Add(config.Achievements[i]);
                    //}
                }

                if (treasure.state == TreasureState.Locked && config.PreTreasure == 0)
                {
                    treasure.state = TreasureState.Collecting;
                    switch ((TreasureCategory)config.Category)
                    {
                        case TreasureCategory.Human:
                            collectingHuman = treasure.id;
                            break;
                        case TreasureCategory.Demon:
                            collectingDemon = treasure.id;
                            break;
                    }
                }

                if (!treasureMapDict.ContainsKey(config.ID))
                {
                    treasureMapDict.Add(config.ID, config.MapId);
                }

                if (config.ID == 301)
                {
                    List<int> list = null;
                    SuccessConfig.TryGetTreasureExpAchievements(config.ID, out list);
                    if (list != null)
                    {
                        eightFurnacesAchievements.AddRange(list);
                    }
                }
            }

            var treasureUpConfigs = Config.Instance.GetAllValues<TreasureUpConfig>();
            foreach (var config in treasureUpConfigs)
            {
                Treasure treasure;
                if (TryGetTreasure(config.MWID, out treasure))
                {
                    treasure.UpdateTreasureStage(config);
                }
            }

            var funcConfig = Config.Instance.Get<FuncConfigConfig>("GuideMission");
            castSoulGuideTaskIds = new List<int>();
            castSoulGuideTaskIds.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
            guideTreasures = new List<int>();
            guideTreasures.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical2));

            funcConfig = Config.Instance.Get<FuncConfigConfig>("TreasureGetVipLv");
            fairyTreasureGetDict = ConfigParse.GetDic<int, int>(funcConfig.Numerical1);

            funcConfig = Config.Instance.Get<FuncConfigConfig>("TreasureSkip");
            treasureBackLvLimit = int.Parse(funcConfig.Numerical1);
            treasureBackPercent = float.Parse(funcConfig.Numerical2);
            funcConfig = Config.Instance.Get<FuncConfigConfig>("TreasureExitLimit");
            treasureExitLvLimit = int.Parse(funcConfig.Numerical1);

            funcConfig = Config.Instance.Get<FuncConfigConfig>("TreasureNoOpen");
            treasureUnOpens.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
        }

        const string pattern = "\\\"[0-9]\\\":\\[[0-9|,]*\\]";
        private void ParseSkillLevelUpConfig()
        {
            try
            {
                var config = Config.Instance.Get<FuncConfigConfig>("SPSkillType");
                var matches = Regex.Matches(config.Numerical1, pattern);

                for (int i = 0; i < matches.Count; i++)
                {
                    var match = matches[i].Value;
                    var stringArray = match.Split(':');

                    var key = 0;
                    int.TryParse(Regex.Match(stringArray[0], "[0-9]").Value, out key);
                    var skillList = skillLevelUpTypes[key] = new List<int>();
                    var skillMatches = Regex.Matches(stringArray[1], "[0-9]{2,}");
                    for (int j = 0; j < skillMatches.Count; j++)
                    {
                        skillList.Add(int.Parse(skillMatches[j].Value));
                    }
                }
            }
            catch (Exception ex)
            {
                DebugEx.Log(ex);
            }

        }

        public static int GetSkillLevelUpId(int _type, int _level)
        {
            return _type * 100 + _level;
        }

        public int GetMapIdByTreasure(int _treasureId)
        {
            if (treasureMapDict.ContainsKey(_treasureId))
            {
                return treasureMapDict[_treasureId];
            }
            return 0;
        }

        public int GetTreasureFightPower(int _treasureId, bool _real = true)
        {
            Treasure treasure;
            if (!TryGetTreasure(_treasureId, out treasure))
            {
                return 0;
            }
            var _fightPower = 0;
            if (treasure.state != TreasureState.Collected)
            {
                return _fightPower;
            }
            for (int i = 0; i < treasure.treasureStages.Count; i++)
            {
                var _stage = treasure.treasureStages[i];
                if (_real && treasure.stage < _stage.stage)
                {
                    break;
                }
                _fightPower += _stage.GetFightPower();
            }
            return _fightPower;
        }

        Dictionary<int, int[]> m_TreasurePotentialGetSkills = new Dictionary<int, int[]>();
        private void ParsePotentialSkillConfig()
        {
            var _cfg = Config.Instance.Get<FuncConfigConfig>("PotentialSkillLearn");
            var _jsonData = LitJson.JsonMapper.ToObject(_cfg.Numerical1);
            foreach (var _key in _jsonData.Keys)
            {
                var _typeId = int.Parse(_key);
                m_TreasurePotentialGetSkills.Add(_typeId, LitJson.JsonMapper.ToObject<int[]>(_jsonData[_key].ToJson()));
            }
        }

        public bool TryGetPotentialGetSkill(int _skillTypeId, out int[] _array)
        {
            return m_TreasurePotentialGetSkills.TryGetValue(_skillTypeId, out _array);
        }

        public bool IsPotentialUnlock(int treasureId, int potentialId)
        {
            if (!FuncOpen.Instance.IsFuncOpen(82))
            {
                return false;
            }
            Treasure treasure;
            if (TryGetTreasure(treasureId, out treasure))
            {
                var potential = treasure.GetPotential(potentialId);
                if (potential != null)
                {
                    var skillConfig = Config.Instance.Get<SkillConfig>(potential.id);
                    if (skillConfig.LearnSkillReq > 0)
                    {
                        var prepotential = treasure.GetPotential(skillConfig.LearnSkillReq);
                        if (prepotential != null && prepotential.level < skillConfig.LearnSkillLV)
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
    }

}