using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

using LitJson;
using UnityEngine;

namespace vnxbqy.UI
{
    
    
    public class CrossServerOneVsOneModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, ISwitchAccount, IPlayerLoginOk
    {
        public string PkResultLocalSaveKey { get; private set; }
        public List<CrossServerOneVsOnePkResult> localSaveResults { get; private set; }
        CrossServerOneVsOneRewardModel rewardModel { get { return ModelCenter.Instance.GetModel<CrossServerOneVsOneRewardModel>(); } }
        public event Action UpdateDayAwardsEvent;
        public const int CrossServerDataMapId = 32010;
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        public bool isClickCoolTime { get; set; }
        public event Action UpdateMatchStateEvent;
        private bool _isMatching;
        public bool IsMatching {
            get { return _isMatching; }
            set {
                _isMatching = value;
                if (UpdateMatchStateEvent != null)
                {
                    UpdateMatchStateEvent();
                }
            }
        }
        public DateTime matchStartTime { get; set; }
        public DateTime roundEndTime { get; private set; }
        StoreModel storeModel { get { return ModelCenter.Instance.GetModel<StoreModel>(); } }
        public string LocalSaveThirdTypeKey = string.Empty;
        private int recordDataMapId;
        private int loadSecond;

        public override void Init()
        {
            IsMatching = false;
            ParseFuncConfig();
            SetHonorRedpoint();
        }

        public void OnBeforePlayerDataInitialize()
        {
            loadSecond = 0;
            StageLoad.Instance.onStageLoadFinish -= OnLoadMapFinish;
            storeModel.RefreshBuyShopLimitEvent -= UpdateBuyShop;
            TimeUtility.OnServerOpenDayRefresh -= UpdateServerOpenDay;
            PlayerDatas.Instance.playerDataRefreshEvent -= UpdatePlayerData;
            CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent -= UpdatePlayerInfo;
            CrossServerOneVsOnePKSeason.Instance.updateSelfSeasonEvent -= UpdateSeason;
            TimeMgr.Instance.OnMinuteEvent -= UpdateMinute;
            GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
            dungeonModel.updateMissionEvent -= UpdateFBHelp;
            rewardModel.CrossRealmPKAwardStateUpdate -= UpdateDayAwardState;
            CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent -= UpdateDayAwardState;
            InitData();
        }

        public void OnAfterPlayerDataInitialize()
        {
            int playerId = (int)PlayerDatas.Instance.baseData.PlayerID;
            PkResultLocalSaveKey = StringUtility.Contact("PkResultLocalSaveKey", playerId);
            LocalSaveThirdTypeKey = StringUtility.Contact("HonorStoreThirdType", playerId);
            GetLocalSaveData();
        }

        public void OnSwitchAccount()
        {
            IsMatching = false;
        }

        public void OnPlayerLoginOk()
        {
            StageLoad.Instance.onStageLoadFinish += OnLoadMapFinish;
            storeModel.RefreshBuyShopLimitEvent += UpdateBuyShop;
            TimeUtility.OnServerOpenDayRefresh += UpdateServerOpenDay;
            PlayerDatas.Instance.playerDataRefreshEvent += UpdatePlayerData;
            CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent += UpdatePlayerInfo;
            CrossServerOneVsOnePKSeason.Instance.updateSelfSeasonEvent += UpdateSeason;
            TimeMgr.Instance.OnMinuteEvent += UpdateMinute;
            GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
            rewardModel.CrossRealmPKAwardStateUpdate += UpdateDayAwardState;
            CrossServerOneVsOnePlayerInfo.Instance.UpdatePlayerInfoEvent += UpdateDayAwardState;
            dungeonModel.updateMissionEvent += UpdateFBHelp;
            UpdateServerOpenDay();
            UpdateDayAwardState();
            if (IsMatching && CrossServerOneVsOnePKSeason.Instance.InOpenTime())
            {
                SendCrossMatch(1);
            }

            UpdateCrossDayAwardsRedpoint();
            UpdateCrossMatchRedpoint();
            UpdateCanBuyRedpoint();
        }

        public override void UnInit()
        {

        }

        private void InitData()
        {
            CrossServerOneVsOnePKSeason.Instance.InitData();
            CrossServerOneVsOnePlayerInfo.Instance.InitData();
            pkResultInfo = new CrossServerOneVsOnePkResult();
            oneVsOneHistoryDict.Clear();
        }

        private void UpdateSecond()
        {
            loadSecond += 1;
            if (loadSecond >= 5)
            {
                recordDataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
                GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
                loadSecond = 0;
                DebugEx.Log("UpdateSecond....." + recordDataMapId);
            }
        }

        private void OnLoadMapFinish()
        {
            var dataMapId = dungeonModel.GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);
            if ((recordDataMapId == CrossServerDataMapId || recordDataMapId == 1000)
                && dataMapId != CrossServerDataMapId)
            {
                var pkSeason = CrossServerOneVsOnePKSeason.Instance;
                if (pkSeason.IsEnterCrossServer())
                {
                    WindowCenter.Instance.Open<CrossServerWin>(false, 0);
                }
            }
            recordDataMapId = dataMapId;
        }

        private void UpdateMinute()
        {
            UpdateCrossMatchRedpoint();
            if (!IsMatching) return;

            if (!CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch)
            {
                IsMatching = false;
                SendCrossMatch(0);
            }
        }

        public void UpdateDayAwardState()
        {
            var playerInfo = CrossServerOneVsOnePlayerInfo.Instance;
            for (int i = 0; i < dayAwardTypelist.Count; i++)
            {
                var dayAward = dayAwardTypelist[i];
                int awardType = dayAward.type;
                switch (awardType)
                {
                    case 1:
                        dayAward.IsReceived = rewardModel.IsAwardState(CrossRealmPKAwardStateEnum.DayWinCountAwardState, dayAward.index);
                        dayAward.SetCompletedNum(playerInfo.DayWinCount);
                        break;
                    case 2:
                        dayAward.IsReceived = rewardModel.IsAwardState(CrossRealmPKAwardStateEnum.DayPKCountAwardState, dayAward.index);
                        dayAward.SetCompletedNum(playerInfo.DayPKCount);
                        break;
                }
            }

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

            UpdateCrossDayAwardsRedpoint();
        }

        private void UpdateSeason()
        {
            UpdateCrossMatchRedpoint();
            UpdateCanBuyRedpoint();
        }

        private void UpdateBuyShop()
        {
            var pkSeason = CrossServerOneVsOnePKSeason.Instance;
            if (!pkSeason.IsEnterCrossServer()) return;

            UpdateCanBuyRedpoint();
        }

        private void UpdatePlayerInfo()
        {
            UpdateCrossDayAwardsRedpoint();
            UpdateCrossMatchRedpoint();
        }

        private void UpdateFBHelp()
        {
            if (!CrossServerUtility.IsCrossServerOneVsOne())
            {
                return;
            }

            var hero = PlayerDatas.Instance.hero;
            var mission = dungeonModel.mission;
            if (mission.prepareTime > 0)
            {
                roundEndTime = DateTime.Now + new TimeSpan(mission.prepareTime * TimeSpan.TicksPerMillisecond);
                if (!WindowCenter.Instance.IsOpen<CrossServerOneVsOneRoundWin>())
                {
                    WindowCenter.Instance.Open<CrossServerOneVsOneRoundWin>();
                }
                if (hero != null)
                {
                    hero.Behaviour.StopHandupAI(true);
                    hero.StopPathFind();
                }

            }
            DebugEx.LogFormat("副本帮助信息回合是否开始：：{0}", mission.isStart);
            if (mission.isStart == 1)
            {
                if (WindowCenter.Instance.IsOpen<CrossServerOneVsOneRoundWin>())
                {
                    WindowCenter.Instance.Close<CrossServerOneVsOneRoundWin>();
                }

                if (!WindowCenter.Instance.IsOpen<CrossServerOneVsOneStartFightWin>())
                {
                    WindowCenter.Instance.Open<CrossServerOneVsOneStartFightWin>();
                }
                if (hero != null)
                {
                    hero.Behaviour.StartHandupAI();
                }
            }
        }

        public List<AwardType> GetDayAwardsList()
        {
            dayAwardTypelist.Sort(CompareByCompleteProgress);
            return dayAwardTypelist;
        }

        public int CompareByCompleteProgress(AwardType start, AwardType end)
        {
            int x = (int)start.progress;
            int y = (int)end.progress;
            if (x.CompareTo(y) != 0) return x.CompareTo(y);

            x = start.type;
            y = end.type;
            if (x.CompareTo(y) != 0) return x.CompareTo(y);

            x = start.num;
            y = end.num;
            if (x.CompareTo(y) != 0) return x.CompareTo(y);

            return 0;
        }

        public bool IsNewDay { get; private set; }
        private void UpdateServerOpenDay()
        {
            var pkSeason = CrossServerOneVsOnePKSeason.Instance;
            if (!pkSeason.IsEnterCrossServer()) return;

            IsNewDay = false;
            int openDay = TimeUtility.OpenDay;
            if (!PlayerPrefs.HasKey(LocalSaveThirdTypeKey))
            {
                IsNewDay = true;
                LocalSave.SetInt(LocalSaveThirdTypeKey, openDay);
            }
            else
            {
                int localOpenDay = LocalSave.GetInt(LocalSaveThirdTypeKey);
                if (openDay != localOpenDay)
                {
                    IsNewDay = true;
                    LocalSave.SetInt(LocalSaveThirdTypeKey, openDay);
                }
            }

            UpdateCanBuyRedpoint();
        }

        #region 表数据
        public int freeMaxMatchNum { get; private set; } //每日免费匹配次数
        public int buyMaxMatchNum { get; private set; } //每日可购买次数
        public string priceFormula { get; private set; } //购买匹配次数需要价格公式
        public string winStreakScoreFormula { get; private set; } //连胜积分公式
        public List<AwardType> dayAwardTypelist { get; private set; }
        public int afterOpenDayOpenCross { get; private set; }
        private void ParseFuncConfig()
        {
            var CrossRealmPKAward = FuncConfigConfig.Get("CrossRealmPKAward");
            var dayMatchAwardData = JsonMapper.ToObject(CrossRealmPKAward.Numerical1);
            var dayWinAwardData = JsonMapper.ToObject(CrossRealmPKAward.Numerical2);
            dayAwardTypelist = new List<AwardType>();
            int dayWinIndex = 0;
            foreach (var num in dayWinAwardData.Keys)
            {
                int times = int.Parse(num);
                var items = dayWinAwardData[num];
                var awardType = new AwardType(times, 1, dayWinIndex);
                dayAwardTypelist.Add(awardType);
                if (items.IsArray)
                {
                    for (int i = 0; i < items.Count; i++)
                    {
                        var itemInfo = items[i];
                        if (itemInfo.IsArray && itemInfo.Count >= 3)
                        {
                            int id = 0;
                            int.TryParse(itemInfo[0].ToString(), out id);
                            int count = 0;
                            int.TryParse(itemInfo[1].ToString(), out count);
                            int isBind = 0;
                            int.TryParse(itemInfo[2].ToString(), out isBind);
                            AwardItem awardItem = new AwardItem(id, count, isBind);
                            awardType.SetAwardItems(awardItem);
                        }
                    }
                }

                dayWinIndex += 1;
            }

            int dayPkIndex = 0;
            foreach (var num in dayMatchAwardData.Keys)
            {
                int times = int.Parse(num);
                var items = dayMatchAwardData[num];
                var awardType = new AwardType(times, 2, dayPkIndex);
                dayAwardTypelist.Add(awardType);
                if (items.IsArray)
                {
                    for (int i = 0; i < items.Count; i++)
                    {
                        var itemInfo = items[i];
                        if (itemInfo.IsArray && itemInfo.Count >= 3)
                        {
                            int id = 0;
                            int.TryParse(itemInfo[0].ToString(), out id);
                            int count = 0;
                            int.TryParse(itemInfo[1].ToString(), out count);
                            int isBind = 0;
                            int.TryParse(itemInfo[2].ToString(), out isBind);
                            AwardItem awardItem = new AwardItem(id, count, isBind);
                            awardType.SetAwardItems(awardItem);
                        }
                    }
                }

                dayPkIndex += 1;
            }

            var CrossRealmPKMatchCount = FuncConfigConfig.Get("CrossRealmPKMatchCount");
            freeMaxMatchNum = int.Parse(CrossRealmPKMatchCount.Numerical1);
            buyMaxMatchNum = int.Parse(CrossRealmPKMatchCount.Numerical2);
            priceFormula = CrossRealmPKMatchCount.Numerical3;

            var CrossRealmPKScore = FuncConfigConfig.Get("CrossRealmPKScore");
            winStreakScoreFormula = CrossRealmPKScore.Numerical3;

            var CrossRealmCfg = FuncConfigConfig.Get("CrossRealmCfg");
            afterOpenDayOpenCross = int.Parse(CrossRealmCfg.Numerical1);
        }

        public class AwardType
        {
            public int type { get; private set; } //1 胜利奖励 2 匹配奖励 
            public int index { get; private set; }
            public int num { get; private set; }
            public int curCompletedNum { get; private set; }
            public CompleteProgress progress { get; private set; }
            public bool IsReceived { get; set; }
            public List<AwardItem> awardItems = new List<AwardItem>();
            public AwardType(int _num, int _type, int _index)
            {
                type = _type;
                num = _num;
                index = _index;
                curCompletedNum = 0;
                IsReceived = false;
                progress = CompleteProgress.Completed;
                awardItems.Clear();
            }

            public void SetAwardItems(AwardItem awardItem)
            {
                awardItems.Add(awardItem);
            }

            public void SetCompletedNum(int completedNum)
            {
                curCompletedNum = completedNum;
                if (IsReceived)
                {
                    curCompletedNum = num;
                    progress = CompleteProgress.AlreadyReceived;
                }
                else
                {
                    progress = curCompletedNum < num ? CompleteProgress.UnCompleted : CompleteProgress.Completed;
                }
            }

            public enum CompleteProgress
            {
                Completed = 0, //已达成
                UnCompleted = 1, //未达成
                AlreadyReceived = 2, //已领取
            }
        }

        public struct AwardItem
        {
            public int itemId;
            public int itemCount;
            public int isBind;
            public AwardItem(int _id, int _count, int _isBind)
            {
                itemId = _id;
                itemCount = _count;
                isBind = _isBind;
            }
        }
        #endregion

        #region 协议
        public CrossServerOneVsOnePkResult pkResultInfo { get; private set; }
        public event Action UpdatePkResultEvent;
        public void UpdatePKResultInfo(HC003_tagGCCrossRealmPKOverInfo pKOverInfo)
        {
            pkResultInfo = new CrossServerOneVsOnePkResult();
            pkResultInfo.UpdatePkResult(pKOverInfo);
            SetPkInfoLocalSave(pkResultInfo);
            if (UpdatePkResultEvent != null)
            {
                UpdatePkResultEvent();
            }
        }

        BuffModel buffDatas { get { return ModelCenter.Instance.GetModel<BuffModel>(); } }
        /// <summary>
        ///0-取消匹配; 1-进行匹配
        /// </summary>
        /// <param name="type"></param>
        public void SendCrossMatch(int type)
        {
            if (type == 1 && TryGetMatchTip()) return;

            var match = new CC101_tagCMCrossRealmPKMatch();
            match.Type = (byte)type;
            GameNetSystem.Instance.SendInfo(match);
            CrossServerOneVsOneRewardModel.PkType = buffDatas.PkType;
        }

        public void SendBuyMatchCount()
        {
            var pKBuy = new CC102_tagCMCrossRealmPKBuy();
            GameNetSystem.Instance.SendInfo(pKBuy);
        }

        public bool TryGetMatchTip()
        {
            int mapId = PlayerDatas.Instance.baseData.MapID;
            bool isCrossDungeon = CrossServerUtility.IsCrossServer();
            if (isCrossDungeon)
            {
                SysNotifyMgr.Instance.ShowTip("CrossMatching3");
                return true;
            }

            var mapConfig = MapConfig.Get(mapId);
            bool isDungeon = mapConfig != null && mapConfig.MapFBType != 0 ? true : false;
            if (isDungeon)
            {
                SysNotifyMgr.Instance.ShowTip("CrossMatching4");
                return true;
            }

            var deadModel = ModelCenter.Instance.GetModel<PlayerDeadModel>();
            if (deadModel.playerIsDie)
            {
                SysNotifyMgr.Instance.ShowTip("CrossMatching5");
                return true;
            }

            var teamModel = ModelCenter.Instance.GetModel<TeamModel>();
            bool isTeamMatch = teamModel.isMatching;
            if (isTeamMatch)
            {
                SysNotifyMgr.Instance.ShowTip("CrossMatching6");
                return true;
            }

            bool isDungeonPrepare = teamModel.teamPrepare.isPreparing;
            if (isDungeonPrepare)
            {
                SysNotifyMgr.Instance.ShowTip("CrossMatching7");
                return true;
            }

            int remainMatchNum = CrossServerOneVsOnePlayerInfo.Instance.GetDayRemainNum();
            if (remainMatchNum <= 0)
            {
                SysNotifyMgr.Instance.ShowTip("CrossMatching16");
                return true;
            }

            return false;

        }

        public bool TryGetBuyMatchTimes(string key)
        {
            if (!CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch)
            {
                SysNotifyMgr.Instance.ShowTip(key);
                return false;
            }

            int remainNum = CrossServerOneVsOnePlayerInfo.Instance.GetDayRemainNum();
            if (remainNum >= freeMaxMatchNum)
            {
                SysNotifyMgr.Instance.ShowTip("CrossMatching13");
                return false;
            }
            return true;
        }

        #endregion

        #region 历史记录
        Dictionary<int, CrossServerOneVsOneHistory> oneVsOneHistoryDict = new Dictionary<int, CrossServerOneVsOneHistory>();
        public event Action oneVsOneHistoryRefresh;
        public void OnReceivePackage(HC103_tagMCCrossRealmPKPlayerHisSeasonInfo package)
        {
            oneVsOneHistoryDict.Clear();
            for (int i = 0; i < package.Count; i++)
            {
                var data = package.SeasonList[i];
                oneVsOneHistoryDict[data.SeasonID] = new CrossServerOneVsOneHistory()
                {
                    season = data.SeasonID,
                    division = data.DanLV,
                    order = data.Order,
                    rewardLevel = data.AwardLV,
                    score = (int)data.Score
                };
            }
            if (oneVsOneHistoryRefresh != null)
            {
                oneVsOneHistoryRefresh();
            }
        }

        public bool TryGetOneVsOneHistory(int session, out CrossServerOneVsOneHistory history)
        {
            return oneVsOneHistoryDict.TryGetValue(session, out history);
        }

        public struct CrossServerOneVsOneHistory
        {
            public int season;
            public int order;
            public int division;
            public int rewardLevel;
            public int score;
        }
        #endregion

        #region 匹配记录

        private void GetLocalSaveData()
        {
            localSaveResults = new List<CrossServerOneVsOnePkResult>();
            string[] localJsons = LocalSave.GeStringArray(PkResultLocalSaveKey);
            if (localJsons != null)
            {
                for (int i = 0; i < localJsons.Length; i++)
                {
                    CrossServerOneVsOnePkResult resultInfo = JsonMapper.ToObject<CrossServerOneVsOnePkResult>(localJsons[i]);
                    localSaveResults.Add(resultInfo);
                }
            }
        }

        public void SetPkInfoLocalSave(CrossServerOneVsOnePkResult resultInfo)
        {
            if (localSaveResults.Count >= 30)
            {
                localSaveResults.RemoveAt(localSaveResults.Count - 1);
            }
            localSaveResults.Insert(0, resultInfo);
            string[] localJsons = new string[localSaveResults.Count];
            for (int i = 0; i < localJsons.Length; i++)
            {
                string json = JsonMapper.ToJson(localSaveResults[i]);
                localJsons[i] = json;
            }
            LocalSave.SetStringArray(PkResultLocalSaveKey, localJsons);
        }

        #endregion

        #region 红点

        public const int CrossOneVsOneRedKey = 21301;
        public Redpoint crossOneVsOneRedpoint = new Redpoint(CrossServerUtility.CrossServerRedKey, CrossOneVsOneRedKey);
        public const int CrossArenaRedKey = 2130101;
        public Redpoint crossArenaRedpoint = new Redpoint(CrossOneVsOneRedKey, CrossArenaRedKey);
        public const int CrossDayAwardsRedKey = 21301011;
        public Redpoint crossDayAwardsRedpoint = new Redpoint(CrossArenaRedKey, CrossDayAwardsRedKey);
        public const int CrossMatchRedKey = 21301012;
        public Redpoint crossMatchRedpoint = new Redpoint(CrossArenaRedKey, CrossMatchRedKey);

        public void UpdateCrossDayAwardsRedpoint()
        {
            bool isReceive = false;
            for (int i = 0; i < dayAwardTypelist.Count; i++)
            {
                var awardType = dayAwardTypelist[i];
                if (awardType.progress == AwardType.CompleteProgress.Completed)
                {
                    isReceive = true;
                    break;
                }
            }

            if (isReceive)
            {
                crossDayAwardsRedpoint.state = RedPointState.Simple;
            }
            else
            {
                crossDayAwardsRedpoint.state = RedPointState.None;
            }

            CrossServerUtility.UpdateCrossServerRedpoint();
        }

        public void UpdateCrossMatchRedpoint()
        {
            var playerInfo = CrossServerOneVsOnePlayerInfo.Instance;
            var pkSeason = CrossServerOneVsOnePKSeason.Instance;

            if (pkSeason.isSatisfyMatch && playerInfo.GetDayRemainNum() > 0)
            {
                crossMatchRedpoint.state = RedPointState.Simple;
            }
            else
            {
                crossMatchRedpoint.state = RedPointState.None;
            }

            if (crossMatchRedpoint.state != RedPointState.None)
            {
                CrossServerUtility.UpdateCrossServerRedpoint();
            }
        }

        #region 荣誉商店红点

        public const int CrossHonorStoreRedKey = 2130104;
        public Redpoint crossHonorStoreRedpoint = new Redpoint(CrossOneVsOneRedKey, CrossHonorStoreRedKey);
        private Dictionary<int, Redpoint> honorRedpointDict = new Dictionary<int, Redpoint>();
        public void SetHonorRedpoint()
        {
            honorRedpointDict.Clear();
            List<StoreConfig> storelist = StoreConfig.GetValues();
            for (int i = 0; i < storelist.Count; i++)
            {
                StoreConfig storeConfig = storelist[i];
                int redKey = 0;
                Redpoint redpoint = null;
                if (storeConfig.ShopType == (int)StoreFunc.CrossOneVsOneHonor)
                {
                    redKey = CrossHonorStoreRedKey * 100 + storeConfig.ID;
                    redpoint = new Redpoint(CrossHonorStoreRedKey, redKey);
                    honorRedpointDict.Add(storeConfig.ID, redpoint);
                }
            }
        }

        public Redpoint GetRedpointById(int shopId)
        {
            Redpoint redpoint = null;
            honorRedpointDict.TryGetValue(shopId, out redpoint);
            return redpoint;
        }

        private void UpdatePlayerData(PlayerDataType type)
        {
            switch (type)
            {
                case PlayerDataType.CDBPlayerRefresh_Honor:
                    UpdateCanBuyRedpoint();
                    break;
            }

        }

        public void UpdateCanBuyRedpoint()
        {
            var pkSeason = CrossServerOneVsOnePKSeason.Instance;
            if (!pkSeason.IsEnterCrossServer()) return;

            List<StoreModel.StoreData> storeDatas = storeModel.TryGetStoreDatas(StoreFunc.CrossOneVsOneHonor);
            if (storeDatas != null)
            {
                for (int i = 0; i < storeDatas.Count; i++)
                {
                    var storeData = storeDatas[i];
                    var storeConfig = storeData.storeConfig;
                    int type = 0;
                    TryGetRedTypeByShopId(storeConfig.ID, out type);
                    if (type == 6)
                    {
                        string key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", storeData.shopId);
                        int remainNum = 0;
                        honorRedpointDict[storeConfig.ID].state = RedPointState.None;
                        if (!storeModel.TryGetIsSellOut(storeConfig, out remainNum))
                        {
                            if (!PlayerPrefs.HasKey(key) || IsNewDay)
                            {
                                if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
                                {
                                    honorRedpointDict[storeConfig.ID].state = RedPointState.Simple;
                                    LocalSave.SetBool(key, true);
                                }
                            }
                            else
                            {
                                if (LocalSave.GetBool(key))
                                {
                                    if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
                                    {
                                        honorRedpointDict[storeConfig.ID].state = RedPointState.Simple;
                                    }
                                }
                            }
                        }
                    }
                }
            }

            CrossServerUtility.UpdateCrossServerRedpoint();
        }

        public bool TryGetRedTypeByShopId(int shopId, out int type)
        {
            type = 0;
            var ruleDict = storeModel.storeRedRuleDict;
            foreach (var key in ruleDict.Keys)
            {
                List<int> idlist = ruleDict[key];
                if (idlist.Contains(shopId))
                {
                    type = key;
                    return true;
                }
            }
            return false;
        }

        public void ClearRedpoint(int shopId)
        {
            IsNewDay = false;
            string record = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", shopId);
            if (honorRedpointDict[shopId].state != RedPointState.None)
            {
                honorRedpointDict[shopId].state = RedPointState.None;
                LocalSave.SetBool(record, false);
            }
        }
        #endregion

        #endregion
    }
}