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

using LitJson;

namespace vnxbqy.UI
{
    
    public class DungeonModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize
    {
        Dictionary<int, Dictionary<int, int>> dungeonMap = new Dictionary<int, Dictionary<int, int>>();//mapid,lineId,DungeonId;
        Dictionary<int, Dictionary<int, int>> dungeonHintMap = new Dictionary<int, Dictionary<int, int>>();
        Dictionary<DungeonCoolDownType, DateTime> dungeonCoolDowns = new Dictionary<DungeonCoolDownType, DateTime>();
        Dictionary<int, DungeonRecord> dungeonRecords = new Dictionary<int, DungeonRecord>();
        Dictionary<int, DailyQuestOpenTime> dungeonOpenTimes = new Dictionary<int, DailyQuestOpenTime>();
        Dictionary<int, int[]> dungeonGradeRewardRate = new Dictionary<int, int[]>();
        Dictionary<int, DungeonEnterCoolDown> dungeonEnterDict = new Dictionary<int, DungeonEnterCoolDown>();
        Dictionary<int, string> dungeonBuyCntFormulaDic = new Dictionary<int, string>();
        Dictionary<int, int> mapIdToDataMapId = new Dictionary<int, int>();
        Dictionary<int, DateTime> dungeonCountRemainTimes = new Dictionary<int, DateTime>();
        Dictionary<int, List<DungeonInspireConfig>> dungeonInspireDict = new Dictionary<int, List<DungeonInspireConfig>>();
        Dictionary<int, int> dungeonCollectNpcInfos = new Dictionary<int, int>();
        Dictionary<int, int> dungeonNpcAttackInfos = new Dictionary<int, int>();
        Dictionary<int, int> dungeonCoverCount = new Dictionary<int, int>();
        List<int> trialDungeonMapList = new List<int>();

        Dictionary<int, int[]> FBCoverCountDict = new Dictionary<int, int[]>();

        public event Action<DungeonCoolDownType> dungeonCoolDownEvent;
        public event Action dungeonBeginCoolDownEndEvent;
        public event Action updateMissionEvent;
        public event Action onDungeonResultEvent;
        public event Action<int> dungeonStageChangeEvent;
        public event Action getDungeonResultEvent;
        public event Action dungeonEnterCoolDownUpdate;
        public event Action updateDungeonBuyCnt;
        public event Action dungeonFairyLandChangeEvent;
        public event Action dungeonInspireLvEvent;
        public event Action<int> dungeonRecordChangeEvent;
        public event Action<int> countRemainTimeChangeEvent;
        public event Action<Dungeon> kylinDifficultySelectedEvent;
        public event Action<DungeonFightStage> dungeonFightStageChangeEevent;
        public event Action onCollectNpcInfoRefresh;
        public event Action onAttackNpcInfoRefresh;

        #region 协助相关数据
        public int selectHurtModel;  // 选择显示1.伤害排行 2.协助伤害

        // boss 伤害排行（协助系统结合）
        BossHurtRankInfo m_BossHurtRank;
        public BossHurtRankInfo BossHurtRank
        {
            get { return m_BossHurtRank; }
        }
        public event Action UpdateBossHurtRankEvent;


        #endregion

        List<Item> sweepResultRewards = new List<Item>();
        List<Item> sweepResultItems = new List<Item>();

        int m_SweepDungeonTypeBuf = 0;
        public int sweepDungeonTypeBuf {
            get { return m_SweepDungeonTypeBuf; }
        }

        Dungeon m_SelectedTrialDungeon;
        public Dungeon selectedTrialDungeon {
            get { return m_SelectedTrialDungeon; }
            set { m_SelectedTrialDungeon = value; }
        }

        Dungeon m_CurrentDungeon;
        public Dungeon currentDungeon {
            get { return m_CurrentDungeon; }
            set { m_CurrentDungeon = value; }
        }

        int m_DungeonGrade = 0;
        public int dungeonGrade {
            get { return m_DungeonGrade; }
        }

        DungeonMissionData m_Mission;
        public DungeonMissionData mission {
            get { return m_Mission; }
        }



        DungeonResult m_DungeonResult;
        public DungeonResult dungeonResult {
            get { return m_DungeonResult; }
            set { m_DungeonResult = value; }
        }

        Dictionary<int, int> dungeonInspireCounts = new Dictionary<int, int>();//5-仙玉或绑玉
        Dictionary<int, int> dungeonInspireUpperDict = new Dictionary<int, int>();
        Dictionary<int, int> dungeonMaxInspireCountDict = new Dictionary<int, int>();

        Dungeon m_SelectedKylinDungeon;
        public Dungeon selectedKylinDungeon {
            get { return m_SelectedKylinDungeon; }
            set {
                if (m_SelectedKylinDungeon != value)
                {
                    m_SelectedKylinDungeon = value;
                    if (kylinDifficultySelectedEvent != null)
                    {
                        kylinDifficultySelectedEvent(m_SelectedKylinDungeon);
                    }
                }
            }
        }

        public Item specialItemCollectRecord;

        public int[] guardSkyBuffIds { get; private set; }
        public int[] guardSkyGuardNpcs { get; private set; }

        public bool inspireNoRemind { get; set; }
        public bool inspireRemindEffective { get; set; }

        public int cacheGradeMap = 0;
        public bool gradeTween = true;

        DungeonFightStage m_DungeonFightStage = DungeonFightStage.None;
        public DungeonFightStage dungeonFightStage {
            get { return m_DungeonFightStage; }
            set {
                if (m_DungeonFightStage != value)
                {
                    m_DungeonFightStage = value;
                    if (dungeonFightStageChangeEevent != null)
                    {
                        dungeonFightStageChangeEevent(m_DungeonFightStage);
                    }
                }
            }
        }

        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        RealmModel realmModel { get { return ModelCenter.Instance.GetModel<RealmModel>(); } }
        BossRebornModel bossRebornModel { get { return ModelCenter.Instance.GetModel<BossRebornModel>(); } }
        DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }

        TeamModel teamModel { get { return ModelCenter.Instance.GetModel<TeamModel>(); } }
        public override void Init()
        {
            ParseConfig();
            StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
        }

        public override void UnInit()
        {
            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
        }

        public void OnBeforePlayerDataInitialize()
        {
            dungeonCountRemainTimes.Clear();
            dungeonInspireCounts.Clear();
            dungeonCollectNpcInfos.Clear();
            dungeonNpcAttackInfos.Clear();
        }

        public void OnAfterPlayerDataInitialize()
        {
        }

        public bool TryGetOpenTime(int _mapId, out DailyQuestOpenTime _openTime)
        {
            return dungeonOpenTimes.TryGetValue(_mapId, out _openTime);
        }

        public bool TryGetCountRemainTime(int _dataMapId, out DateTime _remainTime)
        {
            return dungeonCountRemainTimes.TryGetValue(_dataMapId, out _remainTime) && _remainTime > DateTime.Now;
        }

        public int GetCoverCount(int _dataMapId)
        {
            int count;
            if (!dungeonCoverCount.TryGetValue(_dataMapId, out count)) count = 0;

            int[] allCount;
            if (!FBCoverCountDict.TryGetValue(_dataMapId, out allCount))
                return 0 ;

            return allCount[0] - count;
        }

        public int GetCoverCountYet(int _dataMapId)
        {
            int count;
            if (!dungeonCoverCount.TryGetValue(_dataMapId, out count)) count = 0;

            return count;
        }

        public int GetGrade(Dungeon _dungeon)
        {
            if (dungeonRecords.ContainsKey(_dungeon.mapId))
            {
                var dungeonRecord = dungeonRecords[_dungeon.mapId];
                if (dungeonRecord.lineGrades.ContainsKey(_dungeon.lineId))
                {
                    return dungeonRecord.lineGrades[_dungeon.lineId];
                }
                else
                {
                    return 0;
                }
            }
            else
            {
                return 0;
            }
        }

        public bool TryGetRecord(int _mapId, out DungeonRecord _record)
        {
            return dungeonRecords.TryGetValue(_mapId, out _record);
        }

        public int GetEnterTimes(int _dataMapId)
        {
            DungeonRecord record;
            if (TryGetRecord(_dataMapId, out record))
            {
                return record.enterTimes;
            }
            else
            {
                return 0;
            }
        }


        //显示的上限次数
        public int GetMaxTimesShow(int _dataMapId)
        {
            var config = DungeonOpenTimeConfig.Get(_dataMapId);
            if (config == null)
            {
                return 0;
            }

            return config.DayTimes + InvestModel.Instance.GetFBAddMaxCnt(_dataMapId);
        }

        //总次数
        /// </summary>
        /// <param name="_dataMapId"></param>
        /// <param name="includeVip">true包含当前VIP可增加次数，false则返回含购买的次数</param>
        /// <returns></returns>
        public int GetTotalTimes(int _dataMapId, bool includeVip = false)
        {
            var config = DungeonOpenTimeConfig.Get(_dataMapId);
            if (config == null)
            {
                return 0;
            }

            var totalTimes = config.DayTimes + InvestModel.Instance.GetFBAddMaxCnt(_dataMapId);

            DungeonRecord record;
            TryGetRecord(_dataMapId, out record);
            totalTimes += record != null ? record.recoverTimes : 0;
            totalTimes += record != null ? record.extraTimes : 0;

            var vipModel = ModelCenter.Instance.GetModel<VipModel>();
            switch (_dataMapId)
            {
                //case PersonalBossModel.PERSONALBOSS_MAPID:
                //    totalTimes += vipModel.GetVipPrivilegeCnt(VipPrivilegeType.SelfBoss);
                //    break;
                case ElderGodAreaModel.ELDERGODAREA_MAPID:
                    totalTimes += vipModel.GetVipPrivilegeCnt(VipPrivilegeType.ForbiddenArea);
                    break;
                case CommonDungeonSelectModel.CommonDungenMapID1:
                case CommonDungeonSelectModel.CommonDungenMapID2:
                case CommonDungeonSelectModel.CommonDungenMapID3:
                case CommonDungeonSelectModel.CommonDungenMapID4:
                case CommonDungeonSelectModel.CommonDungenMapID5:
                    if (includeVip)
                        totalTimes += vipModel.GetVipPrivilegeCnt((VipPrivilegeType)CommonDungeonSelectModel.mapIDToVip[_dataMapId]);
                    else
                        totalTimes += record != null ? record.buyTimes : 0;
                    break;
                default:
                    totalTimes += record != null ? record.buyTimes : 0;
                    break;
            }

            return totalTimes + GetCoverCountYet(_dataMapId);
        }

        public int GetBoughtTimes(int _dataMapId)
        {
            DungeonRecord record;
            if (TryGetRecord(_dataMapId, out record))
            {
                return record.buyTimes;
            }
            else
            {
                return 0;
            }
        }

        public int GetAllEnterTimes(int _dataMapId)
        {
            DungeonRecord record;
            if (TryGetRecord(_dataMapId, out record))
            {
                return record.enterCntTotal;
            }
            else
            {
                return 0;
            }
        }

        public int GetBuyTimesLimit(int _dataMapId)
        {
            var config = DungeonOpenTimeConfig.Get(_dataMapId);
            var vipPrivilegeId = config.BuyTimesID;
            if (vipPrivilegeId != 0)
            {
                var maxVipLevel = ModelCenter.Instance.GetModel<VipModel>().vipMaxLv;
                return VipPrivilegeConfig.GetVipPrivilegeData((VipPrivilegeType)vipPrivilegeId, (int)maxVipLevel) + InvestModel.Instance.GetFBAddBuyCnt(_dataMapId);
            }
            else
            {
                return 0;
            }
        }

        public Item GetTicketCost(int _mapId, int _lineId = 0)
        {
            var enterTimes = GetEnterTimes(_mapId);
            var config = DungeonConfig.Get(GetDungeonId(_mapId, _lineId));
            if (config == null)
            {
                return default(Item);
            }
            if (config.TicketID > 0)
            {
                return new Item(config.TicketID, config.TicketCostCnt[Mathf.Clamp(enterTimes, 0, config.TicketCostCnt.Length - 1)]);
            }
            else
            {
                return default(Item);
            }
        }

        public bool TryGetBuyCountCost(int _mapId, out string _formula)
        {
            return dungeonBuyCntFormulaDic.TryGetValue(_mapId, out _formula);
        }

        public bool GetRewardRateWithGrade(int _mapId, int _grade, out int rate)
        {
            rate = 0;
            if (dungeonGradeRewardRate.ContainsKey(_mapId))
            {
                int[] array = dungeonGradeRewardRate[_mapId];
                int _index = 5 - _grade;
                if (_index >= 0 && _index < array.Length)
                {
                    rate = array[_index];
                    return true;
                }
            }
            return false;
        }

        public Item GetSweepCost(Dungeon _dungeon)
        {
            var dungeonId = GetDungeonId(_dungeon);
            var config = DungeonConfig.Get(dungeonId);
            if (config == null)
            {
                return default(Item);
            }
            else
            {
                return new Item(config.SweepItemID, config.SweepCostCnt);
            }
        }

        public void RequestSweep(Dungeon _dungeon)
        {
            m_CurrentDungeon = _dungeon;

            var send = new CA505_tagCMBeginFBWipeOut();
            send.MapID = (ushort)_dungeon.mapId;
            send.LineID = (ushort)_dungeon.lineId;
            send.Cnt = 1;
            send.IsFinish = 1;

            GameNetSystem.Instance.SendInfo(send);
        }

        public bool TestChallange(Dungeon _dungeon, out int _error)
        {
            //错误码：1.副本CD中；2.等级不足；3.转职等级不足；4.剩余次数不足；5.缺少门票
            var dungeonId = GetDungeonId(_dungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);

            if (IsEnterCountDown(_dungeon.mapId))
            {
                _error = 1;
                return false;
            }

            var playerLevel = PlayerDatas.Instance.baseData.LV;
            if (playerLevel < dungeonConfig.LVLimitMin)
            {
                _error = 2;
                return false;
            }

            switch (_dungeon.mapId)
            {
                case 31170:
                    {
                        if (!ModelCenter.Instance.GetModel<FairyModel>().completeGuardSky)
                        {
                            _error = 0;
                            return true;
                        }
                    }
                    break;
                case 31160:
                    _error = 0;
                    return true;
            }

            DungeonRecord record;
            TryGetRecord(currentDungeon.mapId, out record);
            var openTimeConfig = DungeonOpenTimeConfig.Get(_dungeon.mapId);
            var entertimes = GetEnterTimes(_dungeon.mapId);
            var totalTimes = GetTotalTimes(_dungeon.mapId);
            var surplusTimes = totalTimes - entertimes;
            if (surplusTimes <= 0 && openTimeConfig.HelpPoint == 0)
            {
                _error = 4;
                return false;
            }

            if (dungeonConfig.TicketID != 0)
            {
                var cnt = dungeonConfig.TicketCostCnt.Length > entertimes ? dungeonConfig.TicketCostCnt[entertimes] : dungeonConfig.TicketCostCnt[0];
                if (cnt > playerPack.GetItemCountByID(PackType.Item, dungeonConfig.TicketID))
                {
                    _error = 5;
                    return false;
                }
            }

            if (CrossServerUtility.IsCrossServerBoss())
            {
                _error = 6;
                return false;
            }

            _error = 0;
            return true;
        }

        public void ChallengeNextDungeonLevel()
        {
            var cA508 = new CA508_tagCMDoFBAction();
            cA508.ActionType = 1;
            cA508.ActionInfo = (uint)(dungeonResult.lineID + 1);
            GameNetSystem.Instance.SendInfo(cA508);
        }

        public void SingleChallenge(int _dungeonId, int _lineId = 0)
        {
            SingleChallenge(new Dungeon(_dungeonId, _lineId));
        }

        public void SingleChallenge(Dungeon _dungeon)
        {
            var dungeonId = GetDungeonId(_dungeon);
            var dungeonConfig = DungeonConfig.Get(dungeonId);

            var mapId = dungeonConfig.MapID;
            var mapConfig = MapConfig.Get(mapId);
            var teamModel = ModelCenter.Instance.GetModel<TeamModel>();

            if ((MapType)mapConfig.MapFBType == MapType.MultipleFB && teamModel.myTeam.inTeam)
            {
                ConfirmCancel.ShowPopConfirm(
                    Language.Get("Mail101"),
                    Language.Get("PlayerExitTeamSolo"),

                    (bool ok) =>
                    {
                        if (ok)
                        {
                            teamModel.RequestExitTeam();
                            Clock.AlarmAt(DateTime.Now + new TimeSpan(TimeSpan.TicksPerSecond),
                                () =>
                                {
                                    m_CurrentDungeon = _dungeon;
                                    CheckGroupEnter(_dungeon);
                                }
                                );
                        }
                    }
                    );
            }
            else
            {
                m_CurrentDungeon = _dungeon;
                CheckGroupEnter(_dungeon);
            }
        }

        public void GroupChallenge(Dungeon _dungeon)
        {
            var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
            if (!teamModel.myTeam.inTeam)
            {
                ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("FBEnter_NoTeam"), (bool isOk) =>
                {
                    if (isOk)
                    {
                        teamModel.RequestCreateTeam(_dungeon.mapId, _dungeon.lineId, teamModel.myTeam.levelMin, teamModel.myTeam.levelMax);
                        WindowCenter.Instance.Open<TeamFrameWin>();
                    }
                });
            }
            else
            {
                if (teamModel.myTeam.iamCaptainer)
                {
                    if (teamModel.myTeam.memberCount == 1)
                    {
                        ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), GroupChallengeOnlyOneTip(_dungeon.mapId), (bool ok) =>
                        {
                            if (ok)
                            {
                                CheckGroupEnter(_dungeon);
                            }
                            else
                            {
                                CancelGroupEnter(_dungeon);
                            }
                        });
                    }
                    else if (teamModel.myTeam.memberCount - teamModel.myTeam.GetOnlineMemberCount() > 0)
                    {
                        ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("OfflinePlayerNotice"), (bool ok) =>
                        {
                            if (ok)
                            {
                                CheckGroupEnter(_dungeon);
                            }
                        });
                    }
                    else
                    {
                        CheckGroupEnter(_dungeon);
                    }
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("DungeonGroupOnlyTeamLeader");
                }
            }
        }

        private void CancelGroupEnter(Dungeon _dungeon)
        {
            switch (_dungeon.mapId)
            {
                case RealmModel.REALM_DUNGEON_ID:
                    if (!WindowCenter.Instance.IsOpen<TeamFrameWin>())
                    {
                        var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
                        teamModel.missionBuf = teamModel.currentMission = new TeamMission(31110, 1);
                        WindowCenter.Instance.Open<TeamFrameWin>(false, teamModel.myTeam.inTeam ? 1 : 0);
                    }
                    break;
                default:
                    if (!WindowCenter.Instance.IsOpen<TeamFrameWin>())
                    {
                        var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
                        teamModel.missionBuf = teamModel.currentMission = new TeamMission(_dungeon.mapId, _dungeon.lineId);
                        WindowCenter.Instance.Open<TeamFrameWin>(false, teamModel.myTeam.inTeam ? 1 : 0);
                    }
                    break;
            }
        }

        private string GroupChallengeOnlyOneTip(int _mapId)
        {
            return Language.Get("FBEnter_OnlyYou");
        }

        private int ruinsTranscriptMapId;
        private void CheckGroupEnter(Dungeon _dungeon)
        {
            RequestChallangeDungeon(_dungeon.mapId, _dungeon.lineId);
        }

        public bool CanEnter(out int error)
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = MapConfig.Get(mapId);
            if (mapConfig.MapFBType != (int)MapType.OpenCountry ||
                ArenaManager.IsArenaStage() ||
                ClientDungeonStageUtility.isClientDungeon ||
                ClientCrossServerOneVsOne.isClientCrossServerOneVsOne ||
                AdventureStage.Instance.IsInAdventureStage
                )
            {
                error = 1;
                return false;
            }

            if (teamModel.isMatching)
            {
                error = 2;
                return false;
            }

            if (teamModel.teamPrepare.isPreparing)
            {
                error = 3;
                return false;
            }

            if (CrossServerLogin.Instance.IsEnterCrossServerPreparing())
            {
                error = 4;
                return false;
            }

            var deadModel = ModelCenter.Instance.GetModel<PlayerDeadModel>();
            if (deadModel.playerIsDie)
            {
                error = 5;
                return false;
            }
            if (PlayerDatas.Instance.extersion.bossState == 1)
            {
                error = 6;
                return false;
            }

            if (CrossServerUtility.IsCrossServer())
            {
                error = 7;
                return false;
            }
            error = 0;
            return true;
        }

        public void ProcessEnterError(int error)
        {
            switch (error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
                    break;
                case 2:
                    SysNotifyMgr.Instance.ShowTip("CrossMap1");
                    break;
                case 3:
                    SysNotifyMgr.Instance.ShowTip("CrossMap2");
                    break;
                case 4:
                    SysNotifyMgr.Instance.ShowTip("CrossMap3");
                    break;
                case 5:
                    SysNotifyMgr.Instance.ShowTip("CrossMap4");
                    break;
                case 6:
                    SysNotifyMgr.Instance.ShowTip("CrossMap11");
                    break;
                case 7:
                    SysNotifyMgr.Instance.ShowTip("CrossMap10");
                    break;
            }
        }

        public void GroupChallenge(int _dungeonId, int _lineId = 0)
        {
            GroupChallenge(new Dungeon(_dungeonId, _lineId));
        }

        public void ExitCurrentDungeon()
        {
            var send = new C0310_tagCExitFB();
            GameNetSystem.Instance.SendInfo(send);
        }

        public void ResetBufData()
        {
            dungeonFightStage = DungeonFightStage.None;
            specialItemCollectRecord = default(Item);
            dungeonCoolDowns.Clear();
            m_Mission = default(DungeonMissionData);
            dungeonInspireCounts.Clear();
            inspireRemindEffective = false;
            inspireNoRemind = false;
        }

        public void UpdateRecords(HA320_tagMCPlayerFBInfoData.tagMCFBInfo[] _serverInfos)
        {
            for (int i = 0; i < _serverInfos.Length; i++)
            {
                var info = _serverInfos[i];
                var dungeonId = (int)info.FBID;
                if (dungeonRecords.ContainsKey(dungeonId))
                {
                    dungeonRecords[dungeonId].UpdateRecord(info);
                }
                else
                {
                    dungeonRecords[dungeonId] = new DungeonRecord(info);
                }

                if (dungeonRecordChangeEvent != null)
                {
                    dungeonRecordChangeEvent(dungeonId);
                }
            }

        }

        public void UpdateRecords(HA3BD_tagMCBuyEnterInfo.tagMCBuyInfo[] vNetDatas)
        {
            for (int i = 0; i < vNetDatas.Length; i++)
            {
                var info = vNetDatas[i];
                var dungeonId = (int)info.FBID;
                if (dungeonRecords.ContainsKey(dungeonId))
                {
                    dungeonRecords[dungeonId].UpdateRecord(info);
                }
                else
                {
                    dungeonRecords[dungeonId] = new DungeonRecord(info);
                }
            }
            if (updateDungeonBuyCnt != null)
            {
                updateDungeonBuyCnt();
            }
        }

        public DungeonEnterCoolDown GetEnterCoolDown(int _mapID)
        {
            if (dungeonEnterDict.ContainsKey(_mapID))
            {
                return dungeonEnterDict[_mapID];
            }
            return null;
        }

        public bool ContainsDungeonEnter(int _mapID)
        {
            return dungeonEnterDict.ContainsKey(_mapID);
        }

        public bool IsEnterCountDown(int _mapID)
        {
            var dungeonEnterInfo = GetEnterCoolDown(_mapID);
            if (dungeonEnterInfo == null)
            {
                return false;
            }

            if (dungeonEnterInfo.level != 0
                && PlayerDatas.Instance.baseData.LV >= dungeonEnterInfo.level)
            {
                return false;
            }

            return (dungeonEnterInfo.endCoolDownTime - TimeUtility.ServerNow).TotalSeconds > 0;
        }

        public void UpdateEnterCoolDown(HA703_tagMCFBEnterTickList.tagMCFBEnterTick[] vNetDatas)
        {
            for (int i = 0; i < vNetDatas.Length; i++)
            {
                var data = vNetDatas[i];
                if (dungeonEnterDict.ContainsKey((int)data.MapID))
                {
                    dungeonEnterDict[(int)data.MapID].SetEnterTime(data.LastEnterTick);
                }
            }

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

        public void UpdateInspireLevel(int type, int count)
        {
            dungeonInspireCounts[type] = count;
            if (dungeonInspireLvEvent != null)
            {
                dungeonInspireLvEvent();
            }
        }

        public void UpdateDungeonCollectNpcInfo(HA326_tagMCNPCIDCollectionCntInfo package)
        {
            for (int i = 0; i < package.CollNPCCnt; i++)
            {
                var data = package.NPCCollCntList[i];
                dungeonCollectNpcInfos[(int)data.NPCID] = data.CollectionCnt;
            }
            if (onCollectNpcInfoRefresh != null)
            {
                onCollectNpcInfoRefresh();
            }
        }

        public void UpdateDungeonAttackNpcInfo(HA325_tagMCNPCAttackCountInfo package)
        {
            for (int i = 0; i < package.Count; i++)
            {
                var data = package.NPCAttackCountList[i];
                dungeonNpcAttackInfos[(int)data.NPCID] = data.AttackCount;
            }
            if (onAttackNpcInfoRefresh != null)
            {
                onAttackNpcInfoRefresh();
            }
        }

        public void RequestClearEnterCD(int _mapID)
        {
            var clearpack = new CA210_tagCMClearFBCD();
            clearpack.MapID = (uint)_mapID;
            GameNetSystem.Instance.SendInfo(clearpack);
        }

        public void RequestBuyEnterCount(int _mapID)
        {
            var buypack = new CA575_tagCMBuyEnterCount();
            buypack.FBID = (uint)_mapID;
            GameNetSystem.Instance.SendInfo(buypack);
        }

        public void UpdateCoolDown(DungeonCoolDownType _type, uint _millisecond)
        {
            dungeonCoolDowns[_type] = TimeUtility.ServerNow + new TimeSpan(_millisecond * TimeSpan.TicksPerMillisecond);
            if (dungeonCoolDownEvent != null)
            {
                dungeonCoolDownEvent(_type);
            }

            if (_millisecond > 0)
            {
                switch (_type)
                {
                    case DungeonCoolDownType.WaitStart:
                    case DungeonCoolDownType.WaitPlayer:
                    case DungeonCoolDownType.PlayerLeave:
                        dungeonFightStage = DungeonFightStage.Prepare;
                        break;
                    case DungeonCoolDownType.FightStart:
                        dungeonFightStage = DungeonFightStage.Normal;
                        break;
                    case DungeonCoolDownType.PickUpTime:
                        dungeonFightStage = DungeonFightStage.PickUp;
                        break;
                    case DungeonCoolDownType.LeaveMap:
                        dungeonFightStage = DungeonFightStage.ExitPrepare;
                        break;
                    case DungeonCoolDownType.ElderGodAreaDeadTime:
                        dungeonFightStage = DungeonFightStage.ElderGodAreaNearDead;
                        break;
                }

                //switch (_type)
                //{
                //    case DungeonCoolDownType.WaitPlayer:
                //        if (!WindowCenter.Instance.IsOpen<CrossServerOneVsOneWaitPlayerCoolDownWin>())
                //        {
                //            WindowCenter.Instance.Open<CrossServerOneVsOneWaitPlayerCoolDownWin>();
                //        }
                //        break;
                //    case DungeonCoolDownType.PlayerLeave:
                //        if (!WindowCenter.Instance.IsOpen<CrossServerOneVsOnePlayerLeaveCoolDownWin>())
                //        {
                //            WindowCenter.Instance.Open<CrossServerOneVsOnePlayerLeaveCoolDownWin>();
                //        }
                //        break;
                //}
            }

            if (_type == DungeonCoolDownType.WaitStart)
            {
                Clock.AlarmAt(dungeonCoolDowns[_type], OnBeginCoolDownEnd);
            }
        }

        private void OnBeginCoolDownEnd()
        {
            var mapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
            if (mapConfig.MapFBType != (int)MapType.OpenCountry)
            {
                if (dungeonBeginCoolDownEndEvent != null)
                {
                    dungeonBeginCoolDownEndEvent();
                }
            }
        }

        public void UpdateCountRemaintime(HB209_tagMCFBCntRegainRemainTime _serverTimes)
        {


            for (int i = 0; i < _serverTimes.InfoList.Length; i++)
            {
                var info = _serverTimes.InfoList[i];
                int mapID = (int)info.DataMapID;
                dungeonCountRemainTimes[mapID] = TimeUtility.ServerNow 
                    + new TimeSpan(TimeSpan.TicksPerSecond * info.RemainTime);

                // 获取FB已恢复次数
                dungeonCoverCount[mapID] = (int)info.RegainCnt;

                if (countRemainTimeChangeEvent != null)
                {
                    countRemainTimeChangeEvent((int)info.DataMapID);
                }
            }
        }

        public DateTime GetCoolDownEndTime(DungeonCoolDownType _type)
        {
            var endTime = TimeUtility.OriginalTime;
            dungeonCoolDowns.TryGetValue(_type, out endTime);

            return endTime;
        }

        public int GetDugneonNpcCollectCount(int npcId)
        {
            if (dungeonCollectNpcInfos.ContainsKey(npcId))
            {
                return dungeonCollectNpcInfos[npcId];
            }
            return 0;
        }

        public int GetDungeonNpcAttackCount(int npcId)
        {
            if (dungeonNpcAttackInfos.ContainsKey(npcId))
            {
                return dungeonNpcAttackInfos[npcId];
            }
            return 0;
        }

        public void UpdateMission(string _mission)
        {
            var mapId = GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            m_Mission = LitJson.JsonMapper.ToObject<DungeonMissionData>(_mission);
            var lineId = mission.lineID;
            switch (mapId)
            {
                case 31080:
                    {
                        if (!WindowCenter.Instance.IsOpen<DungeonFairyLandWin>())
                        {
                            WindowCenter.Instance.Open<DungeonFairyLandWin>();
                        }
                        if (dungeonFairyLandChangeEvent != null)
                            dungeonFairyLandChangeEvent();
                    }
                    break;
                case 31150:
                    if (!WindowCenter.Instance.IsOpen<ElderGodAngerWin>())
                    {
                        WindowCenter.Instance.Open<ElderGodAngerWin>();
                    }
                    break;
                case FairyLeagueModel.FAIRY_LEAGUE_DUNGEON:
                    ModelCenter.Instance.GetModel<FairyLeagueModel>().UpdateFairyWarHelp(_mission);
                    if (!WindowCenter.Instance.IsOpen<DungeonFairyLeagueMissionWin>())
                    {
                        WindowCenter.Instance.Open<DungeonFairyLeagueMissionWin>();
                    }
                    break;
                case 31160:
                    if (!WindowCenter.Instance.IsOpen<DungeonAncientTargetWin>())
                    {
                        WindowCenter.Instance.Open<DungeonAncientTargetWin>();
                    }
                    break;
                case 31170:
                    if (!WindowCenter.Instance.IsOpen<DungeonMultipleTaskWin>())
                    {
                        WindowCenter.Instance.Open<DungeonMultipleTaskWin>();
                    }
                    break;
                case 31230:
                    //存在打坐和仙盟宴会两个活动，需要判断
                    DailyQuestOpenTime openTime;
                    dailyQuestModel.TryGetOpenTime((int)DailyQuestType.FairyFeast, out openTime);
                    if (openTime.InOpenTime())
                    { 
                        if (m_Mission.hasCollect == 0)
                        {
                            PlayerDatas.Instance.hero.ShowArrow(true);
                        }
                        else
                        {
                            PlayerDatas.Instance.hero.ShowArrow(false);
                        }
                        if (GetDungeonHintId(mapId, lineId) != 0)
                        {
                            if (!WindowCenter.Instance.IsOpen<DungeonMissionHintWin>())
                            {
                                WindowCenter.Instance.Open<DungeonMissionHintWin>();
                            }

                            if (!WindowCenter.Instance.IsOpen<DungeonFairyFeastHintWin>())
                            {
                                WindowCenter.Instance.Open<DungeonFairyFeastHintWin>();
                            }
                        }
                        break;
                    }

                    dailyQuestModel.TryGetOpenTime((int)DailyQuestType.default3, out openTime);
                    if (openTime.InOpenTime())
                    { 
                        ModelCenter.Instance.GetModel<FairyNewModel>().OnReceiveHelpMessage(_mission);
                        if (!WindowCenter.Instance.IsOpen<FamilySitDungeonWin>())
                        {
                            WindowCenter.Instance.Open<FamilySitDungeonWin>();
                        }
                        break;
                    }
                    break;
                case DemonJarModel.DATA_MAPID:
                    //if (!WindowCenter.Instance.IsOpen<DemonJarDamageRankWin>())
                    //{
                    //    WindowCenter.Instance.Open<DemonJarDamageRankWin>();
                    //}
                    break;
                case JadeDynastyBossModel.JADEDYNASTY_MAP:
                    if (!WindowCenter.Instance.IsOpen<JadeDynastyDamageRankWin>())
                    {
                        WindowCenter.Instance.Open<JadeDynastyDamageRankWin>();
                    }
                    break;
                case AllianceBossModel.DATAMAPID:
                    if (!WindowCenter.Instance.IsOpen<AllianceBossHintWin>())
                    {
                        WindowCenter.Instance.Open<AllianceBossHintWin>();
                    }
                    break;
                case RidingPetBossModel.RIDINGPETBOSS_MAP:
                    if (!WindowCenter.Instance.IsOpen<RidingPetBossHintWin>())
                    {
                        WindowCenter.Instance.Open<RidingPetBossHintWin>();
                    }
                    break;
                case TreasureModel.TREASURE_MAPID:
                    break;
                case HeavenBattleModel.HEAVEBATTLE_MAPID:
                    if (GetDungeonHintId(mapId, lineId) != 0)
                    {
                        if (!WindowCenter.Instance.IsOpen<DungeonMissionHintWin>())
                        {
                            WindowCenter.Instance.Open<DungeonMissionHintWin>();
                        }

                        if (!WindowCenter.Instance.IsOpen<XMZZMissionDetailsWin>())
                        {
                            WindowCenter.Instance.Open<XMZZMissionDetailsWin>();
                        }
                    }
                    break;
                case HazyGrassModel.REIKI_DATAMAP:
                case HazyGrassModel.FAIRY_DATAMAP:
                    if (!WindowCenter.Instance.IsOpen<HazyGrassDungeonWin>())
                    {
                        WindowCenter.Instance.Open<HazyGrassDungeonWin>();
                    }
                    break;
                case PersonalBossModel.PERSONALBOSS_MAPID:
                    if (!WindowCenter.Instance.IsOpen<PersonalDropRateWin>())
                    {
                        WindowCenter.Instance.Open<PersonalDropRateWin>();
                    }
                    break;
                case FairyBossModel.MapId:
                    ModelCenter.Instance.GetModel<FairyBossModel>().OnReceiveHelpMessage(_mission);
                    if (!WindowCenter.Instance.IsOpen<FairyBossDungeonWin>())
                    {
                        WindowCenter.Instance.Open<FairyBossDungeonWin>();
                    }
                    break;
                case RealmModel.Tower_MapId:
                    if (!WindowCenter.Instance.IsOpen<RealmTowerHintWin>())
                    {
                        WindowCenter.Instance.Open<RealmTowerHintWin>();
                    }
                    break;
                case GeneralDefine.CrossBattleFieldMapID:
                    ModelCenter.Instance.GetModel<CrossServerModel>().UpdateFBHelp(_mission);
                    ILCrossServerModel.Instance.UpdateMission(_mission);
                    if (!WindowCenter.Instance.IsOpen("CrossServerBattleFieldFBMissionWin"))
                    {
                        WindowCenter.Instance.Open("CrossServerBattleFieldFBMissionWin");
                    }
                    break;
                default:
                    if (GetDungeonHintId(mapId, lineId) != 0)
                    {
                        if (!WindowCenter.Instance.IsOpen<DungeonMissionHintWin>())
                        {
                            WindowCenter.Instance.Open<DungeonMissionHintWin>();
                        }

                        if (!WindowCenter.Instance.IsOpen<DungeonMissionDetailsWin>())
                        {
                            WindowCenter.Instance.Open<DungeonMissionDetailsWin>();
                        }
                    }
                    break;
            }

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

            if (m_Mission.grade > 0 && !WindowCenter.Instance.IsOpen<DungeonGradeWin>())
            {
                WindowCenter.Instance.Open<DungeonGradeWin>();
            }

        }

        // BOSS伤血排行含助战伤害（非副本模块专属暂归类副本管理）
        public void UpdateBossHurtRank(HB415_tagMCBossHurtValueRankInfo pack)
        {
            GActor actore = GAMgr.Instance.GetBySID(pack.ObjID);
            int npcID = actore != null ? (actore as GActorNpcFight).NpcConfig.NPCID : 0;
            if (npcID == bossRebornModel.MWBossID)
            {
                if (!WindowCenter.Instance.IsOpen<BossRebornHurtRankWin>())
                {
                    WindowCenter.Instance.Open<BossRebornHurtRankWin>();
                }
            }
            else
            {
                if (!WindowCenter.Instance.IsOpen<DemonJarDamageRankWin>())
                {
                    WindowCenter.Instance.Open<DemonJarDamageRankWin>();
                }

            }

            var hurtList = new List<BossHurt>();
            m_BossHurtRank.npcObjID = pack.ObjID;
            m_BossHurtRank.hurtValueSelf = 0;
            m_BossHurtRank.hurtRankSelf = 0;
            for (int i = 0; i < pack.HurtCount; i++)
            {
                hurtList.Add(new BossHurt() {
                    HurtID = pack.HurtValueList[i].HurtID,
                    HurtType = pack.HurtValueList[i].HurtType,
                    HurtName = UIHelper.ServerStringTrim(pack.HurtValueList[i].HurtName),
                    totalHurt = pack.HurtValueList[i].HurtValue + (ulong)pack.HurtValueList[i].HurtValueEx * Constants.ExpPointValue,

                });
                if ((pack.HurtValueList[i].HurtType == 2 && pack.HurtValueList[i].HurtID == PlayerDatas.Instance.hero.ActorInfo.teamID)
                    || (pack.HurtValueList[i].HurtType == 1 && pack.HurtValueList[i].HurtID == PlayerDatas.Instance.baseData.PlayerID))
                {
                    m_BossHurtRank.hurtValueSelf = pack.HurtValueList[i].HurtValue + (ulong)pack.HurtValueList[i].HurtValueEx * Constants.ExpPointValue;
                    m_BossHurtRank.hurtRankSelf = i + 1;
                }
            }
            m_BossHurtRank.bossHurtInfo = hurtList;

            var assistBossHurt = new List<AssistBossHurt>();
            for (int i = 0; i < pack.AssistHurtCount; i++)
            {
                assistBossHurt.Add(new AssistBossHurt()
                {
                    playerID = pack.AssistHurtValueList[i].PlayerID,
                    playerName = pack.AssistHurtValueList[i].PlayerName,
                    totalHurt = pack.AssistHurtValueList[i].HurtValue + (long)pack.AssistHurtValueList[i].HurtValueEx * (long)Constants.ExpPointValue,

                });
                if (pack.AssistHurtValueList[i].PlayerID == PlayerDatas.Instance.baseData.PlayerID)
                {
                    m_BossHurtRank.hurtValueSelf = pack.AssistHurtValueList[i].HurtValue + (ulong)pack.AssistHurtValueList[i].HurtValueEx * Constants.ExpPointValue;
                }
            }
            m_BossHurtRank.assistBossHurtInfo = assistBossHurt;
            if (UpdateBossHurtRankEvent != null)
            {
                UpdateBossHurtRankEvent();
            }
        }


        public void UpdateJiaDungeonMission(int _dataMapId, DungeonMissionData _missionData)
        {
            m_Mission = _missionData;
            switch (_dataMapId)
            {
                case DemonJarModel.DATA_MAPID:
                    //if (!WindowCenter.Instance.IsOpen<DemonJarDamageRankWin>())
                    //{
                    //    WindowCenter.Instance.Open<DemonJarDamageRankWin>();
                    //}
                    break;
                case JadeDynastyBossModel.JADEDYNASTY_MAP:
                    if (!WindowCenter.Instance.IsOpen<JadeDynastyDamageRankWin>())
                    {
                        WindowCenter.Instance.Open<JadeDynastyDamageRankWin>();
                    }
                    break;
                case 31190:
                    if (!WindowCenter.Instance.IsOpen<DungeonMissionDetailsWin>())
                    {
                        WindowCenter.Instance.Open<DungeonMissionDetailsWin>();
                    }
                    break;
                case ClientGuardDungeon.DATAMAPID:
                    if (!WindowCenter.Instance.IsOpen<DungeonMissionHintWin>())
                    {
                        WindowCenter.Instance.Open<DungeonMissionHintWin>();
                    }
                    if (!WindowCenter.Instance.IsOpen<DungeonMissionDetailsWin>())
                    {
                        WindowCenter.Instance.Open<DungeonMissionDetailsWin>();
                    }
                    break;
            }

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

        public void ProcessResult(string _msg)
        {
            m_DungeonResult = JsonMapper.ToObject<DungeonResult>(_msg);

            if (AdventureStage.Instance.IsInAdventureStage)
            {
                WindowJumpMgr.Instance.ClearJumpData();
                WindowCenter.Instance.CloseAll(WindowCenter.CloseAllIgnoreType.BaseAndCustom);
                WindowCenter.Instance.Open<MainInterfaceWin>();

                WindowCenter.Instance.Open<DungeonAdventureVictoryWin>();
            }
            else if (m_DungeonResult.isSweep == 1)
            {
                if (WindowCenter.Instance.IsOpen("HazyRegionSweepWin"))
                {
                    return;
                }
                switch (m_DungeonResult.dataMapID)
                {
                    case RuneTowerModel.RUNETOWER_MAPID:
                        var runeTowerModel = ModelCenter.Instance.GetModel<RuneTowerModel>();
                        runeTowerModel.OnGetSweepResult(_msg);
                        break;
                    case TrialDungeonModel.TRIALDUNGOEN_MAPID:
                        WindowCenter.Instance.Open<TrialSweepResultWin>();

                        if (getDungeonResultEvent != null)
                        {
                            getDungeonResultEvent();
                        }
                        break;
                    case 31080:
                        WindowJumpMgr.Instance.WindowJumpToEx("DungeonExpUpVictoryWin");
                        break;
                    default:
                        WindowCenter.Instance.Close<DungeonSweepWin>();
                        WindowCenter.Instance.Open<DungeonSweepResultWin>();

                        if (getDungeonResultEvent != null)
                        {
                            getDungeonResultEvent();
                        }
                        break;
                }
            }
            else if (m_DungeonResult.quickPass == 1)
            {
                //switch (m_DungeonResult.dataMapID)
                //{
                //    case RuneTowerModel.RUNETOWER_MAPID:
                //        WindowCenter.Instance.Open<DungeonRuneTowerVictoryWin>();
                //        break;
                //    case SkyTowerModel.DATA_MAPID:
                //        WindowCenter.Instance.Open<SkyTowerVictoryWin>();
                //        break;
                //    case RealmModel.Tower_MapId:
                //        WindowCenter.Instance.Open<RealmTowerVictoryWin>();
                //        break;
                //}
            }
            else
            {
                if (m_DungeonResult.dataMapID != RuneTowerModel.RUNETOWER_MAPID &&
                    m_DungeonResult.dataMapID != SkyTowerModel.DATA_MAPID &&
                    m_DungeonResult.dataMapID != RealmModel.Tower_MapId)
                {
                    WindowJumpMgr.Instance.ClearJumpData();
                    WindowCenter.Instance.CloseAll(WindowCenter.CloseAllIgnoreType.BaseAndCustom);
                    WindowCenter.Instance.Open<MainInterfaceWin>();
                }
                SoundPlayer.Instance.StopBackGroundMusic();

                if (PlayerDatas.Instance.hero != null)
                {
                    PlayerDatas.Instance.hero.Behaviour.StopHandupAI();
                }

                WindowCenter.Instance.Close<DungeonEndCoolDownWin>();
                WindowCenter.Instance.Close<DungeonPickUpItemCoolDownWin>();

                if (m_DungeonResult.dataMapID == 31080
                    && !NewBieCenter.Instance.completeGuidesBuf.Contains(GeneralDefine.fairyLandGuideId))
                {
                    NewBieCenter.Instance.FinishNewBieGuide(GeneralDefine.fairyLandGuideId);
                }

                if (m_DungeonResult.isPass == 1)
                {
                    switch (m_DungeonResult.dataMapID)
                    {
                        case HeavenBattleModel.HEAVEBATTLE_MAPID://仙魔之争结算界面
                            WindowCenter.Instance.Open<HeavenVictoryWin>();
                            break;
                        case 31140://冰晶矿脉
                            WindowCenter.Instance.Open<DungeonIceCrystalVictoryWin>();
                            break;
                        case 31170://守卫人皇界面
                            WindowCenter.Instance.Open<DungeonGuardSkySettleWin>();
                            break;
                        case 31180:
                            WindowCenter.Instance.Open<DungeonChaosVictoryWin>();
                            break;
                        case DemonJarModel.DATA_MAPID:
                            WindowCenter.Instance.Open<DemonJarVictoryWin>();
                            var demonJarModel = ModelCenter.Instance.GetModel<DemonJarModel>();
                            if (demonJarModel.autoChallengeBoss > 0 && demonJarModel.autoChallengeBoss == demonJarModel.GetBossIdByLine(m_DungeonResult.lineID))
                            {
                                var bossId = demonJarModel.autoChallengeBoss;
                                var isDouble = demonJarModel.isDoubleAward;
                                var rank = m_DungeonResult.rank;

                                demonJarModel.AddAutoChallengeLog(bossId, isDouble, rank);
                                demonJarModel.autoChallengeBoss = 0;
                            }
                            break;
                        case JadeDynastyBossModel.JADEDYNASTY_MAP:
                            WindowCenter.Instance.Open<JadeDynastyBossVictoryWin>();
                            break;
                        case FairyLeagueModel.FAIRY_LEAGUE_DUNGEON:
                        case 31160:
                            break;
                        case 31080:
                            WindowCenter.Instance.Open<DungeonExpUpVictoryWin>();
                            break;
                        case 51010:
                            WindowCenter.Instance.Open<DungeonNuwaVictoryWin>();
                            break;
                        case 31040:
                        case 31050:
                        case 31060:
                            WindowCenter.Instance.Open<DungeonSlayerVictoryWin>();
                            break;
                        case RealmModel.REALM_DUNGEON_ID:
                            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
                            RealmBossShow.Instance.Open(realmLevel);
                            break;
                        case RuneTowerModel.RUNETOWER_MAPID:
                            WindowCenter.Instance.Open<DungeonRuneTowerVictoryWin>();
                            break;
                        case 41110:
                            var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
                            TreasureDungeon treasureDungeon;
                            if (treasureModel.TryGetTreasureDungeon(41110, dungeonResult.lineID, out treasureDungeon))
                            {
                                if (dungeonResult.wheel < treasureDungeon.maxLevel)
                                {
                                    WindowCenter.Instance.Open<DemonTreasureDungeonVictoryWin>();
                                    break;
                                }
                            }
                            if (ClientDungeonStageUtility.isClientDungeon)
                            {
                                UpdateCoolDown(DungeonCoolDownType.LeaveMap, 4 * 1000);
                            }
                            WindowCenter.Instance.Open<DungeonGetTreasureVictoryWin>();
                            WindowCenter.Instance.Open<TreasureDungeonVictoryWin>();
                            break;
                        case SkyTowerModel.DATA_MAPID:
                            WindowCenter.Instance.Open<SkyTowerVictoryWin>();
                            break;
                        case AllianceBossModel.DATAMAPID:
                            WindowCenter.Instance.Open<AllianceBossVictoryWin>();
                            break;
                        case RidingPetBossModel.RIDINGPETBOSS_MAP:
                            WindowCenter.Instance.Open<RidingPetBossVictoryWin>();
                            break;
                        case 22030:
                        case HazyDemonKingModel.CLIENTDATAMAP:
                            WindowCenter.Instance.Open<HazyDemonKingVictoryWin>();
                            break;
                        case ClientGuardDungeon.DATAMAPID:
                            WindowCenter.Instance.Open<DungeonGuardVictoryWin>();
                            break;
                        case RealmModel.Tower_MapId:
                            WindowCenter.Instance.Open<RealmTowerVictoryWin>();
                            WindowCenter.Instance.Close<RealmTowerHintWin>();
                            break;
                        case GeneralDefine.CrossBattleFieldMapID:
                            //WindowCenter.Instance.Open("CrossServerBattleFieldResultWin");
                            break;
                        case GeneralDefine.CrossFamilyBattleMapID:
                            WindowCenter.Instance.Close("CrossServerFamilyBattleFBWin");
                            WindowCenter.Instance.Open("CrossServerFamilyBattleResultWin");
                            break;
                        case ArenaManager.MapID:
                            ArenaManagerModel.Instance.UpdateFBEnd();
                            break;
                        case CrossServerQualifyingModel.DATA_MAPID:
                            CrossServerQualifyingModel.Instance.UpdatePKResult();
                            break;
                        default:
                            WindowCenter.Instance.Open<DungeonVictoryWin>();
                            break;
                    }
                }
                else
                {
                    switch (m_DungeonResult.dataMapID)
                    {
                        case HeavenBattleModel.HEAVEBATTLE_MAPID://仙魔之争结算界面
                            if (dungeonResult.conWinCnt < 1)
                            {
                                WindowCenter.Instance.Open<HeavenFailureWin>();
                            }
                            else
                            {
                                WindowCenter.Instance.Open<HeavenVictoryWin>();
                            }
                            break;
                        case FairyLeagueModel.FAIRY_LEAGUE_DUNGEON:
                        case 31160:
                            break;
                        case 31170://守卫人皇界面
                            WindowCenter.Instance.Open<DungeonGuardSkyDefeatWin>();
                            break;
                        case GeneralDefine.CrossBattleFieldMapID:
                            break;
                        case GeneralDefine.CrossFamilyBattleMapID:
                            WindowCenter.Instance.Close("CrossServerFamilyBattleFBWin");
                            WindowCenter.Instance.Open("CrossServerFamilyBattleResultWin");
                            break;
                        case ArenaManager.MapID:
                            ArenaManagerModel.Instance.UpdateFBEnd();
                            break;
                        case CrossServerQualifyingModel.DATA_MAPID:
                            CrossServerQualifyingModel.Instance.UpdatePKResult();
                            break;
                        default:
                            WindowCenter.Instance.Open<DungeonDefeatedWin>();
                            break;
                    }
                }
            }

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

        public int GetDungeonHintId(int _dataMapId, int _lineId)
        {
            if (dungeonHintMap.ContainsKey(_dataMapId) && dungeonHintMap[_dataMapId].ContainsKey(_lineId))
            {
                return dungeonHintMap[_dataMapId][_lineId];
            }
            else
            {
                return 0;
            }
        }

        public int GetDungeonId(int _dataMapId, int _lineId)
        {
            if (dungeonMap.ContainsKey(_dataMapId) && dungeonMap[_dataMapId].ContainsKey(_lineId))
            {
                return dungeonMap[_dataMapId][_lineId];
            }
            else
            {
                return 0;
            }
        }

        public int GetDungeonId(Dungeon _dungeon)
        {
            return GetDungeonId(_dungeon.mapId, _dungeon.lineId);
        }

        public List<int> GetDungeonIds(int _mapId)
        {
            if (dungeonMap.ContainsKey(_mapId))
            {
                return new List<int>(dungeonMap[_mapId].Values);
            }
            else
            {
                return null;
            }
        }

        public List<int> GetDugeonLines(int _dataMapId)
        {
            if (dungeonMap.ContainsKey(_dataMapId))
            {
                return new List<int>(dungeonMap[_dataMapId].Keys);
            }
            else
            {
                return null;
            }
        }

        public List<int> GetTrialMaps()
        {
            return trialDungeonMapList;
        }

        public int GetDataMapIdByMapId(int _mapId)
        {
            if (_mapId == DemonJarModel.SINGLEMAPID)
            {
                return DemonJarModel.DATA_MAPID;
            }
            else
            {
                //单人副本存在假副本，和服务端1对客户端多地图同分线情况 如100 要找到 31290；而31290还是要找31290
                var config = MapConfig.Get(_mapId);
                if (config != null && config.MapFBType == (int)MapType.SingleFB)
                {
                    if (PlayerDatas.Instance.baseData.dungeonMapId != 0)
                    {
                        config = MapConfig.Get(PlayerDatas.Instance.baseData.dungeonMapId);
                        if (config != null && (config.MapFBType == (int)MapType.SingleFB || config.MapFBType == 10))
                        {
                            _mapId = PlayerDatas.Instance.baseData.dungeonMapId;
                        }
                        
                    }
                }

                if (mapIdToDataMapId.ContainsKey(_mapId))
                {
                    return mapIdToDataMapId[_mapId];
                }
                else
                {
                    return 0;
                }
            }
        }

        public List<DungeonTarget> GetTargets(int _dataMapId, int _lineId, int _step)
        {
            var hintId = GetDungeonHintId(_dataMapId, _lineId);
            if (hintId == 0)
            {
                return null;
            }

            var config = DungeonHintConfig.Get(hintId);
            var step = Mathf.Clamp(_step - 1, 0, int.MaxValue);

            if (config == null)
            {
                return null;
            }
            else
            {
                var dungeonTargets = new List<DungeonTarget>();
                if (config.targetValue1.Length > step && config.targetNum >= 1)
                {
                    var npcId = config.NPC1ID.Length > step ? config.NPC1ID[step] : 0;
                    dungeonTargets.Add(new DungeonTarget((DungeonTargetType)config.targetType1, npcId, config.targetValue1[step]));
                }

                if (config.targetValue2.Length > step && config.targetNum >= 2)
                {
                    var npcId = config.NPC2ID.Length > step ? config.NPC2ID[step] : 0;
                    dungeonTargets.Add(new DungeonTarget((DungeonTargetType)config.targetType2, npcId, config.targetValue2[step]));
                }

                if (config.targetValue3.Length > step && config.targetNum >= 3)
                {
                    var npcId = config.NPC3ID.Length > step ? config.NPC3ID[step] : 0;
                    dungeonTargets.Add(new DungeonTarget((DungeonTargetType)config.targetType3, npcId, config.targetValue3[step]));
                }

                return dungeonTargets;
            }
        }

        public void RequestChallangeDungeon(int _dataMapId, int _lineId)
        {
            var dungeonConfig = DungeonConfig.Get(GetDungeonId(_dataMapId, _lineId));
            if (!AssetSource.sceneFromEditor)
            {
                var assetValid = true;
                if (dungeonConfig != null)
                {
                    assetValid = AssetVersionUtility.IsSceneAssetValid(dungeonConfig.MapID, _lineId);
                }

                if (!assetValid)
                {
                    InGameDownLoad.Instance.TryDownLoad(InGameDownLoad.Dominant.Whole);
                    return;
                }
            }

            if (CrossServerLogin.Instance.IsEnterCrossServerPreparing())
            {
                return;
            }

            if (CrossServerUtility.IsCrossServer())
            {
                SysNotifyMgr.Instance.ShowTip("CrossMap10");
                return;
            }

            MapTransferUtility.Instance.Clear();
            var send = new C0321_tagCEnterFbGameEvent();
            send.MapID = (ushort)_dataMapId;
            send.LineID = (ushort)_lineId;
            GameNetSystem.Instance.SendInfo(send);
        }

        public int GetBelongToLine(int _dailyQuestId)
        {
            var config = DailyQuestConfig.Get(_dailyQuestId);
            var lineIds = GetDugeonLines(config.RelatedID);
            var _lv = PlayerDatas.Instance.baseData.LV;
            for (int i = 0; i < lineIds.Count; i++)
            {
                var _dungeonId = GetDungeonId(config.RelatedID, lineIds[i]);
                DungeonConfig _dungeonCfg = DungeonConfig.Get(_dungeonId);
                if (_lv < _dungeonCfg.LVLimitMin)
                {
                    if (i > 0)
                    {
                        return lineIds[i - 1];
                    }
                }
            }
            return lineIds[lineIds.Count - 1];
        }

        public List<DungeonInspireConfig> GetDungeonInspire(int _dataMapId)
        {
            if (dungeonInspireDict.ContainsKey(_dataMapId))
            {
                return dungeonInspireDict[_dataMapId];
            }
            else
            {
                return null;
            }
        }

        public int GetDungeonInspireLevel(int moneyType = 0)//0代表总等级
        {
            var level = 0;
            foreach (var key in dungeonInspireCounts.Keys)
            {
                if (moneyType == 0 || moneyType == key)
                {
                    level += dungeonInspireCounts[key];
                }
            }
            return level;
        }

        public int GetDungeonInspireCost(DungeonInspireConfig config)
        {
            var level = GetDungeonInspireLevel();
            Equation.Instance.Clear();
            Equation.Instance.AddKeyValue("encourageLV", level);
            return Equation.Instance.Eval<int>(config.MoneyCount);
        }

        public int GetDungeonInspireUpper(int mapId)
        {
            return dungeonInspireUpperDict.ContainsKey(mapId) ? dungeonInspireUpperDict[mapId] : 0;
        }

        public int GetInspireMaxCount(int _dataMapId)
        {
            return dungeonMaxInspireCountDict.ContainsKey(_dataMapId) ? dungeonMaxInspireCountDict[_dataMapId] : 0;
        }

        public Item GetLackItem(DungeonSuppliesLackWin.LackType lackType)
        {
            switch (lackType)
            {
                case DungeonSuppliesLackWin.LackType.ElderGodArea:
                    return GetTicketCost(ElderGodAreaModel.ELDERGODAREA_MAPID);
                case DungeonSuppliesLackWin.LackType.Kylin:
                    return GetSweepCost(selectedKylinDungeon);
                case DungeonSuppliesLackWin.LackType.IceCrystal:
                    return GetSweepCost(new Dungeon(31140, 0));
                case DungeonSuppliesLackWin.LackType.FairyLand:
                    return GetTicketCost(31080);
                case DungeonSuppliesLackWin.LackType.SingleIceCrystal:
                    return GetTicketCost(31140);
                default:
                    return default(Item);
            }
        }

        public bool IsElderGodExpel()
        {
            var dataMapId = GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            return dataMapId == ElderGodAreaModel.ELDERGODAREA_MAPID && mission.score >= 100;
        }

        private void OnStageLoadFinish()
        {
            if (PlayerDatas.Instance.baseData.MapID != cacheGradeMap)
            {
                cacheGradeMap = PlayerDatas.Instance.baseData.MapID;
                gradeTween = true;
            }
        }

        private void ParseConfig()
        {
            ruinsTranscriptMapId = int.Parse(FuncConfigConfig.Get("SpRewardMapID").Numerical1);
            var allDungeonHint = DungeonHintConfig.GetValues();
            foreach (var dungeonHint in allDungeonHint)
            {
                Dictionary<int, int> subDictionary;
                if (dungeonHintMap.ContainsKey(dungeonHint.dataMapId))
                {
                    subDictionary = dungeonHintMap[dungeonHint.dataMapId];
                }
                else
                {
                    dungeonHintMap[dungeonHint.dataMapId] = subDictionary = new Dictionary<int, int>();
                }

                subDictionary[dungeonHint.LineId] = dungeonHint.ID;
            }

            var allDungeon = DungeonConfig.GetValues();
            foreach (var config in allDungeon)
            {
                Dictionary<int, int> dungeonGroup;
                if (dungeonMap.ContainsKey(config.DataMapID))
                {
                    dungeonGroup = dungeonMap[config.DataMapID];
                }
                else
                {
                    dungeonMap[config.DataMapID] = dungeonGroup = new Dictionary<int, int>();
                }

                dungeonGroup[config.LineID] = config.ID;
                mapIdToDataMapId[config.MapID] = config.DataMapID;

                if (!dungeonOpenTimes.ContainsKey(config.DataMapID))
                {
                    var openTime = dungeonOpenTimes[config.DataMapID] = new DailyQuestOpenTime(config.DataMapID);
                    openTime.ParseDungeonNormalOpenTimes(DungeonStateTimeConfig.DungeonStateCanEnterFB(config.DataMapID));
                    openTime.ParseDungeonSpecialOpenTimes(DungeonSpecialStateTimeConfig.GetDungeonTimes(config.DataMapID));
                }
            }

            var allDungeonOpenTime = DungeonOpenTimeConfig.GetValues();
            foreach (var config in allDungeonOpenTime)
            {
                int dungeonId = config.DataMapID;
                if (!dungeonGradeRewardRate.ContainsKey(dungeonId))
                {
                    dungeonGradeRewardRate.Add(dungeonId, config.RewardRate);
                }
            }

            var funcConfig = FuncConfigConfig.Get("FBEnterCD");
            if (funcConfig != null)
            {
                Dictionary<int, int> dict = ConfigParse.GetDic<int, int>(funcConfig.Numerical1);
                foreach (var key in dict.Keys)
                {
                    DungeonEnterCoolDown data = new DungeonEnterCoolDown();
                    data.mapId = key;
                    data.duration = dict[key];
                    dungeonEnterDict.Add(key, data);
                }
                dict = ConfigParse.GetDic<int, int>(funcConfig.Numerical2);
                foreach (var key in dict.Keys)
                {
                    dungeonEnterDict[key].clearCoolDownCost = dict[key];
                }
                dict = ConfigParse.GetDic<int, int>(funcConfig.Numerical3);
                foreach (var key in dict.Keys)
                {
                    dungeonEnterDict[key].level = dict[key];
                }
            }

            funcConfig = FuncConfigConfig.Get("BuyFBCntCost");
            if (funcConfig != null)
            {
                JsonData jsonData = JsonMapper.ToObject(funcConfig.Numerical1);
                foreach (var key in jsonData.Keys)
                {
                    int _mapId = int.Parse(key);
                    dungeonBuyCntFormulaDic.Add(_mapId, jsonData[key].ToString());
                }
            }
            funcConfig = FuncConfigConfig.Get("MunekadoMapID");
            if (funcConfig != null)
            {
                trialDungeonMapList.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
            }

            funcConfig = FuncConfigConfig.Get("FBEncourageBuff");
            if (funcConfig != null)
            {
                dungeonMaxInspireCountDict = ConfigParse.GetDic<int, int>(funcConfig.Numerical2);
                dungeonInspireUpperDict = ConfigParse.GetDic<int, int>(funcConfig.Numerical3);
            }

            foreach (var _cfg in DungeonInspireConfig.GetValues())
            {
                List<DungeonInspireConfig> _list = null;
                if (dungeonInspireDict.TryGetValue(_cfg.DataMapId, out _list) == false)
                {
                    _list = new List<DungeonInspireConfig>();
                    dungeonInspireDict.Add(_cfg.DataMapId, _list);
                }
                _list.Add(_cfg);
            }

            funcConfig = FuncConfigConfig.Get("FamilyInvadeCfg");
            if (funcConfig != null)
            {
                guardSkyBuffIds = JsonMapper.ToObject<int[]>(funcConfig.Numerical4);
                guardSkyGuardNpcs = JsonMapper.ToObject<int[]>(funcConfig.Numerical5);
            }

            funcConfig = FuncConfigConfig.Get("FBCntRegainInterval");

            

            var json = LitJson.JsonMapper.ToObject(funcConfig.Numerical1);
            foreach (var key in json.Keys)
            {
                var mapID = int.Parse(key);
                var array = LitJson.JsonMapper.ToObject<int[]>(json[key].ToJson());
                FBCoverCountDict[mapID] = array;
            }
        }

        //个人等副本不让使用雷诛，容易造成数据冲突
        public bool CanFlashKill()
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = MapConfig.Get(mapId);
            if (mapConfig.MapFBType == (int)MapType.SingleFB || mapConfig.MapFBType == (int)MapType.VSRoom)
            {
                return false;
            }

            return true;
        }
    }
}