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

using System;
using System.Text.RegularExpressions;

namespace Snxxz.UI
{

    [XLua.LuaCallCSharp]
    public class TreasureModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
    {
        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, TreasureDungeon> treasureDungeons = new Dictionary<int, TreasureDungeon>();
        Dictionary<int, List<int>> treasureTasks = new Dictionary<int, List<int>>();
        Dictionary<TreasureCategory, int> treasureUnlockShowDict = new Dictionary<TreasureCategory, int>();
        Dictionary<int, int> treasureTaskCompletedCounts = new Dictionary<int, int>();
        Dictionary<int, int> treasureSignInPropertys = new Dictionary<int, int>();
        List<int> eightFurnacesAchievements = new List<int>();
        List<int> treasureUnOpens = new List<int>();

        public const int TREASURE_DATAMAPID = 41110;
        public const int TREASURE_MAPID = 41110;
        public const int TREASURE_GUIDE_ID = 102;

        const int TREASURE_REDPOINTID = 7000;
        public 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.King - 1]);
        Redpoint zergRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Zerg - 1]);

        public event Action<int> treasureCollectProgressRefresh;
        public event Action<int> treasureSelectedEvent;
        public event Action<TreasureCategory> collectingTreasureChangeEvent;
        public event Action<int> treasureStateChangeEvent;
        public event Action vipKillNPCTreasureEvent;
        public event Action<int> treasureStageUpEvent;
        public event Action<int> demonTreasureDungeonUpdate;
        public event Action demonDungeonChallengeNext;

        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);
                    }
                }
            }
        }

        public bool treasureStageUpShow { get; set; }

        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);
                    }
                }
            }
        }

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

        public bool isServerReady { 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 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 openFromTreasureList { get; set; }

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

        public int treasureBackLvLimit { get; private set; }
        public int exitRecord { get; set; }
        public int entranceOpenCondition { get; private set; }

        TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }

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

        bool playerLevelRefresh = false;
        bool needDisplayReguluLevelUp = false;


        public override void Init()
        {
            ParseConfigs();

            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;
            WindowCenter.Instance.windowAfterOpenEvent += OnWindowOpen;
            WindowCenter.Instance.windowAfterCloseEvent += OnWindowClose;
            NewBieCenter.Instance.guideCompletedEvent += GuideComplete;
            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
            GlobalTimeEvent.Instance.secondEvent += PerSecond;
            TaskModel.Event_MainlineTask += OnTaskRefresh;
        }

        public void OnBeforePlayerDataInitialize()
        {
            isServerReady = false;
            playerLevelRefresh = false;
            needDisplayReguluLevelUp = false;
            treasureUnlockShowDict.Clear();
            treasureTaskCompletedCounts.Clear();
            foreach (var treasure in treasures.Values)
            {
                treasure.state = TreasureState.Locked;
                treasure.RefreshLevel(0, 0);
            }
            foreach (var treasureDungeon in treasureDungeons.Values)
            {
                treasureDungeon.currentLevel = 0;
            }
        }

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

        public void OnPlayerLoginOk()
        {
            isServerReady = true;
            RefreshDemonDungeonRedpoints();
        }

        public override void UnInit()
        {
            NewBieCenter.Instance.guideCompletedEvent -= GuideComplete;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;
            WindowCenter.Instance.windowAfterOpenEvent -= OnWindowOpen;
            WindowCenter.Instance.windowAfterCloseEvent -= OnWindowClose;
            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
            GlobalTimeEvent.Instance.secondEvent -= PerSecond;
            TaskModel.Event_MainlineTask -= OnTaskRefresh;
        }

        private void PerSecond()
        {
            if (isServerReady)
            {
                if (playerLevelRefresh)
                {
                    playerLevelRefresh = false;
                    RefreshTreasureCollectState();
                }
            }
        }

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

        private void ParseConfigs()
        {
            var treasureConfigs = TreasureConfig.GetValues();
            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);
                Treasure treasure = new Treasure(config.ID);

                treasures[config.ID] = treasure;

                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 = TreasureUpConfig.GetValues();
            foreach (var config in treasureUpConfigs)
            {
                Treasure treasure;
                if (TryGetTreasure(config.MWID, out treasure))
                {
                    treasure.ParseStage(config);
                }
            }

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

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

            funcConfig = FuncConfigConfig.Get("TreasureSkip");
            treasureBackLvLimit = int.Parse(funcConfig.Numerical1);

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

            funcConfig = FuncConfigConfig.Get("OpenFabao");
            entranceOpenCondition = int.Parse(funcConfig.Numerical1);

            var treasureDungeonConfigs = TreasureDungeonConfig.GetValues();
            foreach (var config in treasureDungeonConfigs)
            {
                TreasureDungeon treasureDungeon;
                if (!treasureDungeons.TryGetValue(config.MWID, out treasureDungeon))
                {
                    var treasureConfig = TreasureConfig.Get(config.MWID);
                    var challengeRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[treasureConfig.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++);
                    treasureDungeon = new TreasureDungeon(config.MWID, challengeRedpoint);
                    treasureDungeons.Add(config.MWID, treasureDungeon);
                }
                treasureDungeon.ParseDungeonInfo(config);
            }

            var taskConfigs = TaskListConfig.GetValues();
            foreach (var config in taskConfigs)
            {
                List<int> tasks = null;
                if (!treasureTasks.TryGetValue(config.FabaoID, out tasks))
                {
                    tasks = new List<int>();
                    treasureTasks.Add(config.FabaoID, tasks);
                }
                tasks.Add(config.TaskID);
            }

            funcConfig = FuncConfigConfig.Get("MWSignDayAttr");
            var jsonData = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
            foreach (var _key in jsonData.Keys)
            {
                treasureSignInPropertys.Add(int.Parse(_key), int.Parse(jsonData[_key].ToString()));
            }
        }

        public void TryOpenRegulusPopWindow()
        {
            if (isServerReady)
            {
                if (WindowCenter.Instance.IsOpen<MainInterfaceWin>() && !WindowCenter.Instance.ExistAnyFullScreenOrMaskWin())
                {
                    if (!WindowCenter.Instance.IsOpen<TreasureRegulusPopWin>())
                    {
                        WindowCenter.Instance.Open<TreasureRegulusPopWin>();
                    }
                    needDisplayReguluLevelUp = false;
                }
                else
                {
                    needDisplayReguluLevelUp = true;
                }
            }
        }

        public int IsRequireUnlockAnim(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 TryGetUnlockShowTreasure(out int _id)
        {
            _id = 0;
            if ((_id = IsRequireUnlockAnim(TreasureCategory.Human)) != 0)
            {
                return true;
            }
            else if ((_id = IsRequireUnlockAnim(TreasureCategory.Demon)) != 0)
            {
                return true;
            }
            else if ((_id = IsRequireUnlockAnim(TreasureCategory.Fairy)) != 0)
            {
                return true;
            }
            return false;
        }

        public void SetUnlockAnim(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 bool TryGetTreasure(int _id, out Treasure _treasure)
        {
            return treasures.TryGetValue(_id, out _treasure);
        }

        public bool TryGetTreasureDungeon(int _id, out TreasureDungeon _treasureDungeon)
        {
            return treasureDungeons.TryGetValue(_id, out _treasureDungeon);
        }

        public bool TryGetTreasureDungeon(int _mapId, int lineId, out TreasureDungeon treasureDungeon)
        {
            treasureDungeon = null;
            if (_mapId != 41110)
            {
                return false;
            }
            var list = GetTreasureCategory(TreasureCategory.Demon);
            for (int i = 0; i < list.Count; i++)
            {
                if (TryGetTreasureDungeon(list[i], out treasureDungeon))
                {
                    if (treasureDungeon.dungeonInfos.Count > 0)
                    {
                        if (treasureDungeon.dungeonInfos[0].lineId == lineId)
                        {
                            return true;
                        }
                    }
                }
            }
            return false;
        }

        public bool TryGetTreasureTasks(int id, out List<int> tasks)
        {
            return treasureTasks.TryGetValue(id, out tasks);
        }

        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 GetCollectedTreasureCount(TreasureCategory _category)
        {
            var treasureIds = GetTreasureCategory(_category);
            var count = 0;
            foreach (var id in treasureIds)
            {
                if (treasures[id].state == TreasureState.Collected)
                {
                    count++;
                }
            }
            return count;
        }

        public int GetCompleteTaskCount(int id)
        {
            var count = 0;
            List<int> tasks = null;
            if (TryGetTreasureTasks(id, out tasks))
            {
                var taskId = taskModel.GetLatestMainTaskId();
                var taskState = taskModel.GetQuestState(taskId);
                var lastTask = tasks[tasks.Count - 1];
                if (taskId > lastTask)
                {
                    count = tasks.Count;
                }
                else
                {
                    var index = tasks.IndexOf(taskId);
                    if (index == -1)
                    {
                        count = 0;
                    }
                    else
                    {
                        count = taskState == 3 ? (index + 1) : index;
                    }
                }
                count = Mathf.Min(count, tasks.Count);
            }
            return count;
        }

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

            return 0;
        }

        public int GetTreasureBySkillId(int skillId)
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            for (int i = 0; i < list.Count; i++)
            {
                Treasure treasure;
                if (TryGetTreasure(list[i], out treasure)
                    && treasure.skillId == skillId)
                {
                    return list[i];
                }
            }
            return 0;
        }

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

        public Dictionary<int, int> GetSignInPropertys()
        {
            return treasureSignInPropertys;
        }

        private void PlayerDataRefreshInfoEvent(PlayerDataType refreshType)
        {
            switch (refreshType)
            {
                case PlayerDataType.LV:
                    playerLevelRefresh = true;
                    break;
                case PlayerDataType.FightPoint:
                case PlayerDataType.FightPower:
                    RefreshDemonDungeonRedpoints();
                    break;
            }
        }

        private void RefreshTreasureCollectState()
        {
            RefreshTreasureCollectState(TreasureCategory.Human);
            RefreshTreasureCollectState(TreasureCategory.Demon);
        }

        private void RefreshTreasureCollectState(TreasureCategory category)
        {
            var treasureIds = GetTreasureCategory(category);
            foreach (var id in treasureIds)
            {
                var treasure = treasures[id];
                if (treasure.state != TreasureState.Locked)
                {
                    continue;
                }
                var config = TreasureConfig.Get(id);
                if (config.PreTreasure != 0 && treasures[config.PreTreasure].state != TreasureState.Collected)
                {
                    continue;
                }
                var satisfyCollect = false;
                switch (category)
                {
                    case TreasureCategory.Human:
                        {
                            List<int> tasks;
                            if (TryGetTreasureTasks(id, out tasks))
                            {
                                var firstTask = tasks[0];
                                var taskId = taskModel.GetLatestMainTaskId();
                                var taskState = taskModel.GetQuestState(taskId);
                                if (taskId >= firstTask)
                                {
                                    satisfyCollect = true;
                                    collectingHuman = id;
                                }
                            }
                        }
                        break;
                    case TreasureCategory.Demon:
                        {
                            if (PlayerDatas.Instance.baseData.LV >= config.ChallengeLevel)
                            {
                                satisfyCollect = true;
                                collectingDemon = id;
                            }
                        }
                        break;
                }

                if (satisfyCollect)
                {
                    if (isServerReady)
                    {
                        SetUnlockAnim((TreasureCategory)config.Category, id);
                    }
                    treasure.state = TreasureState.Collecting;
                    if (category == TreasureCategory.Demon)
                    {
                        RefreshDemonDungeonRedpoint(id);
                    }
                }

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

        private void RefreshDemonDungeonRedpoints()
        {
            foreach (var treasureId in treasureDungeons.Keys)
            {
                RefreshDemonDungeonRedpoint(treasureId);
            }
        }

        private void RefreshDemonDungeonRedpoint(int treasureId)
        {
            TreasureDungeon treasureDungeon;
            if (TryGetTreasureDungeon(treasureId, out treasureDungeon))
            {
                treasureDungeon.challengeRedpoint.state = RedPointState.None;
                Treasure treasure;
                if (TryGetTreasure(treasureId, out treasure)
                    && treasure.state != TreasureState.Collecting)
                {
                    return;
                }
                var dungeonInfo = treasureDungeon.Get(treasureDungeon.currentLevel + 1);
                if (!dungeonInfo.Equals(default(TreasureDungeonInfo)))
                {
                    if (PlayerDatas.Instance.baseData.FightPoint >= dungeonInfo.fightPower)
                    {
                        treasureDungeon.challengeRedpoint.state = RedPointState.Simple;
                    }
                }
            }
        }

        #region 法宝新获得表现
        private void OnWindowOpen(Window _window)
        {
            if (_window is MainInterfaceWin)
            {
                SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
                if (needDisplayReguluLevelUp)
                {
                    TryOpenRegulusPopWindow();
                }
            }
        }

        private void OnWindowClose(Window win)
        {
            if (win is LoginAdWin)
            {
                SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
            }
        }

        void GuideComplete(int _id)
        {
            if (newGotTreasureId != 0)
            {
                SnxxzGame.Instance.StartCoroutine(Co_OpenTreasureNewGot());
            }
        }

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

        IEnumerator Co_OpenTreasureNewGot()
        {
            yield return null;
            OpenTreasureNewGot();
        }

        private void OpenTreasureNewGot()
        {
            if (!(StageLoad.Instance.currentStage is DungeonStage) || !isServerReady)
            {
                return;
            }
            if (!PreFightMission.Instance.IsFinished() || newGotTreasureId == 0
                || NewBieCenter.Instance.inGuiding || !WindowCenter.Instance.IsOpen<MainInterfaceWin>()
                || WindowCenter.Instance.ExistAnyFullScreenOrMaskWinLEqual(WindowType.Base)
                || WindowCenter.Instance.IsOpen<TreasureNewGotWin>())
            {
                return;
            }
            var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
            var mapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
            if (mapConfig == null || mapConfig.MapFBType != (int)MapType.OpenCountry)
            {
                return;
            }
            WindowCenter.Instance.Open<TreasureNewGotWin>();
        }
        #endregion

        public void ReceivePackage(HA352_tagMCMagicWeaponLVInfo package)
        {
            for (int i = 0; i < package.Count; i++)
            {
                var data = package.InfoList[i];

                Treasure treasure;
                if (TryGetTreasure((int)data.MWID, out treasure))
                {
                    bool levelUp = false;

                    if (treasure.level < data.LV)
                    {
                        levelUp = true;
                    }

                    treasure.RefreshLevel(data.LV, (int)data.Exp);

                    if (isServerReady && levelUp && treasureStageUpEvent != null)
                    {
                        treasureStageUpEvent(treasure.id);
                    }
                }

                if (treasure.level > 0 && treasure.state != TreasureState.Collected)
                {
                    treasure.state = TreasureState.Collected;
                    var config = TreasureConfig.Get(treasure.id);
                    if (IsRequireUnlockAnim((TreasureCategory)config.Category) == treasure.id)
                    {
                        SetUnlockAnim((TreasureCategory)config.Category, 0);
                    }
                    if (isServerReady)
                    {
                        newGotTreasureId = treasure.id;
                        OpenTreasureNewGot();
                    }
                    if (treasureCollectingShowId == treasure.id)
                    {
                        treasureCollectingShowId = 0;
                    }
                    if (treasureStateChangeEvent != null)
                    {
                        treasureStateChangeEvent(treasure.id);
                    }
                }

                TreasureDungeon treasureDungeon;
                if (TryGetTreasureDungeon((int)data.MWID, out treasureDungeon))
                {
                    treasureDungeon.currentLevel = data.FBPassLV;
                    RefreshDemonDungeonRedpoint(treasureDungeon.treasureId);
                    if (demonTreasureDungeonUpdate != null)
                    {
                        demonTreasureDungeonUpdate(treasureDungeon.treasureId);
                    }
                }
            }

            RefreshTreasureCollectState();
        }

        private void OnTaskRefresh(int MissionID, int MissionState)
        {
            RefreshTreasureCollectState(TreasureCategory.Human);

            var treasureIds = GetTreasureCategory(TreasureCategory.Human);
            foreach (var id in treasureIds)
            {
                var count = GetCompleteTaskCount(id);

                if (!treasureTaskCompletedCounts.ContainsKey(id)
                    || treasureTaskCompletedCounts[id] != count)
                {
                    treasureTaskCompletedCounts[id] = count;
                    if (treasureCollectProgressRefresh != null)
                    {
                        treasureCollectProgressRefresh(id);
                    }
                }
            }
        }

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

        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.level < _stage.stage)
                {
                    break;
                }
                _fightPower += _stage.GetFightPower();
                _fightPower += _stage.powerEx;
            }
            _fightPower += GetExtensionPower(_treasureId);
            return _fightPower;
        }

        public int GetExtensionPower(int _treasureId)
        {
            if (_treasureId == 304)
            {
                var signInDays = ModelCenter.Instance.GetModel<SignInModel>().totalSignInCount;
                if (signInDays == 0)
                {
                    return 0;
                }
                Dictionary<int, int> dict = new Dictionary<int, int>();
                foreach (var key in treasureSignInPropertys.Keys)
                {
                    dict.Add(key, treasureSignInPropertys[key] * signInDays);
                }
                return UIHelper.GetFightPower(dict);
            }
            return 0;
        }

        public bool SatisfyChallenge(int id)
        {
            if (treasures.ContainsKey(id))
            {
                var treasure = treasures[id];
                var config = TreasureConfig.Get(id);
                switch ((TreasureCategory)config.Category)
                {
                    case TreasureCategory.Human:
                        {
                            if (treasure.state != TreasureState.Collecting)
                            {
                                return false;
                            }
                            List<int> tasks = null;
                            if (TryGetTreasureTasks(id, out tasks))
                            {
                                var lastTask = tasks[tasks.Count - 1];
                                var taskId = taskModel.GetLatestMainTaskId();
                                var taskState = taskModel.GetQuestState(taskId);
                                if (taskId > lastTask || (taskId == lastTask && taskState == 3))
                                {
                                    return true;
                                }
                            }
                        }
                        break;
                }
            }
            return false;
        }

        public bool SatisfyEntranceOpen()
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            if (list != null && list.Count > 1)
            {
                if (treasures.ContainsKey(list[1]))
                {
                    if (treasures[list[1]].state != TreasureState.Locked)
                    {
                        return true;
                    }
                }
            }
            var taskModel = ModelCenter.Instance.GetModel<TaskModel>();
            var missions = taskModel.MainTaskDic;
            if (missions != null)
            {
                foreach (var missionId in missions.Keys)
                {
                    if (missionId > entranceOpenCondition)
                    {
                        return true;
                    }
                    else if (missionId == entranceOpenCondition)
                    {
                        return missions[missionId].MissionState == 3;
                    }
                }
                return false;
            }
            return true;
        }

        public void DisplayEntranceLimitHint()
        {
            var taskConfig = PyTaskConfig.Get(entranceOpenCondition);
            if (taskConfig != null)
            {
                SysNotifyMgr.Instance.ShowTip("OpenFabaoHint", taskConfig.lv);
            }
        }

        public void DemonDungeonChallengeNext(int lineId)
        {
            CA508_tagCMDoFBAction pak = new CA508_tagCMDoFBAction();
            pak.ActionType = 0;
            pak.ActionInfo = 0;
            GameNetSystem.Instance.SendInfo(pak);
            var dungeonModel = ModelCenter.Instance.GetModel<DungeonModel>();
            dungeonModel.UpdateCoolDown(DungeonCoolDownType.LeaveMap, 0);
            dungeonModel.UpdateCoolDown(DungeonCoolDownType.FightStart, 0);
            WindowCenter.Instance.Close<DemonTreasureDungeonVictoryWin>();

            TreasureDungeon treasureDungeon;
            if (TryGetTreasureDungeon(41110, lineId, out treasureDungeon))
            {
                if (treasureDungeon.currentLevel == treasureDungeon.maxLevel - 1)
                {
                    BossShowModel.Instance.StartBossShow(41110, lineId);
                }
            }

            if (demonDungeonChallengeNext != null)
            {
                demonDungeonChallengeNext();
            }
        }
    }

}