using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using TableConfig;
using LitJson;
using Snxxz.UI;

namespace Snxxz.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, DungeonEnterCD> dungeonEnterDic = new Dictionary<int, DungeonEnterCD>();
        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>>();
        List<int> trialDungeonMapList = new List<int>();

        public event Action<DungeonCoolDownType> dungeonCoolDownEvent;
        public event Action dungeonBeginCoolDownEndEvent;
        public event Action updateMissionEvent;
        public event Action<int> dungeonStageChangeEvent;
        public event Action getDungeonResultEvent;
        public event Action updateDungeonEnterCD;
        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;

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

        public int dungeonCoinInspireCount {
            get; private set;
        }

        public int dungeonJadeInspireCount {
            get; private set;
        }

        public int dungeonInspireUper {
            get; private set;
        }

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

        PlayerPackModel playerPack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        RealmModel realmModel { get { return ModelCenter.Instance.GetModel<RealmModel>(); } }

        public override void Init()
        {
            ParseConfig();
            StageManager.Instance.onStageLoadFinish += OnStageLoadFinish;
        }

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

        public void OnBeforePlayerDataInitialize()
        {
            dungeonCountRemainTimes.Clear();
            dungeonCoinInspireCount = 0;
            dungeonJadeInspireCount = 0;
        }

        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 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 GetTotalTimes(int _dataMapId)
        {
            var config = Config.Instance.Get<DungeonOpenTimeConfig>(_dataMapId);
            if (config == null)
            {
                return 0;
            }

            var totalTimes = config.DayTimes;

            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;
                default:
                    totalTimes += record != null ? record.buyTimes : 0;
                    break;
            }

            return totalTimes;
        }

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

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

        public Item GetTicketCost(int _mapId, int _lineId = 0)
        {
            var enterTimes = GetEnterTimes(_mapId);
            var config = Config.Instance.Get<DungeonConfig>(GetDungeonId(_mapId, _lineId));
            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 = Config.Instance.Get<DungeonConfig>(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 = Config.Instance.Get<DungeonConfig>(dungeonId);

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

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

            var jobRank = PlayerDatas.Instance.baseData.ExAttr1;
            if (jobRank < dungeonConfig.JobRankLimit)
            {
                _error = 3;
                return false;
            }

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

            DungeonRecord record;
            TryGetRecord(currentDungeon.mapId, out record);
            var openTimeConfig = Config.Instance.Get<DungeonOpenTimeConfig>(_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.rptItem, dungeonConfig.TicketID))
                {
                    _error = 5;
                    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 = Config.Instance.Get<DungeonConfig>(dungeonId);

            var mapId = dungeonConfig.MapID;
            var mapConfig = Config.Instance.Get<MapConfig>(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.Create(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.mapId);
                            }
                        });
                    }
                    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(int _mapId)
        {
            switch (_mapId)
            {
                case RealmModel.REALM_DUNGEON_ID:
                    if (!WindowCenter.Instance.CheckOpen<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;
            }
        }

        private string GroupChallengeOnlyOneTip(int _mapId)
        {
            switch (_mapId)
            {
                case 60010:
                    if (PlayerDatas.Instance.baseData.LV < GeneralConfig.Instance.trialDungeonGroupChallengeTipLv)
                    {
                        return Language.Get("SingleIntoFB");
                    }
                    break;
            }
            return Language.Get("FBEnter_OnlyYou");
        }

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

        private void OpenFloorChooseWin()
        {
            var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
            var mainModel = ModelCenter.Instance.GetModel<PlayerMainDate>();
            if (teamModel.myTeam.GetOnlineMemberCount() > 0)
            {
                var cB910 = new CB910_tagCGQueryTeamMemFuncData();
                cB910.TeamMemFuncType = 0;
                GameNetSystem.Instance.SendInfo(cB910);
            }
            else
            {
                int Index = -1;
                if (dungeonRecords.ContainsKey(51010))
                {
                    var DungeonRecord = dungeonRecords[51010];
                    for (int i = 0; i < DungeonRecord.lineGrades.Count; i++)
                    {
                        if (DungeonRecord.lineGrades[i] == 5)
                        {
                            Index = i;
                        }
                    }
                }
                if (Index > -1)
                {
                    if (Index + 1 > 8)
                    {
                        mainModel._layerNumber = 8;
                    }
                    else
                    {
                        mainModel._layerNumber = Index + 1;
                    }

                }
                else
                {
                    mainModel._layerNumber = 0;
                }
            }
            SnxxzGame.Instance.StartCoroutine(AwaitTime());
        }

        IEnumerator AwaitTime()
        {
            yield return WaitingForSecondConst.WaitMS700;
            WindowCenter.Instance.Open<FloorChooseWin>();
        }

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

        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 DungeonEnterCD GetEnterCD(int _mapID)
        {
            if (dungeonEnterDic.ContainsKey(_mapID))
            {
                return dungeonEnterDic[_mapID];
            }
            return null;
        }

        public bool HasEnterCD(int _mapID)
        {
            return dungeonEnterDic.ContainsKey(_mapID);
        }

        public bool IsEnterCountDowning(int _mapID)
        {
            var cd = GetEnterCD(_mapID);
            if (cd == null)
            {
                return false;
            }

            if (cd.dungeonSurplusTime == 0)
            {
                return false;
            }

            return (cd.overdueTime - DateTime.Now).TotalSeconds > 0;
        }

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

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

        public void UpdateInspireLevel(int coinInspireLv, int jadeInpsireLv)
        {
            dungeonCoinInspireCount = coinInspireLv;
            dungeonJadeInspireCount = jadeInpsireLv;
            if (dungeonInspireLvEvent != null)
            {
                dungeonInspireLvEvent();
            }
        }

        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] = DateTime.Now + new TimeSpan(_millisecond * TimeSpan.TicksPerMillisecond);
            if (dungeonCoolDownEvent != null)
            {
                dungeonCoolDownEvent(_type);
            }

            if (_millisecond > 0)
            {
                switch (_type)
                {
                    case DungeonCoolDownType.WaitStart:
                        dungeonFightStage = DungeonFightStage.Prepare;
                        break;
                    case DungeonCoolDownType.TowerTake:
                        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;
                }
            }

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

        private void OnBeginCoolDownEnd()
        {
            var mapConfig = Config.Instance.Get<MapConfig>(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];
                dungeonCountRemainTimes[(int)info.DataMapID] = DateTime.Now + new TimeSpan(TimeSpan.TicksPerSecond * info.RemainTime);

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

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

            return endTime;
        }

        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.CheckOpen<DungeonFairyLandWin>())
                        {
                            WindowCenter.Instance.Open<DungeonFairyLandWin>();
                        }
                        if (dungeonFairyLandChangeEvent != null)
                            dungeonFairyLandChangeEvent();
                    }
                    break;
                case 31150:
                    if (!WindowCenter.Instance.CheckOpen<ElderGodAngerWin>())
                    {
                        WindowCenter.Instance.Open<ElderGodAngerWin>();
                    }
                    break;
                case FairyLeagueModel.FAIRY_LEAGUE_DUNGEON:
                    ModelCenter.Instance.GetModel<FairyLeagueModel>().UpdateFairyWarHelp(_mission);
                    if (!WindowCenter.Instance.CheckOpen<DungeonFairyLeagueMissionWin>())
                    {
                        WindowCenter.Instance.Open<DungeonFairyLeagueMissionWin>();
                    }
                    break;
                case 31160:
                    if (!WindowCenter.Instance.CheckOpen<DungeonAncientTargetWin>())
                    {
                        WindowCenter.Instance.Open<DungeonAncientTargetWin>();
                    }
                    break;
                case 31170:
                    if (!WindowCenter.Instance.CheckOpen<DungeonMultipleTaskWin>())
                    {
                        WindowCenter.Instance.Open<DungeonMultipleTaskWin>();
                    }
                    break;
                case 31230:
                    if (m_Mission.hasCollect == 0)
                    {
                        PlayerDatas.Instance.hero.ShowArrow(true);
                    }
                    else
                    {
                        PlayerDatas.Instance.hero.ShowArrow(false);
                    }
                    if (GetDungeonHintId(mapId, lineId) != 0)
                    {
                        if (!WindowCenter.Instance.CheckOpen<DungeonMissionHintWin>())
                        {
                            WindowCenter.Instance.Open<DungeonMissionHintWin>();
                        }

                        if (!WindowCenter.Instance.CheckOpen<DungeonFairyFeastHintWin>())
                        {
                            WindowCenter.Instance.Open<DungeonFairyFeastHintWin>();
                        }
                    }
                    break;
                case DemonJarModel.DEMONJAR_MAPID:
                    if (!WindowCenter.Instance.CheckOpen<DemonJarDamageRankWin>())
                    {
                        WindowCenter.Instance.Open<DemonJarDamageRankWin>();
                    }
                    break;
                case TreasureModel.TREASURE_MAPID:
                    break;
                case HeavenBattleModel.HEAVEBATTLE_MAPID:
                    if (GetDungeonHintId(mapId, lineId) != 0)
                    {
                        if (!WindowCenter.Instance.CheckOpen<DungeonMissionHintWin>())
                        {
                            WindowCenter.Instance.Open<DungeonMissionHintWin>();
                        }

                        if (!WindowCenter.Instance.CheckOpen<XMZZMissionDetailsWin>())
                        {
                            WindowCenter.Instance.Open<XMZZMissionDetailsWin>();
                        }
                    }
                    break;
                default:
                    if (GetDungeonHintId(mapId, lineId) != 0)
                    {
                        if (!WindowCenter.Instance.CheckOpen<DungeonMissionHintWin>())
                        {
                            WindowCenter.Instance.Open<DungeonMissionHintWin>();
                        }

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

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

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

        }

        public void UpdateFakeDungeonMission(int _dataMapId, DungeonMissionData _missionData)
        {
            m_Mission = _missionData;
            switch (_dataMapId)
            {
                case DemonJarModel.DEMONJAR_MAPID:
                    if (!WindowCenter.Instance.CheckOpen<DemonJarDamageRankWin>())
                    {
                        WindowCenter.Instance.Open<DemonJarDamageRankWin>();
                    }
                    break;
            }

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

        public void ProcessResult(string _msg)
        {
            m_DungeonResult = LitJson.JsonMapper.ToObject<DungeonResult>(_msg);
            if (m_DungeonResult.isSweep == 1)
            {
                switch (m_DungeonResult.dataMapID)
                {
                    case RuneTowerModel.RUNETOWER_MAPID:
                        var runeTowerModel = ModelCenter.Instance.GetModel<RuneTowerModel>();
                        runeTowerModel.OnGetSweepResult(_msg);
                        break;
                    default:
                        WindowCenter.Instance.Close<DungeonSweepWin>();
                        WindowCenter.Instance.Open<DungeonSweepResultWin>();

                        if (getDungeonResultEvent != null)
                        {
                            getDungeonResultEvent();
                        }
                        break;
                }
            }
            else
            {
                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(GeneralConfig.Instance.fairyLandGuideId))
                {
                    NewBieCenter.Instance.FinishNewBieGuide(GeneralConfig.Instance.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.DEMONJAR_MAPID:
                            WindowCenter.Instance.Open<DemonJarVictoryWin>();
                            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 realmConfig = Config.Instance.Get<RealmConfig>(realmModel.cacheRealmLv);
                            if (realmConfig != null && realmConfig.IsBigRealm == 1
                                && dungeonResult.leaderID == PlayerDatas.Instance.baseData.PlayerID)
                            {
                                RealmBossShow.Instance.Open(realmModel.cacheRealmLv);
                                ModelCenter.Instance.GetModel<ChatCenter>().CheckSendRealmThanks();
                            }
                            else
                            {
                                WindowCenter.Instance.Open<DungeonRealmVictoryWin>();
                            }
                            break;
                        case RuneTowerModel.RUNETOWER_MAPID:
                            WindowCenter.Instance.Open<DungeonRuneTowerVictoryWin>();
                            break;
                        case 41110:
                            WindowCenter.Instance.Open<DungeonGetTreasureVictoryWin>();
                            WindowCenter.Instance.Open<TreasureDungeonVictoryWin>();
                            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;
                        default:
                            WindowCenter.Instance.Open<DungeonDefeatedWin>();
                            break;
                    }
                }
            }
        }

        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.DEMONJAR_SINGLEMAPID)
            {
                return DemonJarModel.DEMONJAR_MAPID;
            }
            else
            {
                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 = Config.Instance.Get<DungeonHintConfig>(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)
        {
            if (!AssetSource.sceneFromEditor && !AssetVersionUtility.IsUnpriorAssetDownLoadOk())
            {
                var mapResConfig = DTCA127_tagMCStartChangeMap.GetMapResourcesConfig(_dataMapId, _lineId);
                var assetVersion = AssetVersionUtility.GetAssetVersion(StringUtility.Contact("maps/", mapResConfig.MapResources.ToLower()));

                if (!assetVersion.IsPriorAsset())
                {
                    InGameDownLoad.Instance.TryDownLoad(InGameDownLoad.Dominant.Whole);
                    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 = Config.Instance.Get<DailyQuestConfig>(_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 = Config.Instance.Get<DungeonConfig>(_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 GetInspireMaxCount(int _dataMapId)
        {
            List<DungeonInspireConfig> _list = GetDungeonInspire(_dataMapId);
            int _maxCnt = 0;
            if (_list != null)
            {
                for (int i = 0; i < _list.Count; i++)
                {
                    if (_list[i].InspireType == 2)
                    {
                        _maxCnt = _list[i].InspireCount;
                        break;
                    }
                }
            }
            return _maxCnt;
        }

        public Item GetLackItem(DungeonSuppliesLackWin.LackType lackType)
        {
            switch (lackType)
            {
                case DungeonSuppliesLackWin.LackType.PersonalBoss:
                    return GetTicketCost(PersonalBossModel.PERSONALBOSS_MAPID);
                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;
            }
            var mapId = PlayerDatas.Instance.baseData.MapID;
            var mapConfig = Config.Instance.Get<MapConfig>(mapId);
            if (mapConfig == null || mapConfig.MapFBType == 0)
            {
                UpdateInspireLevel(0, 0);
            }
        }

        private void ParseConfig()
        {
            ruinsTranscriptMapId = int.Parse(Config.Instance.Get<FuncConfigConfig>("SpRewardMapID").Numerical1);
            var allDungeonHint = Config.Instance.GetAllValues<DungeonHintConfig>();
            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 = Config.Instance.GetAllValues<DungeonConfig>();
            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.ParseDungeonSpecificOpenTimes(DungeonSpecialStateTimeConfig.GetDungeonTimes(config.DataMapID));
                }
            }

            var allDungeonOpenTime = Config.Instance.GetAllValues<DungeonOpenTimeConfig>();
            foreach (var config in allDungeonOpenTime)
            {
                int dungeonId = config.DataMapID;
                if (!dungeonGradeRewardRate.ContainsKey(dungeonId))
                {
                    dungeonGradeRewardRate.Add(dungeonId, config.RewardRate);
                }
            }

            FuncConfigConfig funcCfg = Config.Instance.Get<FuncConfigConfig>("FBEnterCD");
            if (funcCfg != null)
            {
                Dictionary<int, uint> dic = ConfigParse.GetDic<int, uint>(funcCfg.Numerical1);
                foreach (var key in dic.Keys)
                {
                    DungeonEnterCD data = new DungeonEnterCD();
                    data.mapId = key;
                    data.enterCd = dic[key];
                    dungeonEnterDic.Add(key, data);
                }
                dic = ConfigParse.GetDic<int, uint>(funcCfg.Numerical2);
                foreach (var key in dic.Keys)
                {
                    dungeonEnterDic[key].SetCost(dic[key]);
                }
            }

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

            funcCfg = Config.Instance.Get<FuncConfigConfig>("InspireNum");
            if (funcCfg != null)
            {
                dungeonInspireUper = int.Parse(funcCfg.Numerical1);
            }

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

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

    }
}