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

using LitJson;
using UnityEngine;
using System.Collections;

namespace vnxbqy.UI
{

    public class HappyXBModel : Model, IBeforePlayerDataInitialize, IAfterPlayerDataInitialize, IPlayerLoginOk
    {
        private Dictionary<string, XBGetItemConfig> xbGetItemDict = new Dictionary<string, XBGetItemConfig>();
        private Dictionary<int, List<XBGetItemConfig>> xbTypeItemDict = new Dictionary<int, List<XBGetItemConfig>>();
        private Dictionary<string, Dictionary<int, XBGetItem>> jobXBItemDict = new Dictionary<string, Dictionary<int, XBGetItem>>();
        private Dictionary<int, XBFuncSet> xbFuncSetDict = new Dictionary<int, XBFuncSet>();
        public Dictionary<int, int> XBCostTypeDict = new Dictionary<int, int>();
        public HappXBTitle title = HappXBTitle.Best;
        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        StoreModel _storeModel;
        StoreModel m_storeModel
        {
            get { return _storeModel ?? (_storeModel = ModelCenter.Instance.GetModel<StoreModel>()); }
        }

        public string USETOOLXBKey = string.Empty;
        public static string HAPPYXBITEMKEY;
        public List<ArrayList> XBNotifyParms = new List<ArrayList>();
        public bool isXBCoolTime { get; set; }

        public bool isJumpBestXB { get; set; }
        public bool isJumpRuneXB { get; set; }
        public bool isJumpGubaoXB { get; set; }
        public bool isJumpGatherSoulXB { get; set; } //聚魂寻宝：是否跳过动画

        public override void Init()
        {
            isJumpBestXB = false;
            isJumpRuneXB = false;
            isJumpGubaoXB = false;
            isJumpGatherSoulXB = false;
            xbGetItemDict.Clear();
            xbTypeItemDict.Clear();
            xbFuncSetDict.Clear();
            List<XBGetItemConfig> list = XBGetItemConfig.GetValues();
            for (int i = 0; i < list.Count; i++)
            {
                string key = StringUtility.Contact(list[i].TreasureType, list[i].MinLV);
                if (!xbGetItemDict.ContainsKey(key))
                {
                    xbGetItemDict.Add(key, list[i]);
                }

                if (!xbTypeItemDict.ContainsKey(list[i].TreasureType))
                {
                    List<XBGetItemConfig> typeItemlist = new List<XBGetItemConfig>();
                    typeItemlist.Add(list[i]);
                    xbTypeItemDict.Add(list[i].TreasureType, typeItemlist);
                }
                else
                {
                    xbTypeItemDict[list[i].TreasureType].Add(list[i]);
                }
            }

            SetXBFuncDict(1);
            SetXBFuncDict(2);
            var treasureIDArr = JsonMapper.ToObject<int[]>(FuncConfigConfig.Get("TreasureLuckyDraw").Numerical1);
            for (int i = 0; i < treasureIDArr.Length; i++)
            {
                int type = XBGetItemConfig.Get(treasureIDArr[i]).TreasureType;
                SetXBFuncDict(type);
            }
            SetXBFuncDict(GatheringSoulModel.xbType);


            SysNotifyMgr.Instance.RegisterCondition("HappyXB", SatisfyNotifyCondition);

            XBCostTypeDict.Clear();

            XBCostTypeDict[(int)HappXBTitle.Best] = TreasureSetConfig.Get(1).CostMoneyType;
            XBCostTypeDict[(int)HappXBTitle.Rune] = TreasureSetConfig.Get(2).CostMoneyType;
            for (int i = 0; i < treasureIDArr.Length; i++)
            {
                int type = XBGetItemConfig.Get(treasureIDArr[i]).TreasureType;
                XBCostTypeDict[(int)HappXBTitle.Gubao1 + i] = TreasureSetConfig.Get(type).CostMoneyType;
            }
            XBCostTypeDict[(int)HappXBTitle.GatherSoul] = TreasureSetConfig.Get(GatheringSoulModel.xbType).CostMoneyType;
        }



        public void OnBeforePlayerDataInitialize()
        {
            PlayerDatas.Instance.playerDataRefreshEvent -= RefreshStoreScore;
            FuncOpen.Instance.OnFuncStateChangeEvent -= UpdateFuncState;
            playerPack.refreshItemCountEvent -= RefreshXBTool;
            isXBCoolTime = false;
            XBNotifyParms.Clear();
            xbTypeInfoDict.Clear();
        }
        public void OnAfterPlayerDataInitialize()
        {
            SetXBGetItemModel();
        }
        public void OnPlayerLoginOk()
        {
            int playerId = (int)PlayerDatas.Instance.baseData.PlayerID;
            HAPPYXBITEMKEY = StringUtility.Contact(playerId, "HappyXBItemTime");
            USETOOLXBKey = StringUtility.Contact(playerId, "UseToolXB");
            XBWarehouseRedPoint();
            PlayerDatas.Instance.playerDataRefreshEvent += RefreshStoreScore;
            playerPack.refreshItemCountEvent += RefreshXBTool;
            FuncOpen.Instance.OnFuncStateChangeEvent += UpdateFuncState;
        }

        public override void UnInit()
        {

        }

        /// <summary>
        /// 检测自身玩家是否需要信息提示
        /// </summary>
        /// <param name="key"></param>
        /// <param name="paramArray"></param>
        /// <returns></returns>
        private bool SatisfyNotifyCondition(string key, ArrayList paramArray)
        {
            switch (title)
            {
                case HappXBTitle.Best:
                    if (isJumpBestXB)
                    {
                        return true;
                    }
                    break;
                case HappXBTitle.Rune:
                    if (isJumpRuneXB)
                    {
                        return true;
                    }
                    break;
                case HappXBTitle.Gubao1:
                case HappXBTitle.Gubao2:
                case HappXBTitle.Gubao3:
                case HappXBTitle.Gubao4:
                    if (isJumpGubaoXB)
                    {
                        return true;
                    }
                    break;
                case HappXBTitle.GatherSoul:
                    if (isJumpGatherSoulXB)
                    {
                        return true;
                    }
                    break;
            }

            XBNotifyParms.Add(new ArrayList(paramArray));
            if (paramArray != null && paramArray.Count > 0 &&
                paramArray[0].Equals(UIHelper.ServerStringTrim(PlayerDatas.Instance.baseData.PlayerName)))
            {
                return false;
            }
            return true;
        }

        public void GetNotifyResult(int itemId, int itemCount)
        {
            int notifyIndex = 0;
            if (CheckNotifyItemByIdAndCnt(itemId, itemCount, out notifyIndex))
            {
                SysNotifyMgr.Instance.ShowTip("HappyXB", XBNotifyParms[notifyIndex].ToArray());
            }
        }

        private bool CheckNotifyItemByIdAndCnt(int itemId, int itemCnt, out int notifyIndex)
        {
            notifyIndex = 0;
            for (int i = 0; i < XBNotifyParms.Count; i++)
            {
                if (XBNotifyParms[i] != null && XBNotifyParms[i].Count > 3)
                {
                    int notifyItemId = 0;
                    int.TryParse(XBNotifyParms[i][1].ToString(), out notifyItemId);
                    int notifyItemCnt = 0;
                    int.TryParse(XBNotifyParms[i][3].ToString(), out notifyItemCnt);
                    if (notifyItemId == itemId && notifyItemCnt == itemCnt)
                    {
                        notifyIndex = i;
                        return true;
                    }
                }
            }
            return false;
        }

        private void SetXBFuncDict(int type)
        {
            var treasureSetCfg = TreasureSetConfig.Get(type);
            if (!xbFuncSetDict.ContainsKey(type))
            {
                XBFuncSet funcSet = new XBFuncSet();
                funcSet.xbType = type;
                funcSet.xbNums = treasureSetCfg.TreasureCountList;

                 funcSet.xbPrices = treasureSetCfg.CostMoneyList;

                funcSet.costToolIds = new int[] { treasureSetCfg.CostItemID, treasureSetCfg.CostItemID };
                funcSet.costToolNums = treasureSetCfg.CostItemCountList;
                funcSet.dailyFreeCount = treasureSetCfg.DailyFreeCount;
                funcSet.xbScores = new int[] { treasureSetCfg.AwardMoneyValue, treasureSetCfg.AwardMoneyValue * treasureSetCfg.TreasureCountList[1] };

                xbFuncSetDict.Add(funcSet.xbType, funcSet);
            }
        }

        public XBFuncSet GetXBFuncSet(int type)
        {
            XBFuncSet funcSet = null;
            xbFuncSetDict.TryGetValue(type, out funcSet);
            return funcSet;
        }

        //默认优先使用道具寻宝
        public bool IsUseToolXB()
        {
            return true;
            //if (!PlayerPrefs.HasKey(USETOOLXBKey))
            //{
            //    LocalSave.SetBool(USETOOLXBKey, true);
            //    return true;
            //}
            //else
            //{
            //    return LocalSave.GetBool(USETOOLXBKey);
            //}
        }

        public void SetUseToolXB(bool isToolXB)
        {
            //LocalSave.SetBool(USETOOLXBKey, isToolXB);
        }

        private void SetXBGetItemModel()
        {
            jobXBItemDict.Clear();
            Dictionary<int, XBGetItem> getItemDict = new Dictionary<int, XBGetItem>();
            Dictionary<int, List<int>> jobItemDict = new Dictionary<int, List<int>>();
            int playerJob = PlayerDatas.Instance.baseData.Job;
            foreach (var key in xbGetItemDict.Keys)
            {

                getItemDict.Clear();
                jobItemDict.Clear();
                Dictionary<int, XBGetItem> jobGetItemDict = new Dictionary<int, XBGetItem>();
                XBGetItemConfig getItemConfig = xbGetItemDict[key];
                jobXBItemDict.Add(key, jobGetItemDict);
                JsonData getItemJson = JsonMapper.ToObject(getItemConfig.GridItemInfo);
                foreach (var grid in getItemJson.Keys)
                {
                    int id = int.Parse(getItemJson[grid][0].ToString());
                    int count = int.Parse(getItemJson[grid][1].ToString());
                    XBGetItem getItem = new XBGetItem();
                    getItem.SetModel(int.Parse(grid), id, count);
                    getItemDict.Add(getItem.gridIndex, getItem);
                }
                JsonData jobReplaceJson = JsonMapper.ToObject(getItemConfig.JobItemList);
                if (jobReplaceJson.IsArray)
                {
                    for (int i = 0; i < jobReplaceJson.Count; i++)
                    {
                        List<int> itemIdlist = new List<int>();
                        jobItemDict.Add(i, itemIdlist);
                        if (jobReplaceJson[i].IsArray)
                        {
                            for (int j = 0; j < jobReplaceJson[i].Count; j++)
                            {
                                int id = int.Parse(jobReplaceJson[i][j].ToString());
                                itemIdlist.Add(id);
                            }
                        }
                    }
                }

                foreach (var model in getItemDict.Values)
                {
                    ItemConfig itemConfig = ItemConfig.Get(model.itemId);
                    if (itemConfig.JobLimit == 0)
                    {
                        jobGetItemDict.Add(model.gridIndex, model);
                    }
                    else
                    {
                        bool isReplace = false;
                        foreach (var list in jobItemDict.Values)
                        {
                            if (list.Contains(model.itemId))
                            {
                                for (int i = 0; i < list.Count; i++)
                                {
                                    int equipJob = int.Parse(list[i].ToString().Substring(0, 1));
                                    if (playerJob == equipJob)
                                    {
                                        isReplace = true;
                                        XBGetItem getItem = new XBGetItem();
                                        getItem.SetModel(model.gridIndex, list[i], model.count);
                                        jobGetItemDict.Add(getItem.gridIndex, getItem);
                                        break;
                                    }
                                }
                                break;
                            }
                        }
                        if (!isReplace)
                        {
                            jobGetItemDict.Add(model.gridIndex, model);
                        }
                    }

                }

            }

        }

        public Dictionary<int, XBGetItem> GetXBGetItemByID(int type)
        {
            int lv = 0;
            List<XBGetItemConfig> configlist = null;
            xbTypeItemDict.TryGetValue(type, out configlist);
            if (configlist != null)
            {
                for (int i = configlist.Count - 1; i > -1; i--)
                {
                    if (PlayerDatas.Instance.baseData.LV >= configlist[i].MinLV)
                    {
                        lv = configlist[i].MinLV;
                        break;
                    }
                }
            }
            string key = StringUtility.Contact(type, lv);
            Dictionary<int, XBGetItem> dict = null;
            jobXBItemDict.TryGetValue(key, out dict);
            return dict;
        }

        public XBGetItemConfig GetXBItemConfigByType(int type)
        {
            int lv = 0;
            List<XBGetItemConfig> configlist = null;
            xbTypeItemDict.TryGetValue(type, out configlist);
            if (configlist != null)
            {
                for (int i = configlist.Count - 1; i > -1; i--)
                {
                    if (PlayerDatas.Instance.baseData.LV >= configlist[i].MinLV)
                    {
                        lv = configlist[i].MinLV;
                        break;
                    }
                }
            }
            XBGetItemConfig xbItemConfig = null;
            string key = StringUtility.Contact(type, lv);
            xbGetItemDict.TryGetValue(key, out xbItemConfig);
            return xbItemConfig;
        }

        #region 处理服务端数据
        public event Action RefreshXBTypeInfoAct;
        public event Action RefreshXBResultAct;
        public int addXBScore { get; private set; }
        public int addXBScoreType { get; private set; } //寻宝积分货币类型
        public int addXBLuckValue { get; private set; }
        private Dictionary<int, XBGetItem> xbResultDict = new Dictionary<int, XBGetItem>();
        public void GetServerXBResult(HA350_tagMCTreasureResult result)
        {
            XBNotifyParms.Clear();
            xbResultDict.Clear();
            addXBScore = result.AddMoneyValue;
            addXBScoreType = result.AddMoneyType;
            addXBLuckValue = result.AddTreasureLuck;
            JsonData resultData = JsonMapper.ToObject(result.TreasureResult);
            if (resultData.IsArray)
            {
                for (int i = 0; i < resultData.Count; i++)
                {
                    if (resultData[i].IsArray)
                    {
                        int index = int.Parse(resultData[i][0].ToString());
                        int itemId = int.Parse(resultData[i][1].ToString());
                        int count = int.Parse(resultData[i][2].ToString());
                        XBGetItem getItem = new XBGetItem();
                        getItem.SetModel(index, itemId, count);
                        if (!xbResultDict.ContainsKey(i))
                        {
                            xbResultDict.Add(i, getItem);
                        }
                        else
                        {
                            xbResultDict[i] = getItem;
                        }
                    }
                }
            }
            SetXBResultRecord();
            isXBCoolTime = false;
            if (RefreshXBResultAct != null)
            {
                RefreshXBResultAct();
            }
        }

        List<string> itemGetTimeArray = new List<string>();
        List<string> getNewItemLoglist = new List<string>();
        List<XBGetItem> xbItemRecordlist = new List<XBGetItem>();
        public void SetXBResultRecord()
        {
            if (PlayerPrefs.HasKey(HAPPYXBITEMKEY))
            {
                itemGetTimeArray = LocalSave.GeStringArray(HappyXBModel.HAPPYXBITEMKEY).ToList();
            }
            else
            {
                itemGetTimeArray.Clear();
            }
            xbItemRecordlist.Clear();
            getNewItemLoglist.Clear();
            xbItemRecordlist.AddRange(GetXBResultlist());
            if (xbItemRecordlist != null)
            {
                int remianLogNum = (itemGetTimeArray.Count + xbItemRecordlist.Count) - 30;
                if (remianLogNum > 0)
                {
                    int startIndex = itemGetTimeArray.Count - remianLogNum;
                    itemGetTimeArray.RemoveRange(startIndex, remianLogNum);
                }
                xbItemRecordlist.Sort(CompareByTime);
                for (int i = 0; i < xbItemRecordlist.Count; i++)
                {
                    string log = Language.Get("HappyXBGetItemTime", xbItemRecordlist[i].createTimeStr, UIHelper.ServerStringTrim(PlayerDatas.Instance.baseData.PlayerName),
                        xbItemRecordlist[i].itemId, xbItemRecordlist[i].count);
                    getNewItemLoglist.Add(log);
                }
                if (getNewItemLoglist.Count > 0)
                {
                    itemGetTimeArray.InsertRange(0, getNewItemLoglist);
                    LocalSave.SetStringArray(HappyXBModel.HAPPYXBITEMKEY, itemGetTimeArray.ToArray());
                }

            }
        }

        public int CompareByTime(XBGetItem start, XBGetItem end)
        {
            DateTime startTime = start.createTime;
            DateTime endTime = end.createTime;
            if (startTime.CompareTo(endTime) != 0) return -startTime.CompareTo(endTime);

            return 0;
        }

        public List<XBGetItem> rangelist = new List<XBGetItem>();
        List<int> index = new List<int>();
        public List<XBGetItem> GetXBResultlist()
        {
            rangelist.Clear();
            index.Clear();
            List<XBGetItem> xbItemlist = xbResultDict.Values.ToList();
            for (int i = 0; i < xbItemlist.Count; i++)
            {
                index.Add(i);
            }
            SetRandomList(xbItemlist);
            return rangelist;
        }

        public void SetRandomList(List<XBGetItem> xbItemlist)
        {
            int currentRandom = UnityEngine.Random.Range(0, index.Count);
            XBGetItem current = xbItemlist[index[currentRandom]];
            if (!rangelist.Contains(current))
            {
                rangelist.Add(current);
                index.Remove(index[currentRandom]);

            }
            if (index.Count > 0)
            {
                SetRandomList(xbItemlist);
            }
        }

        public Dictionary<int, XBGetItem> GetXbResultDict()
        {
            return xbResultDict;
        }

        public void ClearXBRusltData()
        {
            xbResultDict.Clear();
        }

        private Dictionary<int, XBTypeInfo> xbTypeInfoDict = new Dictionary<int, XBTypeInfo>();
        public void GetServerXBInfo(HA351_tagMCTreasureInfo info)
        {
            for (int i = 0; i < info.InfoCount; i++)
            {
                if (!xbTypeInfoDict.ContainsKey(info.TreasuerInfoList[i].TreasureType))
                {
                    XBTypeInfo typeInfo = new XBTypeInfo();
                    typeInfo.xbType = info.TreasuerInfoList[i].TreasureType;
                    typeInfo.luckValue = info.TreasuerInfoList[i].LuckValue;
                    typeInfo.freeCountToday = info.TreasuerInfoList[i].FreeCountToday;
                    typeInfo.treasureCount = (int)info.TreasuerInfoList[i].TreasureCount;
                    xbTypeInfoDict.Add(info.TreasuerInfoList[i].TreasureType, typeInfo);
                }
                else
                {
                    xbTypeInfoDict[info.TreasuerInfoList[i].TreasureType].luckValue = info.TreasuerInfoList[i].LuckValue;
                    xbTypeInfoDict[info.TreasuerInfoList[i].TreasureType].freeCountToday = info.TreasuerInfoList[i].FreeCountToday;
                    xbTypeInfoDict[info.TreasuerInfoList[i].TreasureType].treasureCount = (int)info.TreasuerInfoList[i].TreasureCount;
                }
            }


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

            BestAndRuneXBRedPoint();
        }

        public XBTypeInfo GetXBInfoByType(int type)
        {
            XBTypeInfo typeInfo = null;
            xbTypeInfoDict.TryGetValue(type, out typeInfo);
            return typeInfo;
        }

        /// <summary>
        /// type 1 极品寻宝 2 符印寻宝  index 0 单次寻宝 1 多次寻宝
        ///costType 0-默认仙玉；1-免费次数；2-寻宝道具
        /// </summary>
        /// <param name="type"></param>
        /// <param name="index"></param>
        public event Action<int> StartXBEvent;
        public void SendXBQuest(int type, int index, int costType)
        {
            isXBCoolTime = true;
            CA568_tagCMRequestTreasure treasure = new CA568_tagCMRequestTreasure();
            treasure.TreasureType = (byte)type;
            treasure.TreasureIndex = (byte)index;
            treasure.CostType = (byte)costType;
            GameNetSystem.Instance.SendInfo(treasure);
            if (StartXBEvent != null)
            {
                StartXBEvent(index);
            }
        }

        public void SendPutOutXBItem(PackType curType, PackType targetType, int index, int isAll)
        {
            CA309_tagCMDropItemToOtherPack itemToOtherPack = new CA309_tagCMDropItemToOtherPack();
            itemToOtherPack.SrcBackpack = (byte)curType;
            itemToOtherPack.DesBackPack = (byte)targetType;
            itemToOtherPack.SrcIndex = (ushort)index;
            itemToOtherPack.IsAll = (byte)isAll;
            GameNetSystem.Instance.SendInfo(itemToOtherPack);
        }

        public bool CheckIsEmptyGrid(PackType type, int needGrid = 1)
        {
            switch (type)
            {
                case PackType.Treasure:
                    SinglePack singlePack = playerPack.GetSinglePack(type);
                    if (GeneralDefine.maxXBGridCount - singlePack.GetAllItems().Count < needGrid)
                    {
                        SysNotifyMgr.Instance.ShowTip("XBWarehouseFull");
                        return false;
                    }
                    break;
                case PackType.RunePack:
                    var virtualPackModel = ModelCenter.Instance.GetModel<VirtualPackModel>();
                    if (virtualPackModel.GetPackRemainCount(PackType.RunePack) < needGrid)
                    {
                        SysNotifyMgr.Instance.ShowTip("RuneBagFull");
                        return false;
                    }
                    break;
                case PackType.Item:
                    if (playerPack.GetEmptyGridCount(type) < needGrid)
                    {
                        SysNotifyMgr.Instance.ShowTip("BagFull");
                        return false;
                    }
                    break;
            }
            return true;
        }

        public void SendOneXBQuest(PackType type, int xbType)
        {
            var funcSet = GetXBFuncSet(xbType);
            if (CheckIsEmptyGrid(type))
            {
                if (IsHaveOneXBTool(xbType))
                {
                    SendXBQuest(xbType, 0, 2);
                }
                else
                {
                    int xbOneMoney = funcSet.xbPrices[0];
                    int moneyType = XBCostTypeDict[xbType];
                    if (UIHelper.GetMoneyCnt(moneyType) >= (ulong)xbOneMoney)
                    {
                        SendXBQuest(xbType, 0, 0);
                    }
                    else
                    {
                        //WindowCenter.Instance.Open<RechargeTipWin>();
                        SysNotifyMgr.Instance.ShowTip("LackMoney", moneyType);

                    }
                }
            }
        }

        public void SendXBManyQuest(PackType type, int xbType)
        {
            var funcSet = GetXBFuncSet(xbType);
            if (CheckIsEmptyGrid(type))
            {
                int toolCnt = 0;
                int needToolCnt = 0;
                if (IsHaveManyXBTool(xbType, out toolCnt, out needToolCnt))
                {
                    if (toolCnt >= needToolCnt)
                    {
                        CheckXBManyLimit(0, xbType, 2);
                    }
                    else
                    {
                        CheckXBManyLimit(funcSet.xbPrices[1], xbType, 0);
                    }
                    //needToolCnt = needToolCnt - toolCnt;
                    //int needMoney = needToolCnt * funcSet.xbPrices[0];
                    //if (needMoney > 0)
                    //{
                    //    ItemConfig itemConfig = ItemConfig.Get(funcSet.costToolIds[1]);
                    //    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("HappyXBCostTools", funcSet.costToolNums[1], itemConfig.ItemName, needMoney, needToolCnt), (bool isOk) =>
                    //    {
                    //        if (isOk)
                    //        {
                    //            CheckXBManyLimit(needMoney, xbType,0);
                    //        }
                    //        return;
                    //    });
                    //}
                    //else
                    //{
                    //    CheckXBManyLimit(0, xbType,2);
                    //}

                }
                else
                {
                    CheckXBManyLimit(funcSet.xbPrices[1], xbType, 0);
                }

            }
        }

        public void CheckXBManyLimit(int needMoney, int xbtype, int costType)
        {
            int moneyType = XBCostTypeDict[xbtype];
            if (UIHelper.GetMoneyCnt(moneyType) >= (ulong)needMoney)
            {
                SendXBQuest(xbtype, 1, costType);
            }
            else
            {
                //WindowCenter.Instance.Open<RechargeTipWin>();
                SysNotifyMgr.Instance.ShowTip("LackMoney", moneyType);
            }
        }
        #endregion

        public bool IsHaveFreeXB(int type)
        {
            XBTypeInfo typeInfo = GetXBInfoByType(type);
            if (typeInfo == null)
            {
                typeInfo = new XBTypeInfo()
                {
                    xbType = type,
                    luckValue = 0,
                    freeCountToday = 0,
                    treasureCount = 0,
                };
            }

            //判断是否有免费次数，且免费次数是否用完
            var funcSet = GetXBFuncSet(type);
            return typeInfo.freeCountToday < funcSet.dailyFreeCount;
        }


        public bool CheckIsXBTool(int itemId, int type)
        {
            XBFuncSet funcSet = GetXBFuncSet(type);
            if (funcSet == null) return false;

            if (funcSet.costToolIds.Contains(itemId))
            {
                return true;
            }
            return false;
        }
        public bool IsHaveOneXBTool(int type)
        {
            XBFuncSet funcSet = GetXBFuncSet(type);
            if (funcSet == null) return false;

            int toolCnt = playerPack.GetItemCountByID(PackType.Item, funcSet.costToolIds[0]);
            if (toolCnt >= funcSet.costToolNums[0])
            {
                return true;
            }

            return false;
        }

        public bool IsHaveManyXBTool(int type, out int toolCnt, out int needToolCnt)
        {
            toolCnt = 0;
            needToolCnt = 0;
            XBFuncSet funcSet = GetXBFuncSet(type);
            if (funcSet == null) return false;

            toolCnt = playerPack.GetItemCountByID(PackType.Item, funcSet.costToolIds[1]);
            needToolCnt = funcSet.costToolNums[1];
            if (toolCnt > 0)
            {
                return true;
            }
            return false;
        }




        public event Action<float> RefreshBestXBTimeAct;
        public event Action<float> RefreshRuneXBTimeAct;
        public void RefreshBestXBTime(float time)
        {
            if (RefreshBestXBTimeAct != null)
            {
                RefreshBestXBTimeAct(time);
            }

            if (time <= 0)
            {
                BestAndRuneXBRedPoint();
            }
        }
        public void RefreshRuneXBTime(float time)
        {
            if (RefreshRuneXBTimeAct != null)
            {
                RefreshRuneXBTimeAct(time);
            }

            if (time <= 0)
            {
                BestAndRuneXBRedPoint();
            }
        }

        public event Action<HappXBTitle, int> RefreshAgainXBAct;
        /// <summary>
        /// xbtype 0-单次 1 多次
        /// </summary>
        /// <param name="xBTitle"></param>
        /// <param name="xbType"></param>
        public void SetAgainXBEvent(HappXBTitle xBTitle, int xbType)
        {
            if (RefreshAgainXBAct != null)
            {
                RefreshAgainXBAct(xBTitle, xbType);
            }
        }

        #region 红点逻辑
        public const int HappyXB_RedKey = 203;
        public const int BestXB_RedKey = 20301;
        public const int RuneXB_RedKey = 20302;
        public const int XBStore_RedKey = 20303;
        public const int XBWarehouse_RedKey = 20304;
        public const int BestXB_OneRedKey = 20301001;
        public const int BestXB_ManyRedKey = 20301002;
        public const int BestXB_FreeRedKey = 20301003;
        public const int RuneXB_OneRedKey = 20302001;
        public const int RuneXB_ManyRedKey = 20302002;
        public const int RuneXB_FreeRedKey = 20302003;

        public Redpoint happyXBRed = new Redpoint(HappyXB_RedKey);
        public Redpoint bestXBRed = new Redpoint(HappyXB_RedKey, BestXB_RedKey);
        public Redpoint runeXBRed = new Redpoint(HappyXB_RedKey, RuneXB_RedKey);
        public Redpoint xbStoreRed = new Redpoint(HappyXB_RedKey, XBStore_RedKey);
        public Redpoint xbWarehouseRed = new Redpoint(HappyXB_RedKey, XBWarehouse_RedKey);
        public Redpoint bestXBOneRed = new Redpoint(BestXB_RedKey, BestXB_OneRedKey);
        public Redpoint bestXBManyRed = new Redpoint(BestXB_RedKey, BestXB_ManyRedKey);
        public Redpoint bestXBFreeRed = new Redpoint(BestXB_RedKey, BestXB_FreeRedKey);
        public Redpoint runeXBOneRed = new Redpoint(RuneXB_RedKey, RuneXB_OneRedKey);
        public Redpoint runeXBManyRed = new Redpoint(RuneXB_RedKey, RuneXB_ManyRedKey);
        public Redpoint runeXBFreeRed = new Redpoint(RuneXB_RedKey, RuneXB_FreeRedKey);

        private void UpdateFuncState(int funcId)
        {
            if (funcId == (int)FuncOpenEnum.HappyFindTreasure
                || funcId == 184)
            {
                XBWarehouseRedPoint();
                BestAndRuneXBRedPoint();
                XBStoreRedPoint();
            }
        }

        public void RefreshXBWarehouse()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.HappyFindTreasure)) return;

            xbWarehouseRed.state = RedPointState.Simple;
        }

        public void XBWarehouseRedPoint()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.HappyFindTreasure)) return;

            SinglePack singlePack = playerPack.GetSinglePack(PackType.Treasure);
            if (singlePack == null) return;

            if (singlePack.GetAllItems().Count > 0)
            {
                xbWarehouseRed.state = RedPointState.Simple;
            }
            else
            {
                xbWarehouseRed.state = RedPointState.None;
            }
        }

        private void RefreshXBTool(PackType type, int index, int id)
        {
            if (type != PackType.Item) return;
            if (!CheckIsXBTool(id, 1) && !CheckIsXBTool(id, 2)) return;
            BestAndRuneXBRedPoint();
        }

        public void BestAndRuneXBRedPoint()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.HappyFindTreasure)) return;

            int xbtoolCnt = 0;
            int needtoolCnt = 0;
            if (IsHaveFreeXB(1))
            {
                bestXBFreeRed.state = RedPointState.Simple;
            }
            else
            {
                bestXBFreeRed.state = RedPointState.None;
            }

            if (IsHaveManyXBTool(1, out xbtoolCnt, out needtoolCnt))
            {
                if (xbtoolCnt >= needtoolCnt)
                {
                    bestXBManyRed.state = RedPointState.Simple;
                }
                else
                {
                    bestXBManyRed.state = RedPointState.None;
                }
                bestXBOneRed.state = RedPointState.Simple;
            }
            else
            {
                bestXBOneRed.state = RedPointState.None;
                bestXBManyRed.state = RedPointState.None;
            }

            if (FuncOpen.Instance.IsFuncOpen(184) && IsHaveFreeXB(2))
            {
                runeXBFreeRed.state = RedPointState.Simple;
            }
            else
            {
                runeXBFreeRed.state = RedPointState.None;
            }

            if (FuncOpen.Instance.IsFuncOpen(184) &&
                IsHaveManyXBTool(2, out xbtoolCnt, out needtoolCnt))
            {
                if (xbtoolCnt >= needtoolCnt)
                {
                    runeXBManyRed.state = RedPointState.Simple;
                }
                else
                {
                    runeXBManyRed.state = RedPointState.None;
                }
                runeXBOneRed.state = RedPointState.Simple;
            }
            else
            {
                runeXBOneRed.state = RedPointState.None;
                runeXBManyRed.state = RedPointState.None;
            }
        }


        private void RefreshStoreScore(PlayerDataType type)
        {
            if (type != PlayerDataType.CDBPlayerRefresh_TreasureScore) return;

            XBStoreRedPoint();
        }

        private List<StoreModel.StoreData> storelist = null;
        public void XBStoreRedPoint()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.HappyFindTreasure)) return;

            ulong moneyNum = UIHelper.GetMoneyCnt(25);
            for (int i = 11; i < 14; i++)
            {
                storelist = m_storeModel.TryGetStoreDatas((StoreFunc)i);
                if (storelist.Count > 0)
                {
                    List<StoreModel.StoreData> orderlist = new List<StoreModel.StoreData>();
                    orderlist.AddRange(storelist);
                    orderlist.Sort(CompareByMoney);
                    if (moneyNum >= (ulong)orderlist[0].storeConfig.MoneyNumber)
                    {
                        xbStoreRed.state = RedPointState.Simple;
                        return;
                    }
                }
            }
            xbStoreRed.state = RedPointState.None;
        }

        public int CompareByMoney(StoreModel.StoreData start, StoreModel.StoreData end)
        {
            int money1 = start.storeConfig.MoneyNumber;
            int money2 = end.storeConfig.MoneyNumber;
            if (money1.CompareTo(money2) != 0) return money1.CompareTo(money2);
            int index1 = storelist.IndexOf(start);
            int index2 = storelist.IndexOf(end);
            if (index1.CompareTo(index2) != 0) return index1.CompareTo(index2);
            return 0;
        }
        #endregion
    }

    public class XBTypeInfo
    {
        public int xbType;   // 1 极品寻宝 2 符印寻宝 
        public int luckValue;
        public int freeCountToday;      //今日已免费寻宝次数
        public int treasureCount;        //已寻宝总次数
    }

    public class XBFuncSet
    {
        public int xbType;// 1 极品寻宝 2 符印寻宝 
        public int[] xbNums;
        public int[] xbPrices;
        public int[] costToolIds;
        public int[] costToolNums;
        public int[] xbFreeCDs;
        public int[] xbScores;
        public int dailyFreeCount;
    }

    public class XBGetItem
    {
        public int gridIndex;
        public int itemId;
        public int count;
        public DateTime createTime;
        public string createTimeStr;

        public void SetModel(int index, int id, int count)
        {
            this.gridIndex = index;
            this.itemId = id;
            this.count = count;
            createTime = TimeUtility.ServerNow;
            createTimeStr = TimeUtility.ServerNow.ToString("dd-MM-yyyy HH:mm:ss");
        }
    }

    public enum HappXBTitle
    {
        Best = 1,
        Rune = 2,
        //Store = 3,
        //Warehouse = 4,
        GatherSoul = 4, //聚魂寻宝
        Gubao1 = 5,
        Gubao2 = 6,
        Gubao3 = 7,
        Gubao4 = 8,
        
    }
}