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

using UnityEngine;
using LitJson;
using System.Collections;

public class BuyShopItemLimit
{
    public uint ItemIndex;
    public int 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;
    }
}

public class StoreModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk, ISwitchAccount
{
    Dictionary<int, List<int>> storeAlchemyStudyItemShopIds = new Dictionary<int, List<int>>();

    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 int fairyStoreJumpShopId = 0;

    int m_SelectClassifyId = 0;
    public int selectSecondType
    {
        get { return m_SelectClassifyId; }
        set
        {
            if (m_SelectClassifyId != value)
            {
                m_SelectClassifyId = value;
                if (selectClassifyRefresh != null)
                {
                    selectClassifyRefresh();
                }
            }
        }
    }

    public event Action selectClassifyRefresh;
    public event Action mysteryShopRefreshEvent;

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

    private bool isUpdatePlayerLv;

    //排行榜活动的商店
    public int rankActStore_MoneyType;
    public int rankActStore_StoreType;
    public Operation rankActStore_ActType;

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

        //MainPositionTween.switchFunctionStateEvent += OnMoveTopPart;
        alchemyModel.alchemyStateRefresh += AlchemyStateRefresh;
    }

    public void OnBeforePlayerDataInitialize()
    {
        isUpdatePlayerLv = false;
        IsMustBuyDay = false;
        isLogin = true;
        sortStoreSecondType = true;
        ClearJump();
        //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;
        PlayerDatas.Instance.playerDataRefreshEvent -= RefreshPlayerData;
        TimeMgr.Instance.OnHourEvent -= RefreshServerHour;
        GlobalTimeEvent.Instance.secondEvent -= UpdateSecond;
        //NewBieCenter.Instance.guideBeginEvent -= GuidBegin;
        shopItemlimitDict.Clear();
        petAndMountPushlist.Clear();
        ClearPushData();
        tagTowerModel = null;
        storeFuncType = StoreFunc.DayStore;
        //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");
        buyItemCheckDict.Clear();
    }

    public void OnPlayerLoginOk()
    {
        PlayerDatas.Instance.fairyData.OnRefreshFairyInfo += RefreshFamilyLv;
        PlayerDatas.Instance.fairyData.OnRefreshFairyMine += RefreshServerHour;
        FuncOpen.Instance.OnFuncStateChangeEvent += FuncStateChange;
        PlayerDatas.Instance.playerDataRefreshEvent += 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;
        UpdateShowStore();
        SetIsMustBuyDay();
        ControllerRedPoint();
        UpdateFreeShopRedpoint();
        UpdateCanBuyRedpoint();
        UpdateMustBuyRedpoint();
        UpdatePetAndMountPutAwayRedpoint();
        UpdateAlchemyStudyItemRedpoint();
        UpdateDailyRedpoinit();
        isLogin = false;
    }

    public void OnSwitchAccount()
    {
        isShowMysteryRefreshHint = true;
    }

    public override void UnInit()
    {
        //MainPositionTween.switchFunctionStateEvent -= OnMoveTopPart;
        alchemyModel.alchemyStateRefresh -= AlchemyStateRefresh;
    }

    private void AlchemyStateRefresh()
    {
        UpdateAlchemyStudyItemRedpoint();
    }

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

            if (!string.IsNullOrEmpty(storeRedRules.Numerical3))
            {
                var json = JsonMapper.ToObject(storeRedRules.Numerical3);
                foreach (var typeKey in json.Keys)
                {
                    var type = int.Parse(typeKey);
                    storeAlchemyStudyItemShopIds.Add(type,
                        new List<int>(JsonMapper.ToObject<int[]>(json[typeKey].ToJson())));
                }
            }
        }
    }

    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;

        return sort1.CompareTo(sort2);
    }

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

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


    // 新规则分二级标签，此函数保留，另增加UpdateShowStoreEx函数
    public void UpdateShowStore()
    {
        showStoreTypeDict.Clear();
        int playeLv = PlayerDatas.Instance.baseData.LV;
        //int vipLevel = PlayerDatas.Instance.baseData.VIPLv;
        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.LVSee ? 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);
            }
        }
        UpdateShowStoreEx();
    }

    // 商城分二级标签
    public void UpdateShowStoreEx()
    {
        sortStoreSecondType = true;
        showStoreSecondTypeDict.Clear();
        foreach (var type in showStoreTypeDict.Keys)
        {
            if (!showStoreSecondTypeDict.ContainsKey(type))
                showStoreSecondTypeDict[type] = new Dictionary<int, List<StoreData>>();

            foreach (var storeData in showStoreTypeDict[type])
            {

                foreach (var secondType in storeData.storeConfig.SecondType)
                {
                    if (!showStoreSecondTypeDict[type].ContainsKey(secondType))
                        showStoreSecondTypeDict[type][secondType] = new List<StoreData>();

                    showStoreSecondTypeDict[type][secondType].Add(storeData);
                }

            }
        }

    }

    bool sortStoreSecondType = true;

    public void SortStoreSecondType()
    {
        //ArrayList lst = new ArrayList(showStoreSecondTypeDict.Keys);
        if (!sortStoreSecondType)
            return;

        foreach (var type in showStoreSecondTypeDict.Keys)
        {
            foreach (var secondType in showStoreSecondTypeDict[type].Keys)
            {
                var storeList = showStoreSecondTypeDict[type][secondType];
                storeList.Sort(CompareSecondShop);
            }
        }

        sortStoreSecondType = false;
    }

    private bool IsSellOut(StoreData storeData)
    {
        int remainNum = 0;
        if (TryGetIsSellOut(storeData.storeConfig, out remainNum))
            return true;

        if (storeData.storeConfig.TheOnlyShop == 1 && CheckTheOnlyShopSellOut(storeData.shopId))
            return true;

        return false;
    }

    private int CompareSecondShop(StoreData start, StoreData end)
    {
        bool isSellOut1 = IsSellOut(start);
        bool isSellOut2 = IsSellOut(end);

        if (isSellOut1 != isSellOut2)
            return isSellOut1.CompareTo(isSellOut2);
        int sort1 = start.storeConfig.ShopSort;
        int sort2 = end.storeConfig.ShopSort;

        return sort1.CompareTo(sort2);
    }

    /// <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))
        {
            results.AddRange(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 List<StoreData> TryGetStoreDatasBySecondType(int type, int secondType)
    {
        if (!showStoreSecondTypeDict.ContainsKey(type))
            return null;

        if (!showStoreSecondTypeDict[type].ContainsKey(secondType))
            return null;

        SortStoreSecondType();
        return showStoreSecondTypeDict[type][secondType];
    }

    // 获得二级标签的第一个标签类型
    public int GetFirstStoreSecondType(int type, bool jump = true)
    {
        if (jump && jumpToItemId != 0)
        {
            if (selectSecondType == 0) selectSecondType = 1;
            return selectSecondType;
        }
        if (!showStoreSecondTypeDict.ContainsKey(type))
            return 1;

        ArrayList sortList = new ArrayList(showStoreSecondTypeDict[type].Keys);
        sortList.Sort();
        return (int)sortList[0];
    }

    // 获得二级标签的第一个标签类型
    public ArrayList GetStoreSecondTypeList(int type)
    {
        if (!showStoreSecondTypeDict.ContainsKey(type))
            return null;

        ArrayList sortList = new ArrayList(showStoreSecondTypeDict[type].Keys);
        sortList.Sort();
        return sortList;
    }

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

    /// <summary>
    /// 
    /// </summary>
    /// <param name="config"></param>
    /// <param name="canBuyCnt"> 可购买上限</param>
    /// <param name="addBuyCnt"> 下一级VIP增加的可购买次数</param>
    /// <returns></returns>
    public bool TryGetLimitBuy(StoreConfig config, out int canBuyCnt, out int addBuyCnt)
    {
        canBuyCnt = 0;
        addBuyCnt = 0;
        if (config == null) return false;

        int[] canBuyNums = config.GoumaiNumber;
        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()
    {
        if (GeneralDefine.mysteryShopRefreshInterval == 0)
        {
            return "";
        }
        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;
    }

    int refreshTime = 0;
    private void UpdateSecond()
    {
        if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store)) return;
        if (isUpdatePlayerLv)
        {
            UpdatePlayerLv();
            isUpdatePlayerLv = false;
        }
    }

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

    private void RefreshPlayerData(PlayerDataType type)
    {
        if (type == PlayerDataType.VIPLv && !isLogin)
        {
            UpdateShowStore();
        }

        switch (type)
        {
            case PlayerDataType.LV:
                isUpdatePlayerLv = true;
                break;
            case PlayerDataType.VIPLv:
            case PlayerDataType.Gold:
            case PlayerDataType.GoldPaper:
                UpdateFreeShopRedpoint();
                UpdateCanBuyRedpoint();
                UpdateAlchemyStudyItemRedpoint();
                UpdateDailyRedpoinit();
                break;
            case PlayerDataType.UnionLiven:
                UpdateAlchemyStudyItemRedpoint(8);
                UpdateDailyRedpoinit();
                break;
            case PlayerDataType.FBHelpPoint:
                UpdateFreeShopRedpoint();
                UpdateCanBuyRedpoint();
                UpdateAlchemyStudyItemRedpoint();
                break;
        }
    }

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

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

        UpdateAlchemyStudyItemRedpoint(8);
        UpdateDailyRedpoinit();
    }

    public event Action RefreshBuyShopLimitEvent;

    public StoreFunc storeFuncType = StoreFunc.DayStore;
    public int jumpStoreFuncType { get; set; }
    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 = (int)buylimit.DayBuyCntList[i].BuyCnt;
                    shopItemLimit.isReset = buylimit.DayBuyCntList[i].IsReset;
                    shopItemlimitDict.Add(shopItemLimit.ItemIndex, shopItemLimit);
                }
                else
                {
                    shopItemlimitDict[buylimit.DayBuyCntList[i].ItemIndex].BuyCnt = (int)buylimit.DayBuyCntList[i].BuyCnt;
                    shopItemlimitDict[buylimit.DayBuyCntList[i].ItemIndex].isReset = buylimit.DayBuyCntList[i].IsReset;
                }
            }

        }

        if (!isLogin)
        {
            sortStoreSecondType = true;
            UpdateShowStore();
            UpdateFreeShopRedpoint();
            UpdateCanBuyRedpoint();
            UpdateMustBuyRedpoint();
            UpdatePetAndMountPutAwayRedpoint();
            UpdateAlchemyStudyItemRedpoint();
            UpdateDailyRedpoinit();
        }
        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;
    }

    //和GetShopItemlistEx 一样 获取商店物品列表，只是返回类型不同
    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;
    }

    //和GetShopItemlistByIndex 一样 获取商店物品列表，只是返回类型不同
    public List<int[]> GetShopItemlistEx(StoreConfig storeConfig)
    {
        if (storeConfig == null) return null;

        List<int[]> shopItemlist = new List<int[]>();
        if (storeConfig.ItemID != 0)
        {
            int replaceId = GetReplaceId(storeConfig.ID, storeConfig.ItemID);
            shopItemlist.Add(new int[] { replaceId, storeConfig.ItemCnt, 0 });
        }
        var extraItem = JsonMapper.ToObject<int[][]>(storeConfig.ItemListEx);
        for (int i = 0; i < extraItem.Length; i++)
        {
            shopItemlist.Add(extraItem[i]);
        }
        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)
    {
        int itemId = GetReplaceId(shopInfo.ID, shopInfo.ItemID);
        ItemTipUtility.ShowGood(shopInfo.ID, itemId);
    }

    public int BuyCnt { get; private set; }
    public void SetBuyCnt(int buyCnt)
    {
        BuyCnt = 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))
        {
            var vipLv = PlayerDatas.Instance.baseData.VIPLv;
            var itemMinLv = model.VIPLV[0];
            if (vipLv < itemMinLv)
            {
                SysNotifyMgr.Instance.ShowTip("VIPNotEnough", itemMinLv);
            }
            else
            {
                CA310_tagCMBuyItem buyShop = new CA310_tagCMBuyItem();
                buyShop.BuyItemIndex = (ushort)model.ID;
                buyShop.BuyCount = (uint)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;
            }
        }

    }

    //仙玉购买物品的二次确认框，一级货币只有仙玉 默认为仙玉即可
    Dictionary<int, bool> buyItemCheckDict = new Dictionary<int, bool>();
    //type 对应枚举 BuyStoreItemCheckType 方便记忆
    public void SendBuyShopItemWithPopCheck(StoreConfig model, int count, int type = 0)
    {
        if (model.MoneyNumber == 0)
        {
            //免费的
            SendBuyShopItem(model, count);
            return;
        }

        if (buyItemCheckDict.ContainsKey(type) && buyItemCheckDict[type])
        {
            SendBuyShopItem(model, count);
            return;
        }

        ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), Language.Get("OSTimeLimitGiftConfirm", model.MoneyNumber),
        Language.Get("ConfirmCancel102"), (Action<bool, bool>)((bool isOk, bool isToggle) =>
        {
            if (isOk)
            {
                SendBuyShopItem(model, count);
                buyItemCheckDict[type] = isToggle;
            }
            
        }));
    }

    //花仙玉购买的二次确认框(本次登录) 默认提示 MysticalQG104	是否花费<color=#109d06>{0}</color>仙玉进行购买？
    //type 对应枚举 BuyStoreItemCheckType 方便记忆
    public void UseMoneyCheck(int money, Action func, int type = 0, string tip = "MysticalQG104", string fullTip = "")
    {
        if (money == 0)
        {
            //免费的
            func?.Invoke();
            return;
        }

        if (buyItemCheckDict.ContainsKey(type) && buyItemCheckDict[type])
        {
            func?.Invoke();
            return;
        }

        ConfirmCancel.ToggleConfirmCancel(Language.Get("Mail101"), fullTip == "" ? Language.Get(tip, money) : fullTip,
            Language.Get("ConfirmCancel102"), (bool isOk, bool isToggle) =>
            {
                if (isOk)
                {
                    func?.Invoke();
                    buyItemCheckDict[type] = isToggle;
                }

            });
    }



    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 funcOrder { get; private set; }
    public int jumpToItemId { get; set; }

    /// <summary>
    /// 会先清之前的跳转，调用者要注意 ClearJump
    /// </summary>
    /// <param name="itemId"></param>
    public void SetJumpToModel(int itemId)
    {
        ClearJump();
        jumpToItemId = itemId;
    }

    public void ClearJump()
    {
        funcOrder = -1;
        jumpToItemId = 0;
    }

    public void SetWinOrder(int order)
    {
        funcOrder = order;
    }

    public void OpenStoreWin(bool forceSync = false, int functionOrder = 0, bool useJump = false)
    {
        if (useJump && funcOrder != -1)
        {
            WindowCenter.Instance.Open<StoreWin>(forceSync, funcOrder);
        }
        else
        { 
            ClearJump();
            WindowCenter.Instance.Open<StoreWin>(forceSync, functionOrder);
        }
    }

    public event Action StoreFuncOpenAct;

    private void FuncStateChange(int funcId)
    {
        switch ((FuncOpenEnum)funcId)
        {
            case FuncOpenEnum.Store:
                if (StoreFuncOpenAct != null)
                {
                    StoreFuncOpenAct();
                }
                UpdateFreeShopRedpoint();
                UpdateCanBuyRedpoint();
                UpdateMustBuyRedpoint();
                UpdatePetAndMountPutAwayRedpoint();
                UpdateAlchemyStudyItemRedpoint();
                UpdateDailyRedpoinit();
                break;
            case FuncOpenEnum.BlastFurnace:
                ControllerRedPoint();
                UpdateAlchemyStudyItemRedpoint();
                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;
        }
    }

    public bool IsRequireDailyRedRemind(int shopId)
    {
        var config = StoreConfig.Get(shopId);
        if (config == null)
        {
            return false;
        }
        var key = StringUtility.Contact("Store_", config.ShopType, "_", "Daily", shopId);
        var array = LocalSave.GetIntArray(key);
        if (array != null && array.Length == 2)
        {
            if (array[0] < TimeUtility.Day - 1)
            {
                return true;
            }
            else if (array[0] == TimeUtility.Day - 1)
            {
                return array[1] < 5 || TimeUtility.Hour >= 5;
            }
            else if (array[0] == TimeUtility.Day)
            {
                return array[1] < 5 && TimeUtility.Hour >= 5;
            }
        }
        return true;
    }

    public void SetDailyRedRedmind(int shopId)
    {
        var config = StoreConfig.Get(shopId);
        if (config == null)
        {
            return;
        }
        var key = StringUtility.Contact("Store_", config.ShopType, "_", "Daily", shopId);
        LocalSave.SetIntArray(key, new int[2] { TimeUtility.Day, TimeUtility.Hour });
        UpdateDailyRedpoinit();
    }
    #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)
    {
        fairyStoreRemindRedpoint.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))
            {
                fairyStoreRemindRedpoint.state = RedPointState.Simple;
                return;
            }

            if (CheckIsNewMonth())
            {
                fairyStoreRemindRedpoint.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 const int StoreFunc8_RedKey = 2208;
    public const int FairyStoreRemind_RedKey = 107010601;
    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 Redpoint storeFunc8Point = new Redpoint(MainRedDot.FAIRYStore_REDPOINT_KEY3, StoreFunc8_RedKey);
    public Redpoint fairyStoreRemindRedpoint = new Redpoint(MainRedDot.FAIRYStore_REDPOINT_KEY3, FairyStoreRemind_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;
                case 8:
                    redKey = StoreFunc8_RedKey * 10000 + storeConfig.ID;
                    redpoint = new Redpoint(StoreFunc8_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 (shopRedDict.ContainsKey(storeConfig.ID))
                    {
                        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 (shopRedDict.ContainsKey(storeConfig.ID))
                    {
                        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;
                        }

                    }
                }
            }

        }
    }

    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 (shopRedDict.ContainsKey(storeConfig.ID))
                    {
                        if (CheckIsMustBuy(storeConfig))
                        {
                            shopRedDict[storeConfig.ID].state = RedPointState.Simple;
                        }
                        else
                        {
                            shopRedDict[storeConfig.ID].state = RedPointState.None;
                        }
                    }
                }
            }

        }
    }

    public void UpdateDailyRedpoinit()
    {
        if (storeRedRuleDict.ContainsKey(6))
        {
            var shopIds = storeRedRuleDict[6];
            var count = 0;
            foreach (var shopId in shopIds)
            {
                var redable = false;
                var config = StoreConfig.Get(shopId);
                switch (config.ShopType)
                {
                    case 8:
                        if (TryGetIsSellOut(config, out count))
                        {
                            break;
                        }
                        if (PlayerDatas.Instance.fairyData.fairy == null)
                        {
                            break;
                        }
                        if (config.VIPLV.Length > 0
                            && PlayerDatas.Instance.baseData.VIPLv < config.VIPLV[0])
                        {
                            break;
                        }
                        if (PlayerDatas.Instance.fairyData.fairy.FamilyLV < config.LimitValue)
                        {
                            break;
                        }
                        if (!MoneyIsEnough(config.MoneyType, (ulong)config.MoneyNumber))
                        {
                            break;
                        }
                        redable = IsRequireDailyRedRemind(shopId);
                        break;
                }

                if (shopRedDict.ContainsKey(shopId))
                {
                    shopRedDict[shopId].state = redable ? RedPointState.Simple : RedPointState.None;
                }
            }
        }
    }

    public void UpdateAlchemyStudyItemRedpoint()
    {
        foreach (var shopType in storeAlchemyStudyItemShopIds.Keys)
        {
            UpdateAlchemyStudyItemRedpoint(shopType);
        }
    }

    public void UpdateAlchemyStudyItemRedpoint(int shopType)
    {
        if (!storeAlchemyStudyItemShopIds.ContainsKey(shopType))
        {
            return;
        }
        var shopIds = storeAlchemyStudyItemShopIds[shopType];
        if (showStoreTypeDict.ContainsKey(shopType))
        {
            var shopDatas = showStoreTypeDict[shopType];
            foreach (var shopId in shopIds)
            {
                bool redable = false;

                if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.Store))
                {
                    var shopData = shopDatas.Find((x) =>
                    {
                        return x.shopId == shopId;
                    });
                    if (shopData != null)
                    {
                        var storeConfig = shopData.storeConfig;
                        var count = 0;
                        switch (shopType)
                        {
                            case 5:
                                if (!TryGetIsSellOut(storeConfig, out count))
                                {
                                    if (UIHelper.GetMoneyCnt(storeConfig.MoneyType) >= (ulong)storeConfig.MoneyNumber)
                                    {
                                        redable = IsSatisfyStudyAlchemy(storeConfig.ItemID);
                                    }
                                }
                                break;
                            case 8:
                                if (TryGetIsSellOut(storeConfig, out count))
                                {
                                    break;
                                }
                                if (PlayerDatas.Instance.baseData.FamilyId == 0
                                    || PlayerDatas.Instance.fairyData.fairy == null)
                                {
                                    break;
                                }
                                if (storeConfig.VIPLV.Length > 0
                                    && PlayerDatas.Instance.baseData.VIPLv < storeConfig.VIPLV[0])
                                {
                                    break;
                                }
                                if (PlayerDatas.Instance.fairyData.fairy.FamilyLV < storeConfig.LimitValue)
                                {
                                    break;
                                }
                                if (!MoneyIsEnough(storeConfig.MoneyType, (ulong)storeConfig.MoneyNumber))
                                {
                                    break;
                                }
                                redable = IsSatisfyStudyAlchemy(storeConfig.ItemID);
                                break;
                        }
                    }
                }

                if (shopRedDict.ContainsKey(shopId))
                {
                    shopRedDict[shopId].state = redable ? RedPointState.Simple : RedPointState.None;
                }
            }
        }
    }

    bool IsSatisfyStudyAlchemy(int itemId)
    {
        var alchemyModel = ModelCenter.Instance.GetModel<AlchemyModel>();
        var alchemyId = 0;
        if (alchemyModel.TryGetAlchemyByStudyMaterial(itemId, out alchemyId))
        {
            if (!alchemyModel.IsGraspRecipe(alchemyId))
            {
                var error = 0;
                alchemyModel.TryLearn(alchemyId, out error);
                return error == 1;
            }
        }
        return false;
    }

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

    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()
    {
        return;
        //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))
        //                    {
        //                        if (shopRedDict.ContainsKey(storeData.shopId))
        //                        {
        //                            shopRedDict[storeData.shopId].state = RedPointState.Simple;
        //                            LocalSave.SetBool(key, true);
        //                        }
        //                        SetPetAndMountPushData(storeData.shopId);
        //                    }
        //                    else
        //                    {
        //                        if (shopRedDict.ContainsKey(storeData.shopId))
        //                        {
        //                            if (LocalSave.GetBool(key))
        //                            {
        //                                shopRedDict[storeData.shopId].state = RedPointState.Simple;
        //                            }
        //                            else
        //                            {
        //                                shopRedDict[storeData.shopId].state = RedPointState.None;
        //                            }
        //                        }

        //                    }
        //                }
        //                else
        //                {
        //                    //PlayerPrefs.DeleteKey(key);
        //                    if (shopRedDict.ContainsKey(storeData.shopId))
        //                    {
        //                        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.ContainsKey(storeConfig.ID) && 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.ContainsKey(key) && 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);
    }

    public void CloseAllRedpoint(StoreFunc storeFunc)
    {
        ClearAllPetAndMountRedpoint(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 immedidately)
    //{
    //    if (!isLogin)
    //    {
    //        SetPushPetAndMountWinState(!MainPositionTween.isDefaultState);
    //    }
    //}

    //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)
    //{
    //    return;
    //    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
                || MainPositionTween.rightTopState != MainPositionTween.RightTopState.Function)
            {
                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


}

public enum StoreFunc
{
    DayStore = 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：神秘商店
    default1,
    default2, //时间类活动 - 如boss凭证的商店 20
    default3,
    default4,
    default5,
    default6,
    default7,
    default8,
    default9,
    default10,
    QCTrainActStore = 306, //骑宠养成活动商店
    CelestialPalaceStore = 308, //仙宫商店（天道阁）
}

public enum LocalSaveStoreType
{
    UnionStore, //仙盟商店
                //后续IL开发添加预设
    default1,
    default2,
    default3,
    default4,
    default5,
    default6,
    default7,
    default8,
    default9,
    default10,
}