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

using UnityEngine;
namespace vnxbqy.UI
{
    public class RealmModel : Model, IPlayerLoginOk, IBeforePlayerDataInitialize
    {
        Dictionary<int, Dictionary<int, int>> m_RealmProperties = new Dictionary<int, Dictionary<int, int>>();
        Dictionary<int, Dictionary<int, int[]>> m_RealmPreviewEquips = new Dictionary<int, Dictionary<int, int[]>>();
        Dictionary<int, RealmLevelUpEquipCondition> m_RealmEquipConditions = new Dictionary<int, RealmLevelUpEquipCondition>();
        Dictionary<int, Dictionary<int, int[]>> m_RecommandEquips = new Dictionary<int, Dictionary<int, int[]>>();
        List<List<int>> m_RealmStages = new List<List<int>>();
        public int realmMaxLevel { get; private set; }
        public int realmPoolOpenLevel { get; private set; }
        public int realmEquipDisplayLevel { get; private set; }
        public int realmLevelUpReikiPoint { get; private set; }
        public bool isBossPass { get; private set; }
        public int xxzlAwardState { get; private set; }
        public int m_RealmLVUpAwardState;
        public int m_RealmLVUpCutTreeCnt;
        public int realmExpTime { get; private set; }
        public long startExp { get; private set; }

        public uint buffAddRate { get; private set; }
        public uint buffSeconds { get; private set; }

        public int realmUpgrateNoEnoughReason = 0;  //境界提升不足提示 1。换装备，2 升星

        public long totalExp
        {
            get
            {
                if (PlayerDatas.Instance.baseData.realmLevel < realmPoolOpenLevel)
                {
                    return startExp;
                }

                float exp = startExp;

                var config = RealmConfig.Get(PlayerDatas.Instance.baseData.realmLevel);
                if (exp >= config.expLimit)
                {
                    return config.expLimit;
                }

                var tick = (TimeUtility.ServerNow - expStartTime).Ticks;
                var singleTick = realmExpTime * TimeSpan.TicksPerSecond;
                var times = tick / singleTick;

                float expRate = config.expRate;

                long buffTimes = 0;
                if (buffSeconds > 0)
                {
                    var buffTick = buffSeconds * TimeSpan.TicksPerSecond;
                    var buffTicks = tick > buffTick ? buffTick : tick;
                    buffTimes = buffTicks / singleTick;
                }

                if (buffTimes > 0)
                {
                    var rate = expRate + expRate * (buffAddRate / 10000f);
                    exp += rate * buffTimes;
                }

                var normalTimes = times - buffTimes;
                if (normalTimes > 0)
                {
                    exp += expRate * normalTimes;
                }

                exp = exp > config.expLimit ? config.expLimit : exp;
                return (long)exp;
            }
        }

        public DateTime expStartTime { get; private set; }

        int realmPoolRedpointPercent = 100;

        UIEffect realmEffect;
        int realmEffectCount = 0;

        public event Action OnTowerPassEvent;
        public int passedFloor;
        //可挑战层
        public int currentFloor {
            get { 
                return passedFloor + 1; 
            } 
        }

        public int selectFloorID;    //新的大境界未解锁，或者最后一层时，显示可选的最高层

        public const int REALM_DUNGEON_ID = 31110;
        public const int Tower_MapId = 31310;

        public readonly Redpoint levelUpRedpoint = new Redpoint(114, 11401);
        public readonly Redpoint challengeRedpoint = new Redpoint(114, 11402);
        //public readonly Redpoint realmPoolRedpoint = new Redpoint(114, 11403);
        public readonly Redpoint realmDailyRedpoint = new Redpoint(114, 11404);
        public readonly Redpoint xxzlRedpoint = new Redpoint(114, 11405);
        public readonly Redpoint towerRedpoint = new Redpoint(114, 11406);

        int m_SelectRealm = 0;
        public int selectRealm
        {
            get { return m_SelectRealm; }
            set
            {
                if (m_SelectRealm != value)
                {
                    m_SelectRealm = value;
                    if (selectRealmRefresh != null)
                    {
                        selectRealmRefresh();
                    }
                }
            }
        }

        int cacheMapId = 0;

        bool redpointDirty = false;

        bool serverInited = false;

        public List<int> displayRealms = new List<int>();

        public int displayRealmLevel
        {
            get
            {
                if (displayRealms.Count > 0)
                {
                    return displayRealms[0];
                }
                return PlayerDatas.Instance.baseData.realmLevel;
            }
        }

        public event Action selectRealmRefresh;
        public event Action realmExpRefresh;
        public event Action OnRealmInfo;

        EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
        EquipStarModel equipStarModel { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        ActivitiesPushModel pushModel { get { return ModelCenter.Instance.GetModel<ActivitiesPushModel>(); } }
        TreasureModel treasureModel { get { return ModelCenter.Instance.GetModel<TreasureModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }

        CutTreeModel cutTreeModel { get { return ModelCenter.Instance.GetModel<CutTreeModel>(); } }
        public override void Init()
        {
            //StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;
            //GlobalTimeEvent.Instance.secondEvent += PerSecond;
            //packModel.refreshItemCountEvent += RefreshItemCountEvent;
            //FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            //WindowCenter.Instance.windowBeforeOpenEvent += OnBeforeWindowOpen;
            dungeonModel.dungeonRecordChangeEvent += OnDungeonRecordUpdate;
            cutTreeModel.UpdateTreeLVEvent += RefreshRedpoint;
            ParseConfig();
        }

        public void OnBeforePlayerDataInitialize()
        {
            isBossPass = false;
            expStartTime = DateTime.Now;
            startExp = 0;
            serverInited = false;
            buffSeconds = 0;
            buffAddRate = 0;
            realmEffectCount = 0;
            xxzlAwardState = 0;
            //SysNotifyMgr.Instance.OnSystemNotifyEvent -= OnSystemNotifyEvent;
        }

        public void OnPlayerLoginOk()
        {
            redpointDirty = true;
            serverInited = true;

            //SysNotifyMgr.Instance.OnSystemNotifyEvent -= OnSystemNotifyEvent;
            //SysNotifyMgr.Instance.OnSystemNotifyEvent += OnSystemNotifyEvent;

            RefreshRedpoint();
            TryPushRealmPoolMessage();
        }

        public override void UnInit()
        {
            //StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;
            //packModel.refreshItemCountEvent -= RefreshItemCountEvent;
            //GlobalTimeEvent.Instance.secondEvent -= PerSecond;
            //FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;
            dungeonModel.dungeonRecordChangeEvent -= OnDungeonRecordUpdate;
            cutTreeModel.UpdateTreeLVEvent -= RefreshRedpoint;
        }

        private void OnFuncStateChangeEvent(int id)
        {
            if (id == (int)FuncOpenEnum.Realm)
            {
                RefreshRedpoint();
            }
        }

        private void OnDungeonRecordUpdate(int _dataMapId)
        {
            if (_dataMapId == 5000)
                RefreshRedpoint();
        }

        private void PerSecond()
        {
            if (redpointDirty)
            {
                RefreshRedpoint();
                redpointDirty = false;
            }
            //if (serverInited)
            //{
            //    RefreshRealmPoolRedpoint();
            //}

            TryPlayRealmEffect();
        }

        void ParseConfig()
        {
            realmMaxLevel = 0;
            List<int> stages = new List<int>();
            m_RealmStages.Add(stages);
            var configs = RealmConfig.GetValues();
            foreach (var config in configs)
            {
                if (config.Lv > realmMaxLevel)
                {
                    realmMaxLevel = config.Lv;
                }

                if (config.AddAttrType != null && config.AddAttrType.Length > 0)
                {
                    Dictionary<int, int> dict = new Dictionary<int, int>();
                    for (int i = 0; i < config.AddAttrType.Length; i++)
                    {
                        dict.Add(config.AddAttrType[i], config.AddAttrNum[i]);
                    }
                    m_RealmProperties.Add(config.Lv, dict);
                }

                if (config.Lv != 0)
                {
                    stages.Add(config.Lv);

                    if (config.BossID != 0)
                    {
                        stages = new List<int>();
                        m_RealmStages.Add(stages);
                    }
                }

                //if (!string.IsNullOrEmpty(config.equips))
                //{
                //    var json = LitJson.JsonMapper.ToObject(config.equips);
                //    Dictionary<int, int[]> dict = new Dictionary<int, int[]>();
                //    foreach (var jobKey in json.Keys)
                //    {
                //        var job = int.Parse(jobKey);
                //        var equipArray = LitJson.JsonMapper.ToObject<int[]>(json[jobKey].ToJson());
                //        dict.Add(job, equipArray);
                //    }
                //    m_RealmPreviewEquips.Add(config.Lv, dict);
                //}

                //if (!string.IsNullOrEmpty(config.recommandEquips))
                //{
                //    var json = LitJson.JsonMapper.ToObject(config.recommandEquips);
                //    Dictionary<int, int[]> dict = new Dictionary<int, int[]>();
                //    foreach (var jobKey in json.Keys)
                //    {
                //        var job = int.Parse(jobKey);
                //        var equipArray = LitJson.JsonMapper.ToObject<int[]>(json[jobKey].ToJson());
                //        dict.Add(job, equipArray);
                //    }
                //    m_RecommandEquips.Add(config.Lv, dict);
                //}

                //if (realmPoolOpenLevel == 0 && config.expRate != 0)
                //{
                //    realmPoolOpenLevel = config.Lv;
                //}

                //if (config.NeedEquip != null && config.NeedEquip.Length > 1)
                //{
                //    m_RealmEquipConditions.Add(config.Lv, new RealmLevelUpEquipCondition()
                //    {
                //        level = config.NeedEquip[0],
                //        starLevel = config.NeedEquip[1],
                //        isSuit = config.NeedEquip[2] == 1,
                //        itemColor = config.NeedEquip.Length > 3 ? config.NeedEquip[3] : 0,
                //    });
                //}
            }

            var funcConfig = FuncConfigConfig.Get("RealmExpTime");
            realmExpTime = int.Parse(funcConfig.Numerical1);

            funcConfig = FuncConfigConfig.Get("RealmEqiupDisplayLevel");
            realmEquipDisplayLevel = int.Parse(funcConfig.Numerical1);
            realmPoolRedpointPercent = int.Parse(funcConfig.Numerical2);

        }

        public bool TryGetRealmProperty(int level, out Dictionary<int, int> propertyDict)
        {
            return m_RealmProperties.TryGetValue(level, out propertyDict);
        }

        public bool TryGetRealmStages(int index, out List<int> stages)
        {
            stages = null;
            if (index < m_RealmStages.Count)
            {
                stages = m_RealmStages[index];
                return true;
            }
            return false;
        }

        public bool TryGetRealmPreviewEquips(int level, int job, out int[] equips)
        {
            equips = null;
            if (m_RealmPreviewEquips.ContainsKey(level))
            {
                return m_RealmPreviewEquips[level].TryGetValue(job, out equips);
            }
            return false;
        }

        public bool TryGetRecommandEquips(int level, int job, out int[] equips)
        {
            equips = null;
            if (m_RecommandEquips.ContainsKey(level))
            {
                return m_RecommandEquips[level].TryGetValue(job, out equips);
            }
            return false;
        }

        public bool TryGetRealmEquipCondition(int level, out RealmLevelUpEquipCondition equipCondition)
        {
            return m_RealmEquipConditions.TryGetValue(level, out equipCondition);
        }
        public bool TryLevelUp(out int error)
        {
            error = 0;
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            if (realmLevel >= realmMaxLevel)
            {
                error = 100;
                return false;
            }
            var config = RealmConfig.Get(realmLevel);
            
            if (PlayerDatas.Instance.baseData.LV < config.NeedLV)
            {
                error = 1;
                return false;
            }
            if (config.BossID != 0 && !isBossPass)
            {
                error = 2;
                return false;
            }
            int equipError = 0;
            if (!SatisfyEquipCondition(realmLevel, out equipError))
            {
                error = equipError;
                return false;
            }
            //if (config.NeedGood != 0)
            //{
            //    var count = packModel.GetItemCountByID(PackType.Item, config.NeedGood);
            //    if (count < config.NeedNum)
            //    {
            //        error = 3;
            //        return false;
            //    }
            //}
            return true;
        }

        private void TryPlayRealmEffect()
        {
            if (realmEffect != null)
            {
                if (realmEffect.IsPlaying)
                {
                    return;
                }
                else
                {
                    realmEffectCount--;
                    realmEffect = null;
                }
            }
            if (realmEffectCount > 0)
            {
                if (WindowCenter.Instance.IsOpen<MainInterfaceWin>()
                  && !WindowCenter.Instance.ExistAnyFullScreenOrMaskWin())
                {
                    realmEffect = EffectMgr.Instance.PlayUIEffect(7047, 1800, WindowCenter.Instance.uiRoot.baseCanvas, false);
                }
            }
        }

        public bool IsUnlockEquipRealm(int realmLevel, out int level)
        {
            level = 0;
            var equipSets = equipModel.GetAllEquipSets();
            var index = equipSets.FindIndex((x) =>
            {
                var equipSet = equipModel.GetEquipSet(x);
                if (equipSet != null)
                {
                    return equipSet.realm == realmLevel;
                }
                return false;
            });
            if (index != -1)
            {
                level = equipSets[index];
                return true;
            }
            return false;
        }

        public bool IsBuffActive(DateTime time)
        {
            return buffSeconds > 0
                    && expStartTime.AddTicks(TimeSpan.TicksPerSecond * buffSeconds) > time;
        }

        public bool SatisfyEquipCondition(int realmLevel, out List<int> notSatisfyPlaces)
        {
            notSatisfyPlaces = null;
            RealmLevelUpEquipCondition equipCondition;
            if (!TryGetRealmEquipCondition(realmLevel, out equipCondition))
            {
                return true;
            }
            notSatisfyPlaces = new List<int>();
            for (int i = 1; i <= 8; i++)
            {
                var equipGuid = equipModel.GetEquip(new Int2(equipCondition.level, i));
                var itemModel = packModel.GetItemByGuid(equipGuid);
                if (itemModel != null)
                {
                    if (equipCondition.isSuit)
                    {
                        if (itemModel.config.SuiteiD == 0)
                        {
                            notSatisfyPlaces.Add(i);
                            continue;
                        }
                    }
                    else
                    {
                        if (itemModel.config.ItemColor < equipCondition.itemColor)
                        {
                            notSatisfyPlaces.Add(i);
                            continue;
                        }
                    }

                    var starLevel = equipStarModel.GetEquipStarLevel(new Int2(equipCondition.level, i));

                    if (starLevel < equipCondition.starLevel)
                    {
                        notSatisfyPlaces.Add(i);
                    }
                }
                else
                {
                    notSatisfyPlaces.Add(i);
                }
            }
            return notSatisfyPlaces.Count == 0;
        }

        public bool SatisfyEquipCondition(int realmLevel, out int error)
        {
            error = 0;
            RealmLevelUpEquipCondition equipCondition;
            if (!TryGetRealmEquipCondition(realmLevel, out equipCondition))
            {
                return true;
            }
            for (int i = 1; i <= 8; i++)
            {
                var equipGuid = equipModel.GetEquip(new Int2(equipCondition.level, i));
                var itemModel = packModel.GetItemByGuid(equipGuid);
                if (itemModel != null)
                {
                    if (equipCondition.isSuit)
                    {
                        if (itemModel.config.SuiteiD == 0)
                        {
                            error = 4;
                            return false;
                        }
                    }
                    else
                    {
                        if (itemModel.config.ItemColor < equipCondition.itemColor)
                        {
                            error = 4;
                            return false;
                        }
                    }

                    var starLevel = equipStarModel.GetEquipStarLevel(new Int2(equipCondition.level, i));

                    if (starLevel < equipCondition.starLevel)
                    {
                        error = 5;
                        return false;
                    }
                }
                else
                {
                    error = 4;
                    return false;
                }
            }
            return true;
        }

        public bool HasEquipCondition(int realmLevel)
        {
            return m_RealmEquipConditions.ContainsKey(realmLevel);
        }

        public int GetRealmStage(int realmLevel)
        {
            if (realmLevel == 0)
            {
                return 0;
            }
            for (int i = 0; i < m_RealmStages.Count; i++)
            {
                var stages = m_RealmStages[i];
                var index = stages.IndexOf(realmLevel);
                if (index != -1)
                {
                    if (stages.Count == 1)
                    {
                        return i - 1;
                    }
                    return i;
                }
            }
            return m_RealmStages.Count - 1;
        }

        public int GetRealmStageEffect(int realmLevel)
        {
            var config = RealmConfig.Get(realmLevel);
            if (config != null)
            {
                switch (config.Quality)
                {
                    case 1: return 7028;
                    case 2: return 7029;
                    case 3: return 7030;
                    case 4: return 7031;
                    case 5: return 7032;
                    case 6: return 7033;
                }
            }
            return 7028;
        }

        public int GetRealmCoverEffect(int realmLevel)
        {
            var config = RealmConfig.Get(realmLevel);
            if (config != null)
            {
                switch (config.Quality)
                {
                    case 1: return 7039;
                    case 2: return 7040;
                    case 3: return 7041;
                    case 4: return 7042;
                    case 5: return 7043;
                    case 6: return 7044;
                }
            }
            return 7039;
        }

        public int GetRealmLineEffect(int realmLevel)
        {
            var config = RealmConfig.Get(realmLevel);
            if (config != null)
            {
                switch (config.Quality)
                {
                    case 1: return 7034;
                    case 2: return 7059;
                    case 3: return 7060;
                    case 4: return 7061;
                    case 5: return 7062;
                    case 6: return 7063;
                }
            }
            return 7034;
        }

        public bool GetBossEffectShow(int realmLevel)
        {
            var playerId = PlayerDatas.Instance.baseData.PlayerID;
            return LocalSave.GetBool(StringUtility.Contact("RealmBossEffect_", realmLevel, "_", playerId));
        }

        public void SetBossEffectShow(int realmLevel)
        {
            var playerId = PlayerDatas.Instance.baseData.PlayerID;
            LocalSave.SetBool(StringUtility.Contact("RealmBossEffect_", realmLevel, "_", playerId), true);
        }

        public bool SatisfyChallengeBoss(int reamLevel)
        {
            var config = RealmConfig.Get(reamLevel);
            if (config != null)
            {
                return config.BossID != 0 && !isBossPass && PlayerDatas.Instance.baseData.LV >= config.NeedLV;
            }
            return false;
        }

        public void SendLevelUpRealm()
        {
            CA523_tagCMRealmLVUp pak = new CA523_tagCMRealmLVUp();
            GameNetSystem.Instance.SendInfo(pak);
        }

        public void TryPushRealmPoolMessage()
        {
            return;
            var remainTime = 0f;
            var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            var config = RealmConfig.Get(realmLevel);
            if (realmLevel >= realmPoolOpenLevel && config.expRate != 0)
            {
                if (totalExp < config.expLimit)
                {
                    float surplusExp = config.expLimit - totalExp;
                    if (buffSeconds > 0)
                    {
                        var expRate = config.expRate + config.expRate * (buffAddRate / 10000f);
                        var times = buffSeconds / realmExpTime;
                        if (times * expRate >= surplusExp)
                        {
                            remainTime = Mathf.CeilToInt(surplusExp / expRate) * realmExpTime;
                            surplusExp = 0;
                        }
                        else
                        {
                            remainTime = times * realmExpTime;
                            surplusExp = surplusExp - times * expRate;
                        }
                    }
                    if (surplusExp > 0)
                    {
                        remainTime += Mathf.CeilToInt(surplusExp / config.expRate) * realmExpTime;
                    }
                }
            }
            if (remainTime > 0f)
            {
                var json = pushModel.GetPushJsonData(11403, (int)remainTime,
                    Language.Get("RealmPoolGeTui_Title"), Language.Get("RealmPoolGeTui_Content"));
                pushModel.SendPushInfo(json);
            }
            else
            {
                pushModel.RemovePushInfo(11403);
            }
        }

        public void ReceivePackage(HA311_tagMCSyncRealmInfo package)
        {
            int beforeAwardState = xxzlAwardState;
            isBossPass = package.IsPass == 1;
            xxzlAwardState = (int)package.XXZLAwardState;
            m_RealmLVUpAwardState = (int)package.RealmLVUpAwardState;
            m_RealmLVUpCutTreeCnt = (int)package.RealmLVUpCutTreeCnt;
            //bool isOver = false;
            //if (beforeAwardState != 0 && beforeAwardState != xxzlAwardState && IsRealmXXZLOver())
            //{
            //    isOver = true;
            //}
            OnRealmInfo?.Invoke();
            RefreshRedpoint();
        }

        //是否已领取 0-等级；1-副本关卡；2-仙树等级；3-砍树次数
        public bool GetAwardState(int type)
        {
            return (m_RealmLVUpAwardState & (1 << type)) != 0;
        }

        public void ReceivePackage(HA327_tagMCRealmExpInfo package)
        {
            expStartTime = TimeUtility.GetTime(package.BeginTime);
            startExp = package.CurExpPoint * (long)Constants.ExpPointValue + package.CurExp;
            buffAddRate = package.BuffAddRate;
            buffSeconds = package.BuffTime;
            if (realmExpRefresh != null)
            {
                realmExpRefresh();
            }
            //RefreshRealmPoolRedpoint();

            TryPushRealmPoolMessage();
        }

        private void OnStageLoadFinish()
        {
            if (!(StageLoad.Instance.currentStage is DungeonStage))
            {
                cacheMapId = 0;
            }
            else
            {
                var mapId = PlayerDatas.Instance.baseData.MapID;
                if (cacheMapId == REALM_DUNGEON_ID
                    && mapId != REALM_DUNGEON_ID)
                {
                    SnxxzGame.Instance.StartCoroutine(Co_TryOpenRealmWin());
                }
                cacheMapId = mapId;
            }
        }

        private void OnSystemNotifyEvent(string key)
        {
            if (key == "BigRealmUpSuccess")
            {
                if (WindowCenter.Instance.IsOpen<MainInterfaceWin>()
                  && !WindowCenter.Instance.ExistAnyFullScreenOrMaskWin())
                {
                    if (realmEffectCount < 2)
                    {
                        realmEffectCount++;
                        TryPlayRealmEffect();
                    }
                }
            }
        }

        private void PlayerDataRefreshEvent(PlayerDataType dataType)
        {
            if (dataType == PlayerDataType.RealmLevel
                || dataType == PlayerDataType.LV
                || dataType == PlayerDataType.ExpPoint
                || dataType == PlayerDataType.TotalExp)
            {
                RefreshRedpoint();
            }

            //if (dataType == PlayerDataType.RealmLevel)
            //{
            //    //显示不超过当前的大境界塔层
            //    var config = RealmTowerConfig.Get(currentFloor);
            //    if (config != null)
            //    {
            //        int largeRealm = Math.Max(1, RealmConfig.Get(RealmTowerConfig.Get(currentFloor).NeedRealmLV).LvLarge);
            //        int largeRealmNow = Math.Max(1, RealmConfig.Get(PlayerDatas.Instance.baseData.realmLevel).LvLarge);
            //        if (largeRealm > largeRealmNow)
            //        {
            //            selectFloorID = passedFloor;
            //        }
            //        else
            //        {
            //            selectFloorID = currentFloor;
            //        }
            //    }
            //    else
            //    {
            //        selectFloorID = passedFloor;
            //    }
            //}
        }

        //private void RefreshItemCountEvent(PackType packType, int arg2, int itemId)
        //{
        //    if (packType == PackType.Item)
        //    {
        //        var config = RealmConfig.Get(PlayerDatas.Instance.baseData.realmLevel);
        //        if (config != null && config.NeedGood == itemId)
        //        {
        //            redpointDirty = true;
        //        }
        //    }
        //    if (packType == PackType.Equip)
        //    {
        //        redpointDirty = true;
        //    }
        //}

        IEnumerator Co_TryOpenRealmWin()
        {
            yield return WaitingForSecondConst.WaitMS1000;
            TryOpenRealmWin();
        }

        private void TryOpenRealmWin()
        {
            if (NewBieCenter.Instance.inGuiding)
            {
                return;
            }
            var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
            if (treasureModel.newGotShowing)
            {
                return;
            }
            if (WindowCenter.Instance.ExistAnyFullScreenOrMaskWin())
            {
                return;
            }
            WindowCenter.Instance.Open<RealmTransitionWin>();
        }

        public void SetDayRemind()
        {
            if (realmDailyRedpoint.state == RedPointState.Simple)
            {
                DayRemind.Instance.SetDayRemind(DayRemind.DAILYREALMREDPOINT, true);
                RefreshRedpoint();
            }
        }



        void RefreshRedpoint()
        {
            levelUpRedpoint.state = RedPointState.None;
            var config = RealmConfig.Get(PlayerDatas.Instance.baseData.realmLevel);
            

            int finishCnt = 0;
            //下一个境界需要的条件，同时只需要3个不同的条件
            if (config.NeedLV != 0)
            {
                if (GetAwardState(0))
                {
                    finishCnt++;
                }
                else if (PlayerDatas.Instance.baseData.LV >= config.NeedLV)
                { 
                    levelUpRedpoint.state = RedPointState.Simple;
                    return;
                }

            }

            if (config.NeedPassMap.Length != 0)
            {

                int passLine = 0;
                DungeonRecord dungeonRecord;
                if (dungeonModel.TryGetRecord(config.NeedPassMap[0], out dungeonRecord))
                {
                    passLine = dungeonRecord.passLineID;
                }

                if (GetAwardState(1))
                {
                    finishCnt++;
                }
                else if (passLine >= config.NeedPassMap[1])
                {
                    levelUpRedpoint.state = RedPointState.Simple;
                    return;
                }
            }


            if (config.NeedTreeLV != 0)
            {
                if (GetAwardState(2))
                {
                    finishCnt++;
                }
                else if (cutTreeModel.GetTreeLV() >= config.NeedTreeLV)
                {
                    levelUpRedpoint.state = RedPointState.Simple;
                    return;
                }
                
            }

            if (config.NeedCutTreeCnt != 0)
            {

                if (GetAwardState(3))
                {
                    finishCnt++;
                }
                else if (m_RealmLVUpCutTreeCnt >= config.NeedCutTreeCnt)
                {
                    levelUpRedpoint.state = RedPointState.Simple;
                    return;
                }

            }

            if (finishCnt >= 3)
            {
                ulong maxValue = (ulong)PlayerLVConfig.GetExpByPlayerLv(PlayerDatas.Instance.baseData.LV);
                ulong nowVlaue = (ulong)PlayerDatas.Instance.baseData.TotalExp + (ulong)PlayerDatas.Instance.baseData.ExpPoint * 100000000;
                if (nowVlaue >= maxValue)
                {
                    levelUpRedpoint.state = RedPointState.Simple;
                    return;
                }
            }
            //var levelUpable = false;
            //var challengeable = false;
            //var dailyRedpointable = false;
            //levelUpRedpoint.state = RedPointState.None;
            //challengeRedpoint.state = RedPointState.None;
            //realmDailyRedpoint.state = RedPointState.None;
            //towerRedpoint.state = RedPointState.None;

            //if (!IsRealmXXZLOver())
            //    return;

            //if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Realm))
            //{
            //    var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
            //    if (realmLevel < realmMaxLevel)
            //    {
            //        var config = RealmConfig.Get(realmLevel);
            //        if (SatisfyChallengeBoss(realmLevel))
            //        {
            //            challengeable = PlayerDatas.Instance.baseData.FightPoint >= (ulong)config.FightPower;
            //        }

            //        var error = 0;
            //        if (TryLevelUp(out error))
            //        {
            //            levelUpable = true;
            //        }
            //    }

            //    if (realmLevel >= realmPoolOpenLevel)
            //    {
            //        if (!DayRemind.Instance.GetDayRemind(DayRemind.DAILYREALMREDPOINT))
            //        {
            //            dailyRedpointable = true;
            //        }
            //    }

            //    if (GetErrorOfChallenge() == 0)
            //    {
            //        towerRedpoint.state = RedPointState.Simple;
            //    }
            //}

            //levelUpRedpoint.state = levelUpable ? RedPointState.Simple : RedPointState.None;
            //challengeRedpoint.state = challengeable ? RedPointState.Simple : RedPointState.None;
            //realmDailyRedpoint.state = dailyRedpointable ? RedPointState.Simple : RedPointState.None;

            //RefreshRealmPoolRedpoint();
        }

        //void RefreshRealmPoolRedpoint()
        //{
        //    var isPoolFull = false;
        //    if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Realm))
        //    {
        //        var realmLevel = PlayerDatas.Instance.baseData.realmLevel;
        //        if (realmLevel >= realmPoolOpenLevel)
        //        {
        //            var config = RealmConfig.Get(PlayerDatas.Instance.baseData.realmLevel);
        //            if (totalExp >= config.expLimit * (realmPoolRedpointPercent / 100f))
        //            {
        //                isPoolFull = true;
        //            }
        //        }
        //    }

        //    realmPoolRedpoint.state = isPoolFull ? RedPointState.Simple : RedPointState.None;
        //}

        #region 修仙之路


        public int selectXXZL;

        //任务完成进度
        public bool IsRealmXXZLMissionFinish(int missionID, out int process)
        {
            var config = RealmXXZLConfig.Get(missionID);
            bool isFinish = false;
            process = 0;
            switch (config.TaskType)
            {
                case 1:
                    isFinish = treasureModel.IsTreasureCollected(config.NeedValue);
                    process = isFinish ? 1 : 0;
                    break;
                case 2:
                    process = ModelCenter.Instance.GetModel<SkyTowerModel>().highestPassFloor;
                    isFinish = process >= config.NeedValue;
                    break;
                case 3:
                    process = ModelCenter.Instance.GetModel<WorldBossModel>().killCntTotal;
                    isFinish = process >= config.NeedValue;
                    break;
                case 4:
                    process = (int)ModelCenter.Instance.GetModel<DailyQuestModel>().ActivityPlaceInfo.TotalCount;
                    isFinish = process >= config.NeedValue;
                    break;
                case 5:
                    isFinish = ModelCenter.Instance.GetModel<PersonalBossModel>().IsFBPass(config.NeedValue);
                    process = isFinish ? 1 : 0;
                    break;
                case 6:
                    process = ModelCenter.Instance.GetModel<DungeonModel>().GetAllEnterTimes(60010);
                    isFinish = process >= config.NeedValue;
                    break;
                case 7:
                    process = ModelCenter.Instance.GetModel<ReikiRootModel>().GetReikiRootTotalPointWithFree();
                    isFinish = process >= config.NeedValue;
                    break;
            }

            return isFinish;
        }

        public bool IsRealmXXZLOver()
        {
            var count = RealmXXZLConfig.GetKeys().Count;
            return xxzlAwardState == (Math.Pow(2, count + 1) - 2);
        }

        public int GetXXZLProcess()
        {
            var ids = RealmXXZLConfig.GetKeys();
            int process = 0;
            foreach (var id in ids)
            {
                if (IsGetAward(int.Parse(id)))
                {
                    process++;
                }
            }
            return process;
        }

        public bool IsGetAward(int missionID)
        {
            return (xxzlAwardState & (int)Math.Pow(2, missionID)) != 0;
        }

        //void RefreshXXZLRedpoint()
        //{
        //    xxzlRedpoint.state = RedPointState.None;
        //    if (IsRealmXXZLOver())
        //    {
        //        WindowCenter.Instance.windowBeforeOpenEvent -= OnBeforeWindowOpen;
        //        return;
        //    }
        //    var ids = RealmXXZLConfig.GetKeys();
        //    foreach (var id in ids)
        //    {
        //        int process;
        //        if (!IsGetAward(int.Parse(id)) && IsRealmXXZLMissionFinish(int.Parse(id), out process))
        //        {
        //            xxzlRedpoint.state = RedPointState.Simple;
        //            return;
        //        }
        //    }
        //}

        //void OnBeforeWindowOpen(Window window)
        //{
        //    if (window.name == "MainInterfaceWin")
        //    {
        //        RefreshXXZLRedpoint();
        //    }
        //}

        public void FocusSelectIndex()
        {
            var ids = RealmXXZLConfig.GetKeys();
            int index = -1;
            foreach (var id in ids)
            {
                int missionID = int.Parse(id);
                int process;
                var state = IsGetAward(missionID);
                bool isFinish = IsRealmXXZLMissionFinish(missionID, out process);
                if (!state && isFinish)
                {
                    selectXXZL = missionID - 1;
                    return;
                }
                else if (!state && !isFinish && index == -1)
                {
                    index = missionID - 1;
                }
            }

            selectXXZL = index;
        }
        #endregion

        #region 境界塔
        public void RequestChallenge()
        {
            var error = GetErrorOfChallenge();
            if (error == 0)
            {
                dungeonModel.RequestChallangeDungeon(Tower_MapId, 0);
            }
            else
            {
                switch (error)
                {
                    case 1:
                        SysNotifyMgr.Instance.ShowTip("BossRealmHint2", RealmTowerConfig.Get(selectFloorID).NeedRealmLV);
                        break;
                    default:
                        break;
                }
            }
        }

        //0 可挑战 1 境界不足 2 已通关
        private int GetErrorOfChallenge()
        {
            if (selectFloorID == 0)
                return 1;

            if (RealmTowerConfig.Get(selectFloorID).NeedRealmLV > PlayerDatas.Instance.baseData.realmLevel)
            {
                return 1;
            }
            if (selectFloorID <= passedFloor)
            {
                //已通关
                return 2;
            }
            return 0;
        }

        public void UpdateRealmTowerInfo(HB217_tagMCRealmTowerInfo netPack)
        {
            passedFloor = (int)netPack.Floor;

            //显示不超过当前的大境界塔层
            var config = RealmTowerConfig.Get(currentFloor);
            if (config != null)
            {
                int largeRealm = Math.Max(1, RealmConfig.Get(RealmTowerConfig.Get(currentFloor).NeedRealmLV).LvLarge);
                int largeRealmNow = Math.Max(1, RealmConfig.Get(PlayerDatas.Instance.baseData.realmLevel).LvLarge);
                if (largeRealm > largeRealmNow)
                {
                    selectFloorID = passedFloor;
                }
                else
                {
                    selectFloorID = currentFloor;
                }
            }
            else
            {
                selectFloorID = passedFloor;
            }
            RefreshRedpoint();
            OnTowerPassEvent?.Invoke();
        }

        public void RequestRefreshMonster()
        {
            var sendInfo = new CA508_tagCMDoFBAction();
            sendInfo.ActionType = 0;
            sendInfo.ActionInfo = (uint)currentFloor;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }
        #endregion
    }

    public struct RealmLevelUpEquipCondition
    {
        public int level;
        public int starLevel;
        public bool isSuit;
        public int itemColor;
    }
}