using Snxxz.UI;
using System;
using System.Collections.Generic;
using System.Linq;

using UnityEngine;
using LitJson;
using System.Collections;

public class BuyShopItemLimit
{
    public uint ItemIndex;
    public ushort BuyCnt;        // 今日已购买次数
    public int isReset;         //是否属于每月重置  0 不重置 1重置
}

public struct ShopItemInfo
{
    public int itemId;
    public int count;

    public ShopItemInfo(int id, int count)
    {
        this.itemId = id;
        this.count = count;
    }
}

[XLua.LuaCallCSharp]
public class StoreModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk, ISwitchAccount
{
    public int[] normalBuyCoinsTypes { get; private set; }
    public string UNIONSTORESAVE_KEY { get; private set; }
    public string MUSTBUYSAVE_KEY { get; private set; }
    public string StoreEffectRecord_Key { get; private set; }
    public Dictionary<int, Dictionary<int, int>> JobReplaceIdDict = new Dictionary<int, Dictionary<int, int>>();
    public Dictionary<int, string> resetTimeDict { get; private set; }
    public Dictionary<int, int> showCoinsUIDict { get; private set; }
    public int storeTrailerLv { get; private set; }

    public bool isShowMysteryRefreshHint = true;
    int mysteryRefreshedCount = 0;
    List<int> mysteryCommondities = new List<int>();
    bool isLogin = true;

    public event Action mysteryShopRefreshEvent;

    RuneModel runeModel { get { return ModelCenter.Instance.GetModel<RuneModel>(); } }
    PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
    ItemTipsModel itemTipsModel { get { return ModelCenter.Instance.GetModel<ItemTipsModel>(); } }

    private bool isUpdatePlayerLv;

    public override void Init()
    {
        ParseFuncConfig();
        ParseStoreConfig();
        SetShopRedpoint();
        FuncConfigConfig buyItemHinit = FuncConfigConfig.Get("BuyItemHinit");
        normalBuyCoinsTypes = ConfigParse.GetMultipleStr<int>(buyItemHinit.Numerical1);
        FuncConfigConfig restTimeConfig = FuncConfigConfig.Get("RefreshText");
        resetTimeDict = ConfigParse.GetDic<int, string>(restTimeConfig.Numerical1);
        FuncConfigConfig mallCurrency = FuncConfigConfig.Get("MallCurrency");
        showCoinsUIDict = ConfigParse.GetDic<int, int>(mallCurrency.Numerical1);
        FuncConfigConfig mallPush = FuncConfigConfig.Get("MallPush");
        storeTrailerLv = int.Parse(mallPush.Numerical1);
        MainInterfaceWin.IsCopyOfThePanel += OnMoveTopPart;
    }

    public void OnBeforePlayerDataInitialize()
    {
        isUpdatePlayerLv = false;
        IsMustBuyDay = false;
        isLogin = true;
        ClearJumpModel();
        StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
        FuncOpen.Instance.OnFuncStateChangeEvent -= FuncStateChange;
        WindowCenter.Instance.windowAfterCloseEvent -= windowAfterOpen;
        WindowCenter.Instance.windowAfterCloseEvent -= windowAfterClose;
        PlayerDatas.Instance.fairyData.OnRefreshFairyMine -= RefreshServerHour;
        PlayerDatas.Instance.fairyData.OnRefreshFairyInfo -= RefreshFamilyLv;
        RefreshTCBPlayerDataEvent -= RefreshPlayerData;
        TimeMgr.Instance.OnHourEvent -= RefreshServerHour;
        GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
        NewBieCenter.Instance.guideBeginEvent -= GuidBegin;
        packModel.refreshItemCountEvent -= UpdateFairyEquip;
        shopItemlimitDict.Clear();
        petAndMountPushlist.Clear();
        ClearPushData();
        tagTowerModel = null;
        storeFuncType = StoreFunc.MysteryStore;
        tcbRefreshDict.Clear();

    }

    public void OnAfterPlayerDataInitialize()
    {
        UNIONSTORESAVE_KEY = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, LocalSaveStoreType.UnionStore);
        StoreEffectRecord_Key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "StoreEffectRecord");
        MUSTBUYSAVE_KEY = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "MustBuy");
    }

    public void OnPlayerLoginOk()
    {
        PlayerDatas.Instance.fairyData.OnRefreshFairyInfo += RefreshFamilyLv;
        PlayerDatas.Instance.fairyData.OnRefreshFairyMine += RefreshServerHour;
        FuncOpen.Instance.OnFuncStateChangeEvent += FuncStateChange;
        RefreshTCBPlayerDataEvent += RefreshPlayerData;
        TimeMgr.Instance.OnHourEvent += RefreshServerHour;
        GlobalTimeEvent.Instance.secondEvent += UpdateSecond;
        StageLoad.Instance.onStageLoadFinish += OnStageLoadFinish;
        WindowCenter.Instance.windowAfterOpenEvent += windowAfterOpen;
        WindowCenter.Instance.windowAfterCloseEvent += windowAfterClose;
        NewBieCenter.Instance.guideBeginEvent += GuidBegin;
        packModel.refreshItemCountEvent += UpdateFairyEquip;
        UpdateShowStore();
        SetIsMustBuyDay();
        ControllerRedPoint();
        UpdateFreeShopRedpoint();
        UpdateCanBuyRedpoint();
        UpdateMustBuyRedpoint();
        UpdatePetAndMountPutAwayRedpoint();
        isLogin = false;
    }

    public void OnSwitchAccount()
    {
        isShowMysteryRefreshHint = true;
    }

    public override void UnInit()
    {
        MainInterfaceWin.IsCopyOfThePanel -= OnMoveTopPart;
    }

    public void RefreshMysteryShop()
    {
        var consumablesOwn = packModel.GetItemCountByID(PackType.Item, GeneralDefine.mysteryShopRefreshItem);
        var consumablesNeed = GetMysteryShopRefreshItemNeed();
        if (consumablesOwn >= consumablesNeed)
        {
            var info = new CA232_tagCMRefreshMysticalShop();
            GameNetSystem.Instance.SendInfo(info);
            return;
        }

        var moneyOwn = UIHelper.GetMoneyCnt(1);
        var moneyNeed = (ulong)(GeneralDefine.mysteryShopRefreshItemValue * consumablesNeed);
        if (moneyOwn >= moneyNeed)
        {
            var info = new CA232_tagCMRefreshMysticalShop();
            GameNetSystem.Instance.SendInfo(info);
            return;
        }

        WindowCenter.Instance.Open<RechargeTipWin>();
    }

    public int GetMysteryShopRefreshItemNeed()
    {
        var enumerator = GeneralDefine.mysteryShopRefreshItemCount.GetEnumerator();
        while (enumerator.MoveNext())
        {
            if (mysteryRefreshedCount < enumerator.Current.Key)
            {
                break;
            }
        }

        return enumerator.Current.Value;
    }

    public void UpdateMysteryCommondities(HA816_tagMCMysticalShopInfo info)
    {
        mysteryRefreshedCount = info.RefreshCnt;
        mysteryCommondities.Clear();

        foreach (var item in info.GoodsList)
        {
            mysteryCommondities.Add((int)item.GoodsID);
        }

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

    #region 解析本地数据
    public Dictionary<int, List<int>> storeRedRuleDict { get; private set; } //红点类型 1,免费商品  2,必买商品  3,坐骑灵宠 4,可购买物品（积分兑换）
    public Dictionary<int, List<int>> storePushDict { get; private set; } //1，每日弹1次2,只弹1次
    private void ParseFuncConfig()
    {
        storeRedRuleDict = new Dictionary<int, List<int>>();
        storePushDict = new Dictionary<int, List<int>>();
        FuncConfigConfig storeRedRules = FuncConfigConfig.Get("StoreRedRules");
        if (storeRedRules != null)
        {
            JsonData redRules = JsonMapper.ToObject(storeRedRules.Numerical1);
            foreach (var type in redRules.Keys)
            {
                int redType = 0;
                int.TryParse(type, out redType);
                JsonData shops = redRules[type];
                if (!storeRedRuleDict.ContainsKey(redType))
                {
                    List<int> shopIdlist = new List<int>();
                    if (shops.IsArray)
                    {
                        for (int i = 0; i < shops.Count; i++)
                        {
                            int shopId = 0;
                            int.TryParse(shops[i].ToString(), out shopId);
                            shopIdlist.Add(shopId);
                        }
                    }
                    storeRedRuleDict.Add(redType, shopIdlist);
                }
            }

            JsonData pushRules = JsonMapper.ToObject(storeRedRules.Numerical2);
            foreach (var type in pushRules.Keys)
            {
                int pushType = 0;
                int.TryParse(type, out pushType);
                JsonData shops = pushRules[type];
                if (!storePushDict.ContainsKey(pushType))
                {
                    List<int> shopIdlist = new List<int>();
                    if (shops.IsArray)
                    {
                        for (int i = 0; i < shops.Count; i++)
                        {
                            int shopId = 0;
                            int.TryParse(shops[i].ToString(), out shopId);
                            shopIdlist.Add(shopId);
                        }
                    }
                    storePushDict.Add(pushType, shopIdlist);
                }
            }
        }
    }

    public Dictionary<int, List<StoreData>> storeTypeDict { get; private set; }
    public Dictionary<int, List<StoreData>> theOnlyShopDict { get; private set; } //key 物品id
    public Dictionary<string, List<StoreData>> limitValueShopDict { get; private set; } //key 商品类型和限制条件
    private void ParseStoreConfig()
    {
        storeTypeDict = new Dictionary<int, List<StoreData>>();
        theOnlyShopDict = new Dictionary<int, List<StoreData>>();
        limitValueShopDict = new Dictionary<string, List<StoreData>>();
        List<StoreConfig> storeConfigs = StoreConfig.GetValues();
        for (int i = 0; i < storeConfigs.Count; i++)
        {
            var config = storeConfigs[i];
            if (config.ShopType != 0)
            {
                StoreData storeData = new StoreData();
                storeData.shopId = config.ID;
                storeData.storeConfig = config;
                storeData.jobReplaceDict = AnalysisJobReplace(config);
                if (!storeTypeDict.ContainsKey(config.ShopType))
                {
                    List<StoreData> storeDatas = new List<StoreData>();
                    storeDatas.Add(storeData);
                    storeTypeDict.Add(config.ShopType, storeDatas);
                }
                else
                {
                    storeTypeDict[config.ShopType].Add(storeData);
                }

                if (config.TheOnlyShop == 1)
                {
                    if (!theOnlyShopDict.ContainsKey(config.ItemID))
                    {
                        List<StoreData> storeDatas = new List<StoreData>();
                        storeDatas.Add(storeData);
                        theOnlyShopDict.Add(config.ItemID, storeDatas);
                    }
                    else
                    {
                        theOnlyShopDict[config.ItemID].Add(storeData);
                    }
                }

                string key = StringUtility.Contact(config.ShopType, config.LimitValue);
                if (!limitValueShopDict.ContainsKey(key))
                {
                    List<StoreData> storeDatas = new List<StoreData>();
                    storeDatas.Add(storeData);
                    limitValueShopDict.Add(key, storeDatas);
                }
                else
                {
                    limitValueShopDict[key].Add(storeData);
                }
            }
        }

        foreach (var type in storeTypeDict.Keys)
        {
            var configs = storeTypeDict[type];
            configs.Sort(CompareByShopSort);
        }
    }

    private Dictionary<int, List<int>> AnalysisJobReplace(StoreConfig storeConfig)
    {
        if (storeConfig == null || string.IsNullOrEmpty(storeConfig.JobItem)) return null;

        Dictionary<int, List<int>> replaceDict = new Dictionary<int, List<int>>();
        JsonData jsonData = JsonMapper.ToObject(storeConfig.JobItem);
        if (jsonData.IsArray)
        {
            for (int i = 0; i < jsonData.Count; i++)
            {
                List<int> idlist = new List<int>();
                replaceDict.Add(i, idlist);
                if (jsonData[i].IsArray)
                {
                    for (int j = 0; j < jsonData[i].Count; j++)
                    {
                        int itemId = int.Parse(jsonData[i][j].ToString());
                        idlist.Add(itemId);
                    }
                }
            }
        }
        return replaceDict;
    }

    public int CompareByShopSort(StoreData start, StoreData end)
    {
        int sort1 = start.storeConfig.ShopSort;
        int sort2 = end.storeConfig.ShopSort;
        if (sort1.CompareTo(sort2) != 0) return sort1.CompareTo(sort2);

        return 0;
    }

    public class StoreData
    {
        public int shopId;
        public StoreConfig storeConfig;
        public Dictionary<int, List<int>> jobReplaceDict;
    }
    #endregion

    #region 获取数据

    private Dictionary<int, List<StoreData>> showStoreTypeDict = new Dictionary<int, List<StoreData>>();

    public void UpdateShowStore()
    {
        showStoreTypeDict.Clear();
        int playeLv = PlayerDatas.Instance.baseData.LV;
        foreach (var type in storeTypeDict.Keys)
        {
            var storeDatas = storeTypeDict[type];
            List<StoreData> showStoreDatas = new List<StoreData>();
            if (!showStoreTypeDict.ContainsKey(type))
            {
                for (int i = 0; i < storeDatas.Count; i++)
                {
                    var storeData = storeDatas[i];
                    bool isReachLv = playeLv >= storeData.storeConfig.LV ? true : false;
                    bool isReachSpec = true;
                    switch (storeData.storeConfig.ShopType)
                    {
                        case 12:
                            isReachSpec = TryGetUnlockRune(storeData.storeConfig.ItemID);
                            break;
                    }
                    bool isReach = isReachSpec && isReachLv;
                    if (isReach)
                    {
                        int remainNum = 0;
                        bool isSellOut = TryGetIsSellOut(storeData.storeConfig, out remainNum);
                        if (storeData.storeConfig.IsHideSellOut != 1)
                        {
                            showStoreDatas.Add(storeData);
                        }
                        else
                        {
                            if (storeData.storeConfig.TheOnlyShop == 1)
                            {
                                if (!CheckTheOnlyShopSellOut(storeData.shopId))
                                {
                                    showStoreDatas.Add(storeData);
                                }
                            }
                            else
                            {
                                if (!isSellOut)
                                {
                                    showStoreDatas.Add(storeData);
                                }
                            }
                        }
                    }

                }
                showStoreTypeDict.Add(type, showStoreDatas);
            }
        }
    }

    /// <summary>
    /// 检测唯一商品是否已售罄
    /// </summary>
    /// <param name="shopIndex"></param>
    /// <param name="isTheOnlyShop"></param>
    /// <returns></returns>
    public bool CheckTheOnlyShopSellOut(int shopIndex)
    {
        StoreConfig storeConfig = StoreConfig.Get(shopIndex);
        if (storeConfig == null || storeConfig.TheOnlyShop != 1) return false;

        if (theOnlyShopDict.ContainsKey(storeConfig.ItemID))
        {
            List<StoreData> datas = theOnlyShopDict[storeConfig.ItemID];
            for (int i = 0; i < datas.Count; i++)
            {
                var data = datas[i];
                int remainNum = 0;
                if (TryGetIsSellOut(data.storeConfig, out remainNum))
                {
                    return true;
                }
            }
        }

        return false;
    }

    public List<StoreData> TryGetStoreDatas(StoreFunc type)
    {
        var results = new List<StoreData>();
        List<StoreData> datas = null;
        if (showStoreTypeDict.TryGetValue((int)type, out datas))
        {
            switch (type)
            {
                case StoreFunc.MysteryStore:
                    foreach (var item in datas)
                    {
                        if (mysteryCommondities.Contains(item.storeConfig.ID))
                        {
                            results.Add(item);
                        }
                    }

                    results.Sort((StoreData x, StoreData y) => { return x.storeConfig.MoneyType < y.storeConfig.MoneyType ? -1 : 1; });
                    break;
                default:
                    results.AddRange(datas);
                    break;
            }
        }

        return results;
    }

    public StoreData GetStoreData(int shopId)
    {
        StoreConfig storeConfig = StoreConfig.Get(shopId);
        if (storeConfig == null) return null;

        List<StoreData> storeDatas = null;
        storeTypeDict.TryGetValue(storeConfig.ShopType, out storeDatas);
        if (storeDatas != null)
        {
            for (int i = 0; i < storeDatas.Count; i++)
            {
                var storeData = storeDatas[i];
                if (storeData.shopId == shopId)
                {
                    return storeData;
                }
            }
        }
        return null;
    }

    public int GetReplaceId(int shopId, int itemId)
    {
        var storeData = GetStoreData(shopId);
        if (storeData == null) return 0;

        int job = PlayerDatas.Instance.baseData.Job;
        var replaceDict = storeData.jobReplaceDict;
        if (replaceDict != null)
        {
            foreach (var index in replaceDict.Keys)
            {
                var idlist = replaceDict[index];
                if (idlist.Contains(itemId))
                {
                    int replaceIndex = job - 1;
                    return idlist[replaceIndex];
                }
            }
        }

        return itemId;
    }

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

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

    public bool TryGetIsSellOut(StoreConfig storeConfig, out int remainCnt)
    {
        int canBuyCnt = 0;
        int addBuyCnt = 0;
        remainCnt = 0;
        bool isLimitBuy = TryGetLimitBuy(storeConfig, out canBuyCnt, out addBuyCnt);
        if (!isLimitBuy) return false;

        remainCnt = canBuyCnt;
        BuyShopItemLimit shopItemLimit = GetBuyShopLimit((uint)storeConfig.ID);
        if (shopItemLimit != null)
        {
            remainCnt -= shopItemLimit.BuyCnt;
        }

        if (remainCnt <= 0)
        {
            return true;
        }
        return false;
    }

    public bool TryGetLimitBuy(StoreConfig config, out int canBuyCnt, out int addBuyCnt)
    {
        canBuyCnt = 0;
        addBuyCnt = 0;
        if (config == null) return false;

        int[] canBuyNums = config.PurchaseNumber;
        if (canBuyNums == null || canBuyNums.Length < 1) return false;

        int curVipIndex = -1;
        int nexVipIndex = -1;
        bool isVipBuy = TryGetVipBuy(config, out curVipIndex, out nexVipIndex);
        if (isVipBuy)
        {
            if (curVipIndex != -1)
            {
                canBuyCnt = canBuyNums[curVipIndex];
            }

            if (nexVipIndex != -1)
            {
                addBuyCnt = canBuyNums[nexVipIndex] - canBuyCnt;
            }
            return true;
        }
        else
        {
            if (canBuyNums[0] != 0)
            {
                canBuyCnt = canBuyNums[0];
                return true;
            }
            else
            {
                return false;
            }
        }
    }

    public bool TryGetVipBuy(StoreConfig config, out int curVipIndex, out int nextVipIndex)
    {
        curVipIndex = -1;
        nextVipIndex = -1;
        bool isVipBuy = false;
        if (config == null) return false;

        var vipLvs = config.VIPLV;
        if (vipLvs == null || vipLvs.Length < 1) return false;

        for (int i = 0; i < vipLvs.Length; i++)
        {
            var vipLv = vipLvs[i];
            if (vipLv != 0)
            {
                isVipBuy = true;
            }
        }

        if (isVipBuy)
        {
            int playerVip = PlayerDatas.Instance.baseData.VIPLv;
            for (int i = vipLvs.Length - 1; i > -1; i--)
            {
                var vipLv = vipLvs[i];
                if (vipLv > playerVip)
                {
                    nextVipIndex = i;
                }
                else if (vipLv <= playerVip)
                {
                    curVipIndex = i;
                    break;
                }
            }

        }

        return isVipBuy;
    }

    public bool TryGetUnlockRune(int runeId)
    {
        List<int> unlockRunes = runeModel.GetUnlockRunes();
        if (unlockRunes.Contains(runeId))
        {
            return true;
        }
        return false;
    }

    public List<StoreData> TryGetStoreDatasByLimit(int type, int limitValue)
    {
        string key = StringUtility.Contact(type, limitValue);
        List<StoreData> datas = null;
        limitValueShopDict.TryGetValue(key, out datas);
        return datas;
    }
    #endregion

    public string GetStoreRefreshTimeByType(int type)
    {
        if (resetTimeDict == null || !resetTimeDict.ContainsKey(type)) return string.Empty;

        switch (type)
        {
            case 7:
                int willRefreshTime = GetWillRefreshTime();
                return Language.Get(resetTimeDict[type], UIHelper.AppendColor(TextColType.Green, TimeUtility.SecondsToHMS(willRefreshTime), true));
            default:
                return Language.Get(resetTimeDict[type]);
        }
    }

    public string GetMysteryStoreRefreshTime()
    {
        var seconds = GeneralDefine.mysteryShopRefreshInterval -
             (int)((TimeUtility.ServerNow - TimeUtility.createRoleTime).TotalSeconds) % GeneralDefine.mysteryShopRefreshInterval;
        return Language.Get("StoreWin200", TimeUtility.SecondsToHMS(seconds));
    }

    private int GetWillRefreshTime()
    {
        int willRefresh = (3 - TimeUtility.OpenDay % 3);
        if (willRefresh == 3)
        {
            if (TimeUtility.ServerNow.Hour < 5)
            {
                willRefresh = 0;
            }
        }
        int remainHour = 5 - TimeUtility.ServerNow.Hour;
        int remainMinute = 0 - TimeUtility.ServerNow.Minute;
        int remainSecond = willRefresh * 24 * 60 * 60 + remainHour * 60 * 60 + remainMinute * 60 - TimeUtility.ServerNow.Second;
        return remainSecond;
    }


    private void UpdateSecond()
    {
        if (isUpdatePlayerLv)
        {
            UpdatePlayerLv();
            isUpdatePlayerLv = false;
        }
    }

    private void UpdatePlayerLv()
    {
        UpdateShowStore();
        UpdateFreeShopRedpoint();
        UpdateCanBuyRedpoint();
        UpdateMustBuyRedpoint();
        UpdatePetAndMountPutAwayRedpoint();
    }

    private void RefreshPlayerData(PlayerDataType type)
    {
        switch (type)
        {
            case PlayerDataType.LV:
                isUpdatePlayerLv = true;
                break;
            case PlayerDataType.VIPLv:
            case PlayerDataType.Gold:
            case PlayerDataType.GoldPaper:
                UpdateFreeShopRedpoint();
                UpdateCanBuyRedpoint();
                break;
            case PlayerDataType.FBHelpPoint:
                UpdateFreeShopRedpoint();
                UpdateCanBuyRedpoint();
                UpdateFairyEquipRedpoint();
                break;
        }
    }

    private void RefreshFamilyLv()
    {
        int familyLv = PlayerDatas.Instance.fairyData.fairy.FamilyLV;
        if (familyLv > GetSaveFairyLV())
        {
            ControllerRedPoint();
        }

    }

    private void RefreshServerHour()
    {
        ControllerRedPoint();
        if (PlayerPrefs.HasKey(MUSTBUYSAVE_KEY))
        {
            int[] records = LocalSave.GetIntArray(MUSTBUYSAVE_KEY);
            if (TimeUtility.ServerNow.Hour >= 5
                && ((TimeUtility.ServerNow.Day == records[0] && records[1] < 5)
                || TimeUtility.ServerNow.Day != records[0]))
            {
                saveTimes[0] = TimeUtility.ServerNow.Day;
                saveTimes[1] = TimeUtility.ServerNow.Hour;
                IsMustBuyDay = true;
                LocalSave.SetIntArray(MUSTBUYSAVE_KEY, saveTimes);
                UpdateMustBuyRedpoint();
            }
        }
        if (!PlayerDatas.Instance.fairyData.HasFairy)
        {
            PlayerPrefs.DeleteKey(UNIONSTORESAVE_KEY);
        }
    }

    public event Action RefreshBuyShopLimitEvent;

    public StoreFunc storeFuncType = StoreFunc.MysteryStore;
    private Dictionary<uint, BuyShopItemLimit> shopItemlimitDict = new Dictionary<uint, BuyShopItemLimit>();
    private Dictionary<string, RuneTowerFloorConfig> tagTowerModel;

    /// <summary>
    /// 得到物品购买次数
    /// </summary>
    /// <param name="buylimit"></param>
    public void RefreshBuyShopLimitModel(HA802_tagMCShopItemDayBuyCntInfo buylimit)
    {
        DebugEx.Log("RefreshBuyShopLimitModel" + buylimit.Count);
        if (buylimit.Count > 0)
        {
            int i = 0;
            for (i = 0; i < buylimit.Count; i++)
            {
                if (!shopItemlimitDict.ContainsKey(buylimit.DayBuyCntList[i].ItemIndex))
                {
                    BuyShopItemLimit shopItemLimit = new BuyShopItemLimit();
                    shopItemLimit.ItemIndex = buylimit.DayBuyCntList[i].ItemIndex;
                    shopItemLimit.BuyCnt = buylimit.DayBuyCntList[i].BuyCnt;
                    shopItemLimit.isReset = buylimit.DayBuyCntList[i].IsReset;
                    shopItemlimitDict.Add(shopItemLimit.ItemIndex, shopItemLimit);
                }
                else
                {
                    shopItemlimitDict[buylimit.DayBuyCntList[i].ItemIndex].BuyCnt = buylimit.DayBuyCntList[i].BuyCnt;
                    shopItemlimitDict[buylimit.DayBuyCntList[i].ItemIndex].isReset = buylimit.DayBuyCntList[i].IsReset;
                }
            }

        }

        if (!isLogin)
        {
            UpdateShowStore();
            UpdateFreeShopRedpoint();
            UpdateCanBuyRedpoint();
            UpdateMustBuyRedpoint();
            UpdatePetAndMountPutAwayRedpoint();
            UpdateFairyEquipRedpoint();
        }
        if (RefreshBuyShopLimitEvent != null)
            RefreshBuyShopLimitEvent();
    }

    public BuyShopItemLimit GetBuyShopLimit(uint itemIndex)
    {
        if (shopItemlimitDict.ContainsKey(itemIndex))
        {
            return shopItemlimitDict[itemIndex];
        }
        return null;
    }

    private RuneConfig _tagRuneModel = null;

    public RuneTowerFloorConfig SetRuneSource(int itemId)
    {
        _tagRuneModel = RuneConfig.Get(itemId);
        if (_tagRuneModel == null)
            return null;
        var _tagRuneTowerModel = RuneTowerFloorConfig.Get(_tagRuneModel.TowerID);
        return _tagRuneTowerModel;
    }

    List<ShopItemInfo> shopItemlist = new List<ShopItemInfo>();
    public List<ShopItemInfo> GetShopItemlistByIndex(StoreConfig storeConfig)
    {
        if (storeConfig == null) return null;

        shopItemlist.Clear();
        if (storeConfig.ItemID != 0)
        {
            int replaceId = GetReplaceId(storeConfig.ID, storeConfig.ItemID);
            ShopItemInfo shopItem = new ShopItemInfo(replaceId, storeConfig.ItemCnt);
            shopItemlist.Add(shopItem);
        }
        JsonData extraItem = JsonMapper.ToObject(storeConfig.ItemListEx);
        if (extraItem.IsArray)
        {
            for (int i = 0; i < extraItem.Count; i++)
            {
                if (extraItem[i].IsArray)
                {
                    if (extraItem[i].Count > 0)
                    {
                        int itemId = int.Parse(extraItem[i][0].ToString());
                        int itemCount = int.Parse(extraItem[i][1].ToString());
                        if (itemId != 0)
                        {
                            int extraReplaceId = GetReplaceId(storeConfig.ID, itemId);
                            ShopItemInfo shop = new ShopItemInfo(extraReplaceId, itemCount);
                            shopItemlist.Add(shop);
                        }
                    }
                }
            }
        }
        return shopItemlist;
    }

    public bool TryGetShopItemInfo(StoreFunc _type, int _id, out List<ShopItemInfo> _shopItems)
    {
        _shopItems = null;
        var _list = TryGetStoreDatas(_type);
        var _index = _list.FindIndex((x) =>
        {
            return x.shopId == _id;
        });
        if (_index == -1)
        {
            return false;
        }
        _shopItems = GetShopItemlistByIndex(_list[_index].storeConfig);
        return _shopItems != null;
    }

    #region 0418 数据处理
    private Dictionary<PlayerDataType, int> tcbRefreshDict = new Dictionary<PlayerDataType, int>();
    public event Action<PlayerDataType> RefreshTCBPlayerDataEvent;
    public void RefreshTCBPlayerData(H0418_tagObjInfoRefresh info)
    {
        if (!tcbRefreshDict.ContainsKey((PlayerDataType)info.RefreshType))
        {
            tcbRefreshDict.Add((PlayerDataType)info.RefreshType, (int)info.Value);
        }
        else
        {
            tcbRefreshDict[(PlayerDataType)info.RefreshType] = (int)info.Value;
        }

        if (RefreshTCBPlayerDataEvent != null)
        {
            RefreshTCBPlayerDataEvent((PlayerDataType)info.RefreshType);
        }
    }

    public int GetTCBPlayerData(PlayerDataType tCDBPlayer)
    {
        int value = 0;
        tcbRefreshDict.TryGetValue(tCDBPlayer, out value);
        return value;
    }

    #endregion

    #region 点击商店物品逻辑
    public void OnClickShopCell(StoreConfig shopInfo)
    {
        BuyItemPopModel.Instance.SetModel(shopInfo.ID);
        int itemId = GetReplaceId(shopInfo.ID, shopInfo.ItemID);
        ItemAttrData attrData = new ItemAttrData(itemId, true, (ulong)shopInfo.ItemCnt, -1, true, PackType.Deleted
            , "", null, ItemTipChildType.Buy);
        itemTipsModel.SetItemTipsModel(attrData, false);
        attrData.SetTipsFuncBtn(ItemOperateType.buy, (ItemOperateType type, string id) => { OnClickBuyBtn(ItemOperateType.buy, shopInfo.ID); });
        itemTipsModel.ShowTip();
    }

    public int BuyCnt { get; private set; }
    public void SetBuyCnt(int buyCnt)
    {
        BuyCnt = buyCnt;
    }
    private void OnClickBuyBtn(ItemOperateType type, int shopId)
    {
        BuyShopItemLimit shopItemLimit = GetBuyShopLimit((uint)shopId);
        StoreConfig storeConfig = StoreConfig.Get(shopId);
        int curVipIndex = -1;
        int nextVipIndex = -1;
        bool isVipBuy = TryGetVipBuy(storeConfig, out curVipIndex, out nextVipIndex);
        if (shopItemLimit != null)
        {
            int remainNum = 0;
            if (isVipBuy)
            {
                remainNum = storeConfig.PurchaseNumber[curVipIndex] - shopItemLimit.BuyCnt;
            }
            else
            {
                remainNum = storeConfig.PurchaseNumber[0] - shopItemLimit.BuyCnt;
            }
            if (remainNum < 1)
            {
                ServerTipDetails.DisplayNormalTip(Language.Get("StoreWin109"));
                return;
            }

        }
        SendBuyShopItem(storeConfig, BuyCnt);
    }

    #endregion

    private ulong _price;
    public void SendBuyShopItem(StoreConfig model, int count)
    {
        if ((StoreFunc)model.ShopType == StoreFunc.RuneStore)
        {
            _tagRuneModel = RuneConfig.Get(model.ItemID);
            if (_tagRuneModel != null)
            {
                if (!IsCanBuyItem(_tagRuneModel.TowerID))
                {
                    ServerTipDetails.DisplayNormalTip(Language.Get("Store101"));
                    return;
                }
            }
        }

        _price = (ulong)(model.MoneyNumber * count);
        if (MoneyIsEnough(model.MoneyType, _price))
        {
            C0803_tagCBuyItemList buyShop = new C0803_tagCBuyItemList();
            buyShop.NPCID = 0;
            buyShop.BuyItemIndex = (ushort)model.ID;
            buyShop.BuyCount = (ushort)count;
            GameNetSystem.Instance.SendInfo(buyShop);

        }
        else
        {
            switch (model.MoneyType)
            {
                case 1:
                    if (VersionConfig.Get().isBanShu)
                    {
                        SysNotifyMgr.Instance.ShowTip("GoldErr");
                        return;
                    }
                    WindowCenter.Instance.Open<RechargeTipWin>();
                    break;
                case 25:
                    SysNotifyMgr.Instance.ShowTip("LackXBMoney", model.MoneyType);
                    break;
                default:
                    SysNotifyMgr.Instance.ShowTip("LackMoney", model.MoneyType);
                    break;
            }
        }

    }

    public event Action<int> RefreshBuyResultEvent;

    public void GetBuyResult(HA811_tagMCShoppingResult result)
    {
        DebugEx.Log("GetBuyResult");
        StoreConfig tagStore = StoreConfig.Get((int)result.ItemIndex);
        if (tagStore != null)
        {
            ItemConfig chinModel = ItemConfig.Get(GetReplaceId(tagStore.ID, tagStore.ItemID));
            if (!normalBuyCoinsTypes.Contains(tagStore.MoneyType))
            {
                if (tagStore.RemindSuccess == 0)
                {
                    return;
                }
                BuySuccessModel.Instance.SetBuySuccessModel(chinModel.ID, (int)result.ItemCnt);
                if (!WindowCenter.Instance.IsOpen<BuySuccessWin>())
                {
                    WindowCenter.Instance.Open<BuySuccessWin>();
                }
            }
            else
            {
                float costMoney = tagStore.MoneyNumber;
                SysNotifyMgr.Instance.ShowTip("BuyItemHinit", costMoney, tagStore.MoneyType, chinModel.ItemName);
            }

            if (RefreshBuyResultEvent != null)
            {
                RefreshBuyResultEvent(chinModel.ID);
            }
        }
    }

    /// <summary>
    /// 用于判断符文塔兑换是否满足条件
    /// </summary>
    /// <param name="limitTower"></param>
    /// <returns></returns>
    public bool IsCanBuyItem(int limitTower)
    {
        int playerTower = (int)runeModel.passRuneTowerFloor;
        int offset = playerTower - limitTower;

        return offset >= 0;
    }

    public bool MoneyIsEnough(int moneyType, ulong money)
    {
        if (UIHelper.GetMoneyCnt(moneyType) < money)
        {
            return false;
        }
        else
        {
            return true;
        }
    }

    public int jumpToItemId { get; set; }
    public void SetJumpToModel(int itemId)
    {
        jumpToItemId = itemId;
    }

    public event Action StoreFuncOpenAct;

    private void FuncStateChange(int funcId)
    {
        switch ((FuncOpenEnum)funcId)
        {
            case FuncOpenEnum.Store:
                if (StoreFuncOpenAct != null)
                {
                    StoreFuncOpenAct();
                }
                UpdateFreeShopRedpoint();
                UpdateCanBuyRedpoint();
                UpdateMustBuyRedpoint();
                UpdatePetAndMountPutAwayRedpoint();
                UpdateFairyEquipRedpoint();
                break;
            case FuncOpenEnum.BlastFurnace:
                ControllerRedPoint();
                break;
        }
    }

    public bool IsNewDay(string recordKey)
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return false;

        if (PlayerPrefs.HasKey(recordKey))
        {
            int day = LocalSave.GetInt(recordKey);
            if (day != TimeUtility.ServerNow.Day)
            {
                LocalSave.SetInt(recordKey, TimeUtility.ServerNow.Day);
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            LocalSave.SetInt(recordKey, TimeUtility.ServerNow.Day);
            return true;
        }
    }
    #region 商城红点

    #region 仙盟红点逻辑处理

    private bool CheckIsBuyNewItem(int fairyLv)
    {
        if (fairyLv > GetSaveFairyLV())
        {
            var toolStoreDatas = TryGetStoreDatasByLimit((int)StoreFunc.ToolStore, fairyLv);
            var mountStoreDatas = TryGetStoreDatasByLimit((int)StoreFunc.MountStoneStore, fairyLv);
            var skillBookStoreData = TryGetStoreDatasByLimit((int)StoreFunc.MountSkillBookStore, fairyLv);
            if ((toolStoreDatas != null && toolStoreDatas.Count > 0)
                || (mountStoreDatas != null && mountStoreDatas.Count > 0)
                || (skillBookStoreData != null && skillBookStoreData.Count > 0))
            {
                return true;
            }
        }
        return false;
    }

    private bool CheckIsNewMonth()
    {
        GetSaveDateTime();
        if (datelist.Count > 0)
        {
            if (TimeUtility.ServerNow.Month == datelist[0])
            {
                if (TimeUtility.ServerNow.Day >= 1
                    && TimeUtility.ServerNow.Hour >= 5
                    && datelist[1] <= 1 && datelist[2] < 5)
                {
                    return true;
                }
            }
            else
            {
                if (TimeUtility.ServerNow.Day >= 1
                    && TimeUtility.ServerNow.Hour >= 5)
                {
                    return true;
                }
            }
        }
        return false;
    }

    List<int> datelist = new List<int>();
    public List<int> GetSaveDateTime()
    {
        datelist.Clear();
        int[] unionArray = LocalSave.GetIntArray(UNIONSTORESAVE_KEY);
        if (unionArray != null && unionArray.Length >= 4)
        {
            datelist.Add(unionArray[1]);
            datelist.Add(unionArray[2]);
            datelist.Add(unionArray[3]);
        }
        return datelist;
    }

    public int GetSaveFairyLV()
    {
        int[] unionArray = LocalSave.GetIntArray(UNIONSTORESAVE_KEY);
        int fairyLv = 0;
        if (unionArray != null)
        {
            return unionArray[0];
        }
        return fairyLv;
    }


    //1仙盟等级 2 月份 3 号 4 几点
    public void SetStoreLocalSave(LocalSaveStoreType saveStoreType, params int[] infos)
    {
        string key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, saveStoreType);
        LocalSave.SetIntArray(key, infos);
    }

    public void ControllerRedPoint(bool isLook = false)
    {
        MainRedDot.Instance.fairyStoreRedPoint.state = RedPointState.None;
        if (!ModelCenter.Instance.GetModel<FairyModel>().fairyStoreOpen
            || !FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace))
        {
            return;
        }

        int familyLv = PlayerDatas.Instance.fairyData.fairy.FamilyLV;
        if (!isLook)
        {
            if (CheckIsBuyNewItem(familyLv))
            {
                MainRedDot.Instance.fairyStoreRedPoint.state = RedPointState.Simple;
                return;
            }

            if (CheckIsNewMonth())
            {
                MainRedDot.Instance.fairyStoreRedPoint.state = RedPointState.Simple;
                return;
            }
        }

        SetStoreLocalSave(LocalSaveStoreType.UnionStore, familyLv, TimeUtility.ServerNow.Month,
                TimeUtility.ServerNow.Day, TimeUtility.ServerNow.Hour);
    }

    #endregion

    public const int StoreFunc_RedKey = 22;
    public const int StoreFunc1_RedKey = 2201;
    public const int StoreFunc2_RedKey = 2202;
    public const int StoreFunc3_RedKey = 2203;
    public const int StoreFunc4_RedKey = 2204;
    public const int StoreFunc5_RedKey = 2205;
    public Redpoint storeFuncPoint = new Redpoint(StoreFunc_RedKey);
    public Redpoint storeFunc1Point = new Redpoint(StoreFunc_RedKey, StoreFunc1_RedKey);
    public Redpoint storeFunc2Point = new Redpoint(StoreFunc_RedKey, StoreFunc2_RedKey);
    public Redpoint storeFunc3Point = new Redpoint(StoreFunc_RedKey, StoreFunc3_RedKey);
    public Redpoint storeFunc4Point = new Redpoint(StoreFunc_RedKey, StoreFunc4_RedKey);
    public Redpoint storeFunc5Point = new Redpoint(StoreFunc_RedKey, StoreFunc5_RedKey);
    public Dictionary<int, Redpoint> shopRedDict = new Dictionary<int, Redpoint>();
    public void SetShopRedpoint()
    {
        shopRedDict.Clear();
        List<StoreConfig> storelist = StoreConfig.GetValues();
        for (int i = 0; i < storelist.Count; i++)
        {
            StoreConfig storeConfig = storelist[i];
            int redKey = 0;
            Redpoint redpoint = null;
            switch (storeConfig.ShopType)
            {
                case 1:
                    redKey = StoreFunc1_RedKey * 10000 + storeConfig.ID;
                    redpoint = new Redpoint(StoreFunc1_RedKey, redKey);
                    shopRedDict.Add(storeConfig.ID, redpoint);
                    break;
                case 2:
                    redKey = StoreFunc2_RedKey * 10000 + storeConfig.ID;
                    redpoint = new Redpoint(StoreFunc2_RedKey, redKey);
                    shopRedDict.Add(storeConfig.ID, redpoint);
                    break;
                case 3:
                    redKey = StoreFunc3_RedKey * 10000 + storeConfig.ID;
                    redpoint = new Redpoint(StoreFunc3_RedKey, redKey);
                    shopRedDict.Add(storeConfig.ID, redpoint);
                    break;
                case 4:
                    redKey = StoreFunc4_RedKey * 10000 + storeConfig.ID;
                    redpoint = new Redpoint(StoreFunc4_RedKey, redKey);
                    shopRedDict.Add(storeConfig.ID, redpoint);
                    break;
                case 5:
                    redKey = StoreFunc5_RedKey * 10000 + storeConfig.ID;
                    redpoint = new Redpoint(StoreFunc5_RedKey, redKey);
                    shopRedDict.Add(storeConfig.ID, redpoint);
                    break;
            }
        }
    }

    public void UpdateFreeShopRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;

        foreach (var key in showStoreTypeDict.Keys)
        {
            var storeDatas = showStoreTypeDict[key];
            for (int i = 0; i < storeDatas.Count; i++)
            {
                var storeConfig = storeDatas[i].storeConfig;
                int type = 0;
                TryGetRedTypeByShopId(storeConfig.ID, out type);
                if (type == 1)
                {
                    int remainNum = 0;
                    if (!TryGetIsSellOut(storeConfig, out remainNum))
                    {
                        shopRedDict[storeConfig.ID].state = RedPointState.Simple;
                    }
                    else
                    {
                        shopRedDict[storeConfig.ID].state = RedPointState.None;
                    }
                }
            }

        }
    }

    public void UpdateCanBuyRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;

        foreach (var key in showStoreTypeDict.Keys)
        {
            var storeDatas = showStoreTypeDict[key];
            for (int i = 0; i < storeDatas.Count; i++)
            {
                var storeConfig = storeDatas[i].storeConfig;
                int type = 0;
                TryGetRedTypeByShopId(storeConfig.ID, out type);
                if (type == 4)
                {
                    int remainNum = 0;
                    if (!TryGetIsSellOut(storeConfig, out remainNum))
                    {
                        if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
                        {
                            shopRedDict[storeConfig.ID].state = RedPointState.Simple;
                        }
                        else
                        {
                            shopRedDict[storeConfig.ID].state = RedPointState.None;
                        }
                    }
                    else
                    {
                        shopRedDict[storeConfig.ID].state = RedPointState.None;
                    }
                }
            }

        }
    }

    private void UpdateFairyEquip(PackType type, int index, int id)
    {
        if (type != PackType.Equip
            && (index != (int)RoleEquipType.FairyCan1 || index != (int)RoleEquipType.FairyCan2)) return;

        ClearAllFairyEquipRedpoint();

    }

    public void UpdateFairyEquipRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;

        foreach (var key in showStoreTypeDict.Keys)
        {
            var storeDatas = showStoreTypeDict[key];
            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 == 5)
                {

                    string fairySaveKey = string.Empty;
                    bool isGetSave = TryGetFairySaveKey(storeConfig, out fairySaveKey);
                    int remainNum = 0;
                    if (!TryGetIsSellOut(storeConfig, out remainNum))
                    {
                        if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
                        {
                            if (isGetSave)
                            {
                                shopRedDict[storeData.shopId].state = RedPointState.Simple;
                                LocalSave.SetBool(fairySaveKey, true);
                            }
                            else
                            {
                                shopRedDict[storeData.shopId].state = RedPointState.None;
                            }
                        }
                        else
                        {
                            if (shopRedDict[storeData.shopId].state != RedPointState.None)
                            {
                                LocalSave.SetBool(fairySaveKey, false);
                                shopRedDict[storeConfig.ID].state = RedPointState.None;
                            }
                        }
                    }
                    else
                    {
                        shopRedDict[storeConfig.ID].state = RedPointState.None;
                    }
                }
            }

        }
    }

    public void ClearFairyEquipRedpoint(StoreConfig storeConfig)
    {
        int type = 0;
        TryGetRedTypeByShopId(storeConfig.ID, out type);
        if (type == 5)
        {
            if (shopRedDict[storeConfig.ID].state != RedPointState.None)
            {
                shopRedDict[storeConfig.ID].state = RedPointState.None;
                string key1 = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", storeConfig.ID, "EquipPlace:", 9);
                string key2 = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", storeConfig.ID, "EquipPlace:", 10);
                if (LocalSave.GetBool(key1))
                {
                    LocalSave.SetBool(key1, false);
                }
                else if (LocalSave.GetBool(key2))
                {
                    LocalSave.SetBool(key2, false);
                }
            }
        }
    }

    public void SwitchFuncTitleClearRedpoint(StoreFunc storeFunc)
    {
        if (storeFuncType == StoreFunc.IntegralStore && storeFunc != StoreFunc.IntegralStore)
        {
            ClearAllFairyEquipRedpoint();
        }
    }

    private void ClearAllFairyEquipRedpoint()
    {
        foreach (var key in shopRedDict.Keys)
        {
            StoreConfig storeConfig = StoreConfig.Get(key);
            ItemConfig itemConfig = ItemConfig.Get(storeConfig.ItemID);
            int type = 0;
            TryGetRedTypeByShopId(storeConfig.ID, out type);
            if (type == 5)
            {
                if (shopRedDict[key].state != RedPointState.None)
                {
                    shopRedDict[key].state = RedPointState.None;
                    string key1 = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", key, "EquipPlace:", 9);
                    string key2 = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", key, "EquipPlace:", 10);

                    if (LocalSave.GetBool(key1))
                    {
                        LocalSave.SetBool(key1, false);
                    }
                    else if (LocalSave.GetBool(key2))
                    {
                        LocalSave.SetBool(key2, false);
                    }
                }
            }
        }
    }

    public bool TryGetFairySaveKey(StoreConfig config, out string fairySaveKey)
    {
        fairySaveKey = string.Empty;
        if (config == null) return false;

        ItemConfig itemConfig = ItemConfig.Get(config.ItemID);
        if (itemConfig.EquipPlace == (int)RoleEquipType.FairyCan1)
        {
            string key1 = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", config.ID, "EquipPlace:", 9);
            string key2 = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", config.ID, "EquipPlace:", 10);
            ItemModel itemModel1 = packModel.GetItemByIndex(PackType.Equip, 9);
            ItemModel itemModel2 = packModel.GetItemByIndex(PackType.Equip, 10);
            if (itemModel1 == null
                && (!PlayerPrefs.HasKey(key1) || LocalSave.GetBool(key1)))
            {
                fairySaveKey = key1;
                return true;
            }
            else if (itemModel2 == null
                 && (!PlayerPrefs.HasKey(key2) || LocalSave.GetBool(key2)))
            {
                fairySaveKey = key2;
                return true;
            }
        }
        return false;
    }

    public void UpdateMustBuyRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;

        foreach (var key in showStoreTypeDict.Keys)
        {
            var storeDatas = showStoreTypeDict[key];
            for (int i = 0; i < storeDatas.Count; i++)
            {
                var storeConfig = storeDatas[i].storeConfig;
                int type = 0;
                TryGetRedTypeByShopId(storeConfig.ID, out type);
                if (type == 2)
                {
                    if (CheckIsMustBuy(storeConfig))
                    {
                        shopRedDict[storeConfig.ID].state = RedPointState.Simple;
                    }
                    else
                    {
                        shopRedDict[storeConfig.ID].state = RedPointState.None;
                    }
                }
            }

        }
    }

    public void ClearMustBuyRedpoint(StoreConfig storeConfig)
    {
        int type = 0;
        TryGetRedTypeByShopId(storeConfig.ID, out type);
        if (type == 2)
        {
            shopRedDict[storeConfig.ID].state = RedPointState.None;
            IsMustBuyDay = false;
        }
    }

    public bool IsMustBuyDay { get; private set; }
    int[] saveTimes = new int[2];
    public void SetIsMustBuyDay()
    {
        if (IsMustBuyDay) return;

        saveTimes[0] = TimeUtility.ServerNow.Day;
        saveTimes[1] = TimeUtility.ServerNow.Hour;
        if (PlayerPrefs.HasKey(MUSTBUYSAVE_KEY))
        {
            int[] records = LocalSave.GetIntArray(MUSTBUYSAVE_KEY);
            if (TimeUtility.ServerNow.Hour >= 5
                && ((TimeUtility.ServerNow.Day == records[0] && records[1] < 5)
                || TimeUtility.ServerNow.Day != records[0]))
            {
                IsMustBuyDay = true;
                LocalSave.SetIntArray(MUSTBUYSAVE_KEY, saveTimes);
            }
            else
            {
                IsMustBuyDay = false;
            }
        }
        else
        {
            IsMustBuyDay = true;
            LocalSave.SetIntArray(MUSTBUYSAVE_KEY, saveTimes);
        }
    }

    public bool CheckIsMustBuy(StoreConfig config)
    {
        int remainNum = 0;
        if (!TryGetIsSellOut(config, out remainNum) && IsMustBuyDay)
        {
            return true;
        }
        return false;
    }

    /// <summary>
    /// 新灵宠坐骑上架红点
    /// </summary>
    public void UpdatePetAndMountPutAwayRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;

        List<StoreData> storelist = TryGetStoreDatas(StoreFunc.BindStore);
        if (storelist == null) return;

        for (int i = 0; i < storelist.Count; i++)
        {
            var storeData = storelist[i];
            ItemConfig itemConfig = ItemConfig.Get(storeData.storeConfig.ItemID);
            int type = 0;
            TryGetRedTypeByShopId(storeData.shopId, out type);
            if (type == 3)
            {
                string key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", storeData.shopId);
                int remainNum = 0;
                switch (itemConfig.Type)
                {
                    case 26:
                    case 41:
                        if (!TryGetIsSellOut(storeData.storeConfig, out remainNum))
                        {
                            if (!PlayerPrefs.HasKey(key))
                            {
                                shopRedDict[storeData.shopId].state = RedPointState.Simple;
                                LocalSave.SetBool(key, true);
                                SetPetAndMountPushData(storeData.shopId);
                            }
                            else
                            {
                                if (LocalSave.GetBool(key))
                                {
                                    shopRedDict[storeData.shopId].state = RedPointState.Simple;
                                }
                                else
                                {
                                    shopRedDict[storeData.shopId].state = RedPointState.None;
                                }

                            }
                        }
                        else
                        {
                            //PlayerPrefs.DeleteKey(key);
                            shopRedDict[storeData.shopId].state = RedPointState.None;
                        }
                        break;
                }
            }
        }

    }

    public void ClearPetAndMountRedpoint(StoreConfig storeConfig)
    {
        ItemConfig itemConfig = ItemConfig.Get(storeConfig.ItemID);
        switch (itemConfig.Type)
        {
            case 26:
            case 41:
                string key = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", storeConfig.ID);
                if (shopRedDict[storeConfig.ID].state == RedPointState.Simple)
                {
                    shopRedDict[storeConfig.ID].state = RedPointState.None;
                    LocalSave.SetBool(key, false);
                }
                break;
        }
    }

    public void ClearAllPetAndMountRedpoint(StoreFunc storeFunc)
    {
        if (storeFuncType == StoreFunc.BindStore && storeFunc != StoreFunc.BindStore)
        {
            foreach (var key in shopRedDict.Keys)
            {
                StoreConfig storeConfig = StoreConfig.Get(key);
                ItemConfig itemConfig = ItemConfig.Get(storeConfig.ItemID);
                switch (itemConfig.Type)
                {
                    case 26:
                    case 41:
                        if (shopRedDict[key].state != RedPointState.None)
                        {
                            string record = StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "ShopId", key);
                            shopRedDict[key].state = RedPointState.None;
                            LocalSave.SetBool(record, false);
                        }
                        break;
                }

            }
        }

    }

    public void CloseRedPoint(StoreConfig storeConfig)
    {
        ClearMustBuyRedpoint(storeConfig);
        ClearPetAndMountRedpoint(storeConfig);
        ClearFairyEquipRedpoint(storeConfig);
    }

    public void CloseAllRedpoint(StoreFunc storeFunc)
    {
        ClearAllPetAndMountRedpoint(storeFunc);
        SwitchFuncTitleClearRedpoint(storeFunc);
    }
    #endregion

    #region 坐骑灵宠推送

    List<int> petAndMountPushlist = new List<int>();
    public int currentPushId { get; private set; }
    public event Action pushRefreshEvent;
    private void SetPetAndMountPushData(int shopId)
    {
        if (!petAndMountPushlist.Contains(shopId))
        {
            petAndMountPushlist.Add(shopId);
        }

        if (currentPushId == 0 || (currentPushId != 0 && currentPushId != shopId))
        {
            currentPushId = shopId;
            if (pushRefreshEvent != null)
            {
                pushRefreshEvent();
            }
        }
        if (!isLogin)
        {
            SetPushPetAndMountWinState();
        }
    }

    private int cacheMapId = 0;
    private void OnStageLoadFinish()
    {
        if (PlayerDatas.Instance.baseData.MapID == cacheMapId)
        {
            return;
        }
        MapConfig curMapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);
        if (curMapConfig == null || curMapConfig.MapFBType != 0)
        {
            SetPushPetAndMountWinState(true, true);
        }
    }

    private void GuidBegin()
    {
        PetAndMountPushWin pushWin = WindowCenter.Instance.Get<PetAndMountPushWin>();
        if (pushWin != null)
        {
            SetPushPetAndMountWinState(true, true);
        }
    }

    private void OnMoveTopPart(bool isMove)
    {
        if (!isLogin)
        {
            SetPushPetAndMountWinState(!isMove);
        }
    }

    private void windowAfterOpen(Window win)
    {
        if (win is FirstTimeRechargeWin)
        {
            SetPushPetAndMountWinState(true, true);
        }
    }

    private void windowAfterClose(Window win)
    {
        if (isLogin) return;

        if (win is MainInterfaceWin)
        {
            SetPushPetAndMountWinState(true);
        }
        else if (win is RoleParticularsWin
            || win is FirstTimeRechargeWin)
        {
            SetPushPetAndMountWinState();
        }
    }

    public void SetPushPetAndMountWinState(bool isMustClose = false, bool isClearData = false)
    {
        if (isClearData)
        {
            ClearPushData();
            WindowCenter.Instance.Close<PetAndMountPushWin>();
            return;
        }

        if (CheckIsShowPush(isMustClose))
        {
            if (!WindowCenter.Instance.IsOpen<PetAndMountPushWin>())
            {
                WindowCenter.Instance.Open<PetAndMountPushWin>();
            }
        }
        else
        {
            WindowCenter.Instance.Close<PetAndMountPushWin>();
        }
    }

    public bool CheckIsShowPush(bool isMustClose = false)
    {
        bool isShow = false;
        if (isMustClose)
        {
            isShow = false;
        }
        else
        {
            MapConfig curMapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);

            if ((curMapConfig == null || curMapConfig.MapFBType != 0)
                || !WindowCenter.Instance.IsOpen<MainInterfaceWin>()
                || NewBieCenter.Instance.inGuiding
                || WindowCenter.Instance.IsOpen<FirstTimeRechargeWin>()
                || currentPushId == 0
                || !ModelCenter.Instance.GetModel<PlayerMainDate>().MainTopPanelShow)
            {
                isShow = false;
            }
            else
            {
                isShow = true;
            }
        }
        return isShow;
    }

    public void ClearPushData()
    {
        currentPushId = 0;
        petAndMountPushlist.Clear();
    }

    public void RemovePetAndMountPush(int shopId)
    {
        if (petAndMountPushlist.Contains(shopId))
        {
            petAndMountPushlist.Remove(shopId);
            currentPushId = GetPrePetAndMountPushId();
            if (pushRefreshEvent != null)
            {
                pushRefreshEvent();
            }
        }
        else
        {
            ClearPushData();
        }
    }

    private int GetPrePetAndMountPushId()
    {
        currentPushId = 0;
        for (int i = petAndMountPushlist.Count - 1; i > -1; i--)
        {
            currentPushId = petAndMountPushlist[i];
            break;
        }
        return currentPushId;
    }

    #endregion

    #region 处理跳转数据
    public int funcOrder { get; private set; }
    public int jumpShopId { get; private set; }
    public void SetJumpModel(StoreFunc storeFunc, int shopId)
    {
        if (shopId == 0) return;

        funcOrder = (int)storeFunc - 1;
        jumpShopId = shopId;
    }

    public void ClearJumpModel()
    {
        funcOrder = -1;
        jumpShopId = 0;
    }


    #endregion
}

public enum StoreFunc
{
    WeekStore = 1, //1：每周限购
    CommonStore = 2, //2：常用道具
    GrowStrongerStore = 3, //3：成长变强
    BindStore = 4,  //4：绑玉商城
    IntegralStore = 5,  //5：积分商城
    BagStore = 6,  //6:随身商店
    RuneStore = 7,  //7：符印商店
    ToolStore = 8, // 道具商店
    MountStoneStore = 9, //坐骑魂石商店
    MountSkillBookStore = 10,//坐骑技能书商店
    XBEquipStore = 11, //寻宝装备商店
    XBRuneStore = 12, //寻宝符印商店
    XBToolStore = 13, //寻宝道具商店
    OSGift = 14,//开服礼包
    OSTimeLimitGift = 15,//限时特惠
    CrossOneVsOneHonor = 17,//荣誉商店
    MysteryStore = 18, //1：神秘商店
    DanDrugStore = 30, //丹药回收商店
}

public enum LocalSaveStoreType
{
    UnionStore, //仙盟商店
}