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

public class TreasurePavilionModel : ILModel<TreasurePavilionModel>
{
    //古宝ID：[星级，等级]
    Dictionary<int, List<int>> gubaoDict = new Dictionary<int, List<int>>();
    List<int> gubaoShowList = new List<int>();  //排序显示 可激活-已激活-品质

    public Dictionary<int, int> gubaoAwardDict = new Dictionary<int, int>();
    public Dictionary<int, int> gubaoEffectDict = new Dictionary<int, int>(); //古宝特效
    public Dictionary<int, string> gubaoDiIconDict = new Dictionary<int, string>();
    public int[] xbIDArr;
    public Dictionary<int, int> luckyDrawFuncIDDict = new Dictionary<int, int>();
    public event Action UpdateGubaoEvent;
    public Dictionary<int, Dictionary<int, int[]>> probabilityDisplayDict = new Dictionary<int, Dictionary<int, int[]>>();
    public int selectGubao; //从藏宝阁选中
    public int waitActiveGubao; //激活等待显示的古宝
    public int upgradeGubao;    //当前升级升星的古宝
    public int upgradeFuncOrder = 0;//0升星1升级
    string scoreFormula;
    public bool isEffectPlaying = false;//古宝抽奖动画正在播放
    public List<int> gubaoTypeList = new List<int>();
    public Dictionary<int, int> gubaoItemCountDict = new Dictionary<int, int>();    //古宝碎片背包物品改为数值记录
    public event Action UpdateGubaoItemCountEvent;

    public bool isWinOpen = false;
    int getA3CBCount;          //古宝收到了几次包
    int m_SelectIndex;  //古宝总类型
    public event Action OnSelectUpdate;
    public int selectIndex
    {
        get { return m_SelectIndex; }
        set
        {
            if (m_SelectIndex != value)
            {
                m_SelectIndex = value;
                OnSelectUpdate?.Invoke();
            }
        }
    }

    int m_SelectTagIndex = 0;  //古宝Tag类型 0 全部 1 共鸣 2 可升星
    public int selectTagIndex
    {
        get { return m_SelectTagIndex; }
        set
        {
            if (m_SelectTagIndex != value)
            {
                m_SelectTagIndex = value;
                OnSelectUpdate?.Invoke();
            }
        }
    }

    int m_SelectResonanceID = 0;
    public int selectResonanceID
    {
        get { return m_SelectResonanceID; }
        set
        {
            if (m_SelectResonanceID != value)
            {
                m_SelectResonanceID = value;
            }
        }
    }

    bool m_showLuckyDraw = false;
    public bool isShowLuckyDraw
    {
        get { return m_showLuckyDraw; }
        set
        {
            if (m_showLuckyDraw != value)
            {
                m_showLuckyDraw = value;
                OnSelectUpdate?.Invoke();
            }
        }
    }
    int m_XBIndex = 0;
    public int xbIndex
    {
        get { return m_XBIndex; }
        set
        {
            if (m_XBIndex != value)
            {
                m_XBIndex = value;
                OnSelectUpdate?.Invoke();
            }
        }
    }

    PackModel packModel { get { return ModelCenter.Instance.GetModelEx<PackModel>(); } }

    Dictionary<int, Redpoint> activeRedPointDict = new Dictionary<int, Redpoint>();
    Dictionary<int, Redpoint> starRedPointDict = new Dictionary<int, Redpoint>();
    Dictionary<int, Redpoint> lvRedPointDict = new Dictionary<int, Redpoint>();
    Dictionary<int, Redpoint> awardRedPointDict = new Dictionary<int, Redpoint>();
    Redpoint tmpRP = new Redpoint(MainRedDot.RedPoint_key, MainRedPoint.cbgRedpoint);
    Redpoint treasureLuckyDrawRedpoint = new Redpoint(MainRedPoint.cbgRedpoint, MainRedDot.TreasureLuckyDrawRedpoint);    //古宝抽奖入口红点
    List<Redpoint> treasureLuckyDrawTabRedpointList = new List<Redpoint>(); //古宝抽奖Tab红点
    Redpoint treasureLuckDrawFreeRedpoint = new Redpoint(MainRedDot.TreasureLuckyDrawRedpoint, MainRedDot.TreasureLuckyDrawRedpoint * 10 + 9);//免费抽奖红点
    TreasurePavilionUpgradeChooseModel treasurePavilionUpgradeChooseModel { get { return ModelCenter.Instance.GetModelEx<TreasurePavilionUpgradeChooseModel>(); } }
    protected override void Init()
    {
        GameEvent.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
        packModel.refreshItemCountEvent += RefreshItemCount;
        FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
        ParseConfig();

        for (int i = 0; i < gubaoTypeList.Count; i++)
        {
            new Redpoint(MainRedPoint.cbgRedpoint, MainRedPoint.cbgRedpoint * 10 + gubaoTypeList[i]);
        }
        for (int i = 0; i < 4; i++)
        {
            treasureLuckyDrawTabRedpointList.Add(new Redpoint(MainRedDot.TreasureLuckyDrawRedpoint, MainRedDot.TreasureLuckyDrawRedpoint * 10 + i));
        }
        var gubaoKeys = ILGubaoConfig.GetKeys();
        for (int i = 0; i < gubaoKeys.Count; i++)
        {
            var gubaoID = int.Parse(gubaoKeys[i]);
            var gubaoRPID = MainRedPoint.cbgRedpoint * 10000 + gubaoID;
            var config = ILGubaoConfig.Get(gubaoID);
            new Redpoint(MainRedPoint.cbgRedpoint * 10 + config.GubaoType, gubaoRPID);
            activeRedPointDict[gubaoID] = new Redpoint(gubaoRPID, gubaoRPID * 10);
            starRedPointDict[gubaoID] = new Redpoint(gubaoRPID, gubaoRPID * 10 + 1);
            lvRedPointDict[gubaoID] = new Redpoint(gubaoRPID, gubaoRPID * 10 + 2);
            var starConfig = ILGubaoStarConfig.Get(ILGubaoStarConfig.GetGubaoStarIndex(gubaoID, 1));
            if (starConfig.StarEffIDList[0] != 0 && ILGubaoEffAttrConfig.Get(starConfig.StarEffIDList[0]).EffItemAwardList.Length > 2)
            {
                awardRedPointDict[gubaoID] = new Redpoint(gubaoRPID, gubaoRPID * 10 + 3);
            }
            //if (!unLockItems.Contains(config.UnlockItemID))
            //{
            //    unLockItems.Add(config.UnlockItemID);
            //}
        }
    }

    protected override void UnInit()
    {
        GameEvent.beforePlayerDataInitializeEvent -= OnBeforePlayerDataInitialize;
        packModel.refreshItemCountEvent -= RefreshItemCount;
        FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
    }
    private void OnFunctionStateChange(int id)
    {
        if (id == 234)
        {
            UpdateLuckyDrawRedpoint();
        }
    }
    void ParseConfig()
    {
        gubaoTypeList = ILGubaoConfig.gubaoTypeDict.Keys.ToList();
        //gubaoShowList.Clear();
        //var tmpList = ILGubaoConfig.GetKeys();
        //for (int i = 0; i < tmpList.Count; i++)
        //{
        //    gubaoShowList.Add(int.Parse(tmpList[i]));
        //}
        var config = FuncConfigConfig.Get("gubao");
        var json = JsonMapper.ToObject(config.Numerical1);
        var keys = json.Keys.ToList();
        for (int i = 0; i < keys.Count; i++)
        {
            gubaoEffectDict[int.Parse(keys[i])] = int.Parse(json[keys[i]].ToString());
        }

        json = JsonMapper.ToObject(config.Numerical2);
        keys = json.Keys.ToList();
        for (int i = 0; i < keys.Count; i++)
        {
            gubaoDiIconDict[int.Parse(keys[i])] = json[keys[i]].ToString();
        }

        scoreFormula = config.Numerical3;

        config = FuncConfigConfig.Get("TreasureLuckyDraw");
        xbIDArr = JsonMapper.ToObject<int[]>(config.Numerical1);
        json = JsonMapper.ToObject(config.Numerical2);
        keys = json.Keys.ToList();
        for (int i = 0; i < keys.Count; i++)
        {
            luckyDrawFuncIDDict[int.Parse(keys[i])] = int.Parse(json[keys[i]].ToString());
        }

        for (int i = 0; i < xbIDArr.Length; i++)
        {
            int xbID = xbIDArr[i];
            int type = XBGetItemConfig.Get(xbID).TreasureType;
            Dictionary<int, int[]> result = new Dictionary<int, int[]>();
            string str = TreasureSetConfig.Get(type).ProbabilityDisplay;
            var jsonData = JsonMapper.ToObject(str);
            var keyList = jsonData.Keys.ToList();
            for (int j = 0; j < keyList.Count; j++)
            {
                string key = keyList[j];
                int[] value = JsonMapper.ToObject<int[]>(jsonData[key].ToJson());
                result[int.Parse(key)] = value;
            }
            probabilityDisplayDict[type] = result;
        }


    }


    void OnBeforePlayerDataInitialize()
    {
        gubaoDict.Clear();
        waitActiveGubao = 0;
        gubaoAwardDict.Clear();
        gubaoItemCountDict.Clear();
        getA3CBCount = 0;
    }


    void RefreshItemCount(PackType packType, int index, int itemID)
    {
        if (packType == PackType.Item)
        {
            if (CanRefreshRepoint(itemID))
            {
                UpdateRedpoint();
            }
        }
    }

    public void UpdateLuckyDrawRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen(214))
            return;

        var keyList = luckyDrawFuncIDDict.Keys.ToList();
        for (int i = 0; i < treasureLuckyDrawTabRedpointList.Count; i++)
        {
            treasureLuckyDrawTabRedpointList[i].state = RedPointState.None;
        }
        treasureLuckDrawFreeRedpoint.state = RedPointState.None;

        for (int i = 0; i < 4; i++)
        {
            if (i < xbIDArr.Length)
            {
                if (!luckyDrawFuncIDDict.ContainsKey(xbIDArr[i]))
                    return;
                if (!FuncOpen.Instance.IsFuncOpen(luckyDrawFuncIDDict[xbIDArr[i]]))
                    return;
                int type = XBGetItemConfig.Get(xbIDArr[i]).TreasureType;
                var funcSet = ModelCenter.Instance.GetModel<HappyXBModel>().GetXBFuncSet(type);
                bool isHaveFree = ModelCenter.Instance.GetModel<HappyXBModel>().IsHaveFreeXB(type);
                if (isHaveFree)
                {
                    treasureLuckyDrawTabRedpointList[i].state = RedPointState.Simple;
                    if (xbIndex == i)
                    {
                        treasureLuckDrawFreeRedpoint.state = RedPointState.Simple;
                    }
                }
            }
        }
    }

    // 428 -4281(类型) - 4280000 - 42800001
    // 主界面红点-古宝(ID)红点- 0激活1升星2升级红点 
    // 物品数量
    public void UpdateRedpoint()
    {
        if (!FuncOpen.Instance.IsFuncOpen(214))
            return;

        treasurePavilionUpgradeChooseModel.UpdateGubaoPieceInfo();
        var keys = activeRedPointDict.Keys.ToList();
        for (int i = 0; i < keys.Count; i++)
        {
            var gubaoID = keys[i];
            activeRedPointDict[gubaoID].state = RedPointState.None;
            starRedPointDict[gubaoID].state = RedPointState.None;
            lvRedPointDict[gubaoID].state = RedPointState.None;

            var config = ILGubaoConfig.Get(gubaoID);

            if (!gubaoDict.ContainsKey(gubaoID))
            {
                var hasCnt = GetGubaoItemCount(gubaoID);// packModel.GetItemCountByID(PackType.Item, config.UnlockItemID);
                if (hasCnt >= config.UnlockItemCnt)
                {
                    activeRedPointDict[gubaoID].state = RedPointState.Simple;
                }

            }
            else
            {
                var gubaoInfo = TryGetGubaoInfo(gubaoID);
                //升级红点
                var needItems = ILGubaoLVConfig.GetGubaoQualityLVItems(config.GubaoType, config.GubaoQuality, gubaoInfo[1]);
                bool enough = true;
                for (int j = 0; j < needItems.Count; j++)
                {
                    var hasCnt = packModel.GetItemCountByID(PackType.Item, needItems[j].x);
                    if (hasCnt < needItems[j].y)
                    {
                        enough = false;
                        break;
                    }
                }
                if (enough && needItems.Count > 0)
                    lvRedPointDict[gubaoID].state = RedPointState.Simple;

                //升星红点
                var maxStar = ILGubaoStarConfig.GetMaxStar(gubaoID);
                if (maxStar == 1)
                {
                    continue;
                }
                var qualityItems = ILGubaoStarConfig.GetGubaQualityPieceInfoList(gubaoID, gubaoInfo[0]);
                needItems = ILGubaoStarConfig.GetGubaoStarItems(gubaoID, gubaoInfo[0]);
                enough = true;
                for (int j = 0; j < needItems.Count; j++)
                {
                    var itemConfig = ItemConfig.Get(needItems[j].x);
                    int hasCnt;
                    if (itemConfig.Effect1 == 270)
                        hasCnt = GetGubaoItemCount(itemConfig.EffectValueA1);
                    else
                        hasCnt = packModel.GetItemCountByID(PackType.Item, needItems[j].x);
                    if (hasCnt < needItems[j].y)
                    {
                        enough = false;
                        break;
                    }
                }

                // 检查古宝碎片
                if (enough)
                {
                    for (int j = 0; j < qualityItems.Count; j++)
                    {
                        int quality = qualityItems[j].x;
                        int cnt = qualityItems[j].y;
                        int hasCnt = treasurePavilionUpgradeChooseModel.GetHaveGuBaoPieceCountByQuality(quality);
                        if (hasCnt < cnt)
                        {
                            enough = false;
                            break;
                        }
                    }
                }

                if (enough && (needItems.Count > 0 || qualityItems.Count > 0))
                    starRedPointDict[gubaoID].state = RedPointState.Simple;

            }
        }
    }

    void UpdateRedpointAward()
    {
        if (!FuncOpen.Instance.IsFuncOpen(214))
            return;

        var keys = awardRedPointDict.Keys.ToList();
        for (int i = 0; i < keys.Count; i++)
        {
            var gubaoID = keys[i];
            awardRedPointDict[gubaoID].state = RedPointState.None;

            //领取红点
            if (gubaoAwardDict.ContainsKey(gubaoID) && gubaoAwardDict[gubaoID] > 0)
            {
                var starConfig = ILGubaoStarConfig.Get(ILGubaoStarConfig.GetGubaoStarIndex(gubaoID, gubaoDict[gubaoID][0]));
                if (gubaoAwardDict[gubaoID] / ILGubaoEffAttrConfig.Get(starConfig.StarEffIDList[0]).EffCond > 0)
                {
                    awardRedPointDict[gubaoID].state = RedPointState.Simple;
                }
            }
        }
    }



    bool CanRefreshRepoint(int itemID)
    {
        //if (unLockItems.Contains(itemID))
        //    return true;

        if (ILGubaoLVConfig.needItemIDs.Contains(itemID))
            return true;

        if (ILGubaoStarConfig.needItemIDs.Contains(itemID))
            return true;
        return false;
    }

    public void UpdateGubaoNetPack(IL_HA3C7_tagMCGubaoInfo netPack)
    {
        for (int i = 0; i < netPack.Count; i++)
        {
            gubaoDict[netPack.GubaoInfoList[i].GubaoID] = new List<int>() {
            netPack.GubaoInfoList[i].GubaoStar,
            netPack.GubaoInfoList[i].GubaoLV
            };
        }

        UpdateGubaoEvent?.Invoke();
        if (waitActiveGubao != 0 && gubaoDict.ContainsKey(waitActiveGubao))
        {
            WindowCenter.Instance.OpenIL<TreasurePavilionActiveWin>();
        }
        UpdateRedpoint();
    }

    public void SortGubaoList()
    {
        gubaoShowList = ILGubaoConfig.gubaoTypeDict[gubaoTypeList[selectIndex]];
        gubaoShowList.Sort(CmpGubao);
    }

    public List<int> GetGubaoList()
    {
        return gubaoShowList;
    }



    public List<int> TryGetGubaoInfo(int gubaoID)
    {
        if (!gubaoDict.ContainsKey(gubaoID))
            return new List<int>();

        return gubaoDict[gubaoID];
    }


    //排序显示 可激活-已激活-品质
    int CmpGubao(int gubaoA, int gubaoB)
    {
        var isActiveA = gubaoDict.ContainsKey(gubaoA);
        var isActiveB = gubaoDict.ContainsKey(gubaoB);

        var configA = ILGubaoConfig.Get(gubaoA);
        var configB = ILGubaoConfig.Get(gubaoB);
        var canActiveA = false;
        var canActiveB = false;
        if (!isActiveA)
        {
            canActiveA = GetGubaoItemCount(gubaoA) >= configA.UnlockItemCnt;
            if (canActiveA) isActiveA = true;
        }

        if (!isActiveB)
        {
            canActiveB = GetGubaoItemCount(gubaoB) >= configB.UnlockItemCnt;
            if (canActiveB) isActiveB = true;
        }

        if (canActiveA != canActiveB)
        {
            return canActiveB.CompareTo(canActiveA);
        }

        if (isActiveA != isActiveB)
        {
            return isActiveB.CompareTo(isActiveA);
        }

        int gubaoQualityA = configA.GubaoQuality;
        int gubaoQualityB = configB.GubaoQuality;
        if (gubaoQualityA != gubaoQualityB)
        {
            return gubaoQualityB.CompareTo(gubaoQualityA);
        }

        return gubaoA.CompareTo(gubaoB);
    }

    public int GetGubaoScore(int gubaoID)
    {
        Equation.Instance.Clear();
        //baseScore+lvFightPower*0.2+starScore
        var config = ILGubaoConfig.Get(gubaoID);
        Equation.Instance.AddKeyValue("baseScore", config.BaseScore);

        var gubaoInfo = TryGetGubaoInfo(gubaoID);
        var lvFightPower = 0;

        ILGubaoStarConfig starConfig = null;
        if (gubaoDict.ContainsKey(gubaoID))
        {
            starConfig = ILGubaoStarConfig.Get(ILGubaoStarConfig.GetGubaoStarIndex(gubaoID, gubaoDict[gubaoID][0]));
        }

        if (gubaoInfo.Count > 0)
        {
            var lvConfig = ILGubaoLVConfig.Get(ILGubaoLVConfig.GetGubaoQualityLVIndex(config.GubaoType, config.GubaoQuality, gubaoInfo[1]));
            Dictionary<int, int> attrDict = new Dictionary<int, int>();
            for (int i = 0; i < lvConfig.LVAttrTypeList.Length; i++)
            {
                attrDict[lvConfig.LVAttrTypeList[i]] = lvConfig.LVAttrValueList[i];
            }

            if (starConfig.StarAttrIDList.Length != 0)
            {
                for (int i = 0; i < starConfig.StarAttrIDList.Length; i++)
                {
                    if (!attrDict.ContainsKey(starConfig.StarAttrIDList[i]))
                    {
                        attrDict[starConfig.StarAttrIDList[i]] = 0;
                    }
                    attrDict[starConfig.StarAttrIDList[i]] += starConfig.StarAttrValueList[i];
                }
            }

            lvFightPower = UIHelper.GetFightPower(attrDict);
        }
        Equation.Instance.AddKeyValue("lvFightPower", lvFightPower);
        var starScore = 0;
        if (starConfig != null)
        {
            for (int i = 0; i < starConfig.StarEffIDList.Length; i++)
            {
                if (!ILGubaoEffAttrConfig.Has(starConfig.StarEffIDList[i]))
                {
                    starScore += 0;
                }
                else
                {
                    starScore += ILGubaoEffAttrConfig.Get(starConfig.StarEffIDList[i]).StarScore;
                }
            }
        }
        Equation.Instance.AddKeyValue("starScore", starScore);
        return Equation.Instance.Eval<int>(scoreFormula);
    }

    public void ActiveGubao(int gubaoID)
    {
        var pak = new IL_CB216_tagCMGubaoActivate();
        pak.GubaoID = (ushort)gubaoID;
        GameNetSystem.Instance.SendInfo(pak);
        waitActiveGubao = gubaoID;
    }

    public void UpgradeGubaoStar(int gubaoID, IL_CB217_tagCMGubaoStarUp.tagCMGubaoPieceUse[] info = null)
    {
        var pak = new IL_CB217_tagCMGubaoStarUp();
        pak.GubaoID = (ushort)gubaoID;
        pak.CommPieceUseList = info;
        pak.PieceSelectCount = info == null ? (byte)0 : (byte)info.Length;
        GameNetSystem.Instance.SendInfo(pak);
    }

    public void UpgradeGubaoLV(int gubaoID)
    {
        var pak = new IL_CB218_tagCMGubaoLVUp();
        pak.GubaoID = (ushort)gubaoID;
        GameNetSystem.Instance.SendInfo(pak);
    }

    public event Action UpdateGubaoAwardEvent;
    public void UpdateGubaoAward(IL_HA3CA_tagMCGubaoItemEffInfo netPack)
    {
        for (int i = 0; i < netPack.ItemEffInfoList.Length; i++)
        {
            gubaoAwardDict[netPack.ItemEffInfoList[i].GubaoID] = (int)netPack.ItemEffInfoList[i].EffValue;
        }

        UpdateRedpointAward();
        UpdateGubaoAwardEvent?.Invoke();
    }


    public void UpdateGubaoItemCount(IL_HA3CB_tagMCGubaoPieceInfo netPack)
    {

        ShowRewardWin(netPack);
        for (int i = 0; i < netPack.PieceInfoList.Length; i++)
        {
            gubaoItemCountDict[netPack.PieceInfoList[i].GubaoID] = (int)netPack.PieceInfoList[i].PieceCount;
        }
        UpdateGubaoItemCountEvent?.Invoke();
        UpdateRedpoint();
    }

    private List<Item> accumulatedItems = new List<Item>();
    private Clock rewardClock;

    public void ShowRewardWin(IL_HA3CB_tagMCGubaoPieceInfo vNetData)
    {
        getA3CBCount += 1;
        if (ItemLogicUtility.Instance.hidePickItem)
            return;
        if (getA3CBCount <= 1) // 同步古宝数据,避免触发奖励弹窗
            return;
        if (isShowLuckyDraw && isWinOpen)    //避免和古宝抽奖奖励弹窗冲突
            return;


        for (int i = 0; i < vNetData.PieceInfoList.Length; i++)
        {
            int gubaoID = vNetData.PieceInfoList[i].GubaoID;
            int pieceCount = (int)vNetData.PieceInfoList[i].PieceCount;
            int hasCnt = 0;
            if (gubaoItemCountDict.ContainsKey(gubaoID))
            {
                hasCnt = gubaoItemCountDict[gubaoID];
            }
            if (hasCnt > pieceCount)
                return;
            int itemId = ILGubaoConfig.Get(gubaoID).UnlockItemID;
            ItemLogicUtility.Instance.RefreshPickItem(PackType.Item, itemId.ToString());
            
        }
    }

    public int GetGubaoItemCount(int gubaoID)
    {
        if (!gubaoItemCountDict.ContainsKey(gubaoID))
            return 0;

        return gubaoItemCountDict[gubaoID];
    }

    //当前类型的古宝一个共鸣套装也没有
    public bool IsTypeNoReverberation()
    {
        var dict = GubaoResonanceConfig.GetGubaoIDToResonanceIDDict();
        var list = GetGubaoList();
        for (int i = 0; i < list.Count; i++)
        {
            int gubaoID = list[i];
            if (dict.ContainsKey(gubaoID))
            {
                return false;
            }
        }
        return true;
    }



    //返回当前所在标签类型的可升星的古宝列表
    public bool TryGetUpgradeStarList(out List<int> upgradeStarList)
    {
        upgradeStarList = new List<int>();
        var list = GetGubaoList();
        for (int i = 0; i < list.Count; i++)
        {
            int gubaoID = list[i];
            //古宝表里没有
            if (!ILGubaoConfig.Has(gubaoID)) continue;
            var config = ILGubaoConfig.Get(gubaoID);
            //古宝未激活
            if (!gubaoDict.ContainsKey(gubaoID)) continue;
            var gubaoInfo = TryGetGubaoInfo(gubaoID);
            var maxStar = ILGubaoStarConfig.GetMaxStar(gubaoID);
            //古宝最大等级只有1级
            if (maxStar == 1) continue;
            var qualityItems = ILGubaoStarConfig.GetGubaQualityPieceInfoList(gubaoID, gubaoInfo[0]);
            var needItems = ILGubaoStarConfig.GetGubaoStarItems(gubaoID, gubaoInfo[0]);
            var enough = true;
            for (int j = 0; j < needItems.Count; j++)
            {
                var itemConfig = ItemConfig.Get(needItems[j].x);
                int hasCnt;
                if (itemConfig.Effect1 == 270)
                    hasCnt = GetGubaoItemCount(itemConfig.EffectValueA1);
                else
                    hasCnt = packModel.GetItemCountByID(PackType.Item, needItems[j].x);
                if (hasCnt < needItems[j].y)
                {
                    enough = false;
                    break;
                }
            }
            // 检查古宝碎片
            if (enough)
            {
                for (int j = 0; j < qualityItems.Count; j++)
                {
                    int quality = qualityItems[j].x;
                    int cnt = qualityItems[j].y;
                    int hasCnt = treasurePavilionUpgradeChooseModel.GetHaveGuBaoPieceCountByQuality(quality);
                    if (hasCnt < cnt)
                    {
                        enough = false;
                        break;
                    }
                }
            }

            if (enough && (needItems.Count > 0 || qualityItems.Count > 0))
                upgradeStarList.Add(gubaoID);
        }
        return upgradeStarList.Count > 0;
    }

    //获取当前类型的所有共鸣ID
    public List<int> GetReverberationList()
    {
        List<int> tempList = new List<int>();
        var dict = GubaoResonanceConfig.GetGubaoIDToResonanceIDDict();
        var list = GetGubaoList();
        for (int i = 0; i < list.Count; i++)
        {
            int gubaoID = list[i];
            if (dict.ContainsKey(gubaoID))
            {
                int resonanceID = dict[gubaoID];
                if (!tempList.Contains(resonanceID))
                {
                    tempList.Add(resonanceID);
                }
            }
        }
        tempList.Sort();
        return tempList;
    }

    //显示内容(直接显示总的)
    public string GetInfo(int nowID)
    {
        if (!GubaoResonanceAttrConfig.Has(nowID))
            return string.Empty;
        var config = GubaoResonanceAttrConfig.Get(nowID);
        int resonanceStar = config.ResonanceStar;
        int[] attrIDArr = config.ResonanceAttrIDList;
        int[] attrValueArr = config.ResonanceAttrValueList;
        List<string> result = new List<string>();
        if (resonanceStar == 1)
        {
            result.Add(Language.Get("TreasurePavilion02"));
        }
        else
        {
            result.Add(Language.Get("TreasurePavilion03", resonanceStar));
        }

        for (int i = 0; i < attrIDArr.Length; i++)
        {
            result.Add(GetShowAttribute(attrIDArr[i], attrValueArr[i]));
        }

        string str = StringUtility.Contact(result.ToArray());
        result.Clear();
        result = null;
        return str;
    }

    //获得当前共鸣星级上一共鸣星级的共鸣属性ID 没有返回0
    public int GetLastResonanceStarID(int resonanceID, int resonanceStar)
    {
        var dict = GubaoResonanceAttrConfig.GetDict();
        var starDict = dict[resonanceID];
        var keyList = starDict.Keys.ToList();
        int minResonanceStar = resonanceStar;

        //传入星级是1 已经是最小星级的
        if (resonanceStar == 1)
            return 0;
        keyList.Sort();
        int index = keyList.IndexOf(resonanceStar);
        if (index - 1 < 0)
            return 0;
        return starDict[keyList[index - 1]];
    }

    //获得当前共鸣星级上一共鸣星级的属性值 没有返回0
    public long GetLastAttributeValue(int lastID, int nowAttrID)
    {
        if (lastID == 0)
            return 0;
        var config = GubaoResonanceAttrConfig.Get(lastID);
        int[] lastAttrIDArr = config.ResonanceAttrIDList;
        int[] lastAttrValueArr = config.ResonanceAttrValueList;
        if (!IsLastHaveAttributeID(lastID, nowAttrID))
            return 0;
        int index = GetLastHaveAttributeIDIndex(lastID, nowAttrID);
        return lastAttrValueArr[index];
    }

    //上一档是否存在这个属性
    public bool IsLastHaveAttributeID(int lastID, int AttrID)
    {
        if (lastID == 0)
            return false;
        var config = GubaoResonanceAttrConfig.Get(lastID);
        int[] lastAttrIDArr = config.ResonanceAttrIDList;
        for (int i = 0; i < lastAttrIDArr.Length; i++)
        {
            if (lastAttrIDArr[i] == AttrID)
            {
                return true;
            }
        }
        return false;
    }

    public int GetLastHaveAttributeIDIndex(int lastID, int AttrID)
    {
        var config = GubaoResonanceAttrConfig.Get(lastID);
        int[] lastAttrIDArr = config.ResonanceAttrIDList;
        for (int i = 0; i < lastAttrIDArr.Length; i++)
        {
            if (lastAttrIDArr[i] == AttrID)
            {
                return i;
            }
        }
        return 0;
    }

    //传入属性id 自动根据属性类型决定后面加不加%
    public string GetShowAttribute(int id, long value)
    {
        if (id == 0 || !PlayerPropertyConfig.GetKeys().Contains(id.ToString()))
            return "";
        return StringUtility.Contact(" ", PlayerPropertyConfig.Get(id).Name, " +", PlayerPropertyConfig.GetValueDescription(id, value) + " ");
    }

    //获得这组古宝的最小星数
    public int GetNowStar(int id)
    {
        int resonanceID = GubaoResonanceAttrConfig.Get(id).ResonanceID;
        var gubaoIDList = GubaoResonanceConfig.Get(resonanceID).GubaoIDList;
        List<int> starCountList = new List<int>();
        for (int i = 0; i < gubaoIDList.Length; i++)
        {
            int gubaoID = gubaoIDList[i];
            var list = TryGetGubaoInfo(gubaoID);
            if (list.Count == 0)
                return 0;
            starCountList.Add(list[0]);
        }
        starCountList.Sort();
        return starCountList[0];
    }

    //获取共鸣中有几件古宝激活了
    public int GetResonanceGuBaoActiveCount(int resonanceID)
    {
        int count = 0;
        var gubaoIDList = GubaoResonanceConfig.Get(resonanceID).GubaoIDList;
        for (int i = 0; i < gubaoIDList.Length; i++)
        {
            int gubaoID = gubaoIDList[i];
            var list = TryGetGubaoInfo(gubaoID);
            var hasCnt = GetGubaoItemCount(gubaoID);
            var config = ILGubaoConfig.Get(gubaoID);
            //满足激活条件的古宝 视为已激活
            if (list.Count == 0)
            {
                if (hasCnt >= config.UnlockItemCnt)
                {
                    count += 1;
                }
                else
                {
                    continue;
                }
            }
            else
            {
                count += 1;
            }
        }
        return count;
    }


    //获得这组古宝的最小星数
    public int GetNowStarByResonanceID(int resonanceID)
    {
        var gubaoIDList = GubaoResonanceConfig.Get(resonanceID).GubaoIDList;
        List<int> starCountList = new List<int>();
        for (int i = 0; i < gubaoIDList.Length; i++)
        {
            int gubaoID = gubaoIDList[i];
            var list = TryGetGubaoInfo(gubaoID);
            if (list.Count == 0)
                return 0;
            starCountList.Add(list[0]);
        }
        starCountList.Sort();
        return starCountList[0];
    }

    //获取共鸣中有几条属性激活了
    public int GetResonanceGuBaoAttrActiveCount(int resonanceID)
    {
        int minStar = GetNowStarByResonanceID(resonanceID);
        int count = 0;
        var starList = GubaoResonanceAttrConfig.GetResonanceStarDict()[resonanceID];
        for (int j = 0; j < starList.Count; j++)
        {
            int star = starList[j];
            if (star <= minStar)
            {
                count += 1;
            }
        }
        return count;
    }

    //对套装进行排序
    //套装激活属性数量未满 > 没有任何激活的古宝套装 > 套装所有属性激活
    public int CmpResonance(int resonanceA, int resonanceB)
    {
        // 套装中古宝数量
        int gubaoCountA = GubaoResonanceConfig.Get(resonanceA).GubaoIDList.Length;
        int gubaoCountB = GubaoResonanceConfig.Get(resonanceB).GubaoIDList.Length;
        // 套装中激活的古宝数量
        int activeCountA = GetResonanceGuBaoActiveCount(resonanceA);
        int activeCountB = GetResonanceGuBaoActiveCount(resonanceB);
        // 套装可激活属性数量
        int AttrCountA = GubaoResonanceAttrConfig.GetResonanceStarDict()[resonanceA].Count;
        int AttrCountB = GubaoResonanceAttrConfig.GetResonanceStarDict()[resonanceB].Count;
        // 套装激活属性数量
        int activeAttrCountA = GetResonanceGuBaoAttrActiveCount(resonanceA);
        int activeAttrCountB = GetResonanceGuBaoAttrActiveCount(resonanceB);

        // 判断是否有任一古宝激活但套装未满（包括未激活任何套装效果的情况）
        bool isPartiallyActiveA = activeCountA > 0 && activeCountA < gubaoCountA;
        bool isPartiallyActiveB = activeCountB > 0 && activeCountB < gubaoCountB;

        // 判断套装属性是否全部激活
        bool allActiveA = activeAttrCountA == AttrCountA && activeAttrCountA > 0;
        bool allActiveB = activeAttrCountB == AttrCountB && activeAttrCountB > 0;

        // 处理套装所有属性激活的情况，将其排在最后
        if (allActiveA != allActiveB)
        {
            return allActiveA ? 1 : -1; // 全部激活的套装排在后面
        }

        // 如果都是全部激活或都不是全部激活，继续比较其他条件

        // 比较激活属性数量
        if (activeAttrCountA != activeAttrCountB)
        {
            return activeAttrCountB.CompareTo(activeAttrCountA);
        }

        // 如果激活属性数量相同，处理有任一古宝激活但套装未满的情况
        if (isPartiallyActiveA != isPartiallyActiveB)
        {
            return isPartiallyActiveA ? -1 : 1; // 部分激活的套装优先
        }

        if (isPartiallyActiveA && isPartiallyActiveB)
        {
            // 两个套装都是部分激活，比较激活的古宝数量
            return activeCountB.CompareTo(activeCountA);
        }

        // 处理没有任何激活的古宝套装的情况
        if (activeCountA == 0 && activeCountB == 0)
        {
            // 两个套装都没有激活的古宝，比较总古宝数量
            return gubaoCountB.CompareTo(gubaoCountA);
        }

        // 如果都是全部激活的情况，比较总古宝数量
        if (allActiveA && allActiveB)
        {
            return gubaoCountB.CompareTo(gubaoCountA);
        }

        // 如果代码执行到这里，说明存在未考虑到的情况，返回0表示相等
        return 0;

    }

    public int GetJumpIndex()
    {
        if (selectResonanceID == 0)
        {
            return 0;
        }
        else
        {
            List<int> reverberationList = GetReverberationList();
            reverberationList.Sort(CmpResonance);
            int index = reverberationList.IndexOf(selectResonanceID);
            if (index < 0)
            {
                return 0;
            }
            return index;
        }
    }

    //获取品质对应的可展示的物品ID
    public List<int> GetItemIDByQuality(int quality, int treasureType)
    {
        List<int> result = new List<int>();
        var probabilityDict = probabilityDisplayDict[treasureType];
        int[] libs = probabilityDict[quality];
        for (int i = 0; i < libs.Length; i++)
        {
            int libID = libs[i];
            var list = TreasureItemLibConfig.GetItemIDList(libID);
            for (int j = 0; j < list.Count; j++)
            {
                if (!result.Contains(list[j]))
                {
                    result.Add(list[j]);
                }
            }
        }
        return result;
    }

    public Dictionary<int, int> GetRateDict(int treasureID)
    {
        Dictionary<int, int> result = new Dictionary<int, int>();
        Dictionary<int, int> gridLibInfo = new Dictionary<int, int>();
        var jsonData = JsonMapper.ToObject(XBGetItemConfig.Get(treasureID).GridLibInfo);
        var keyList = jsonData.Keys.ToList();
        for (int i = 0; i < keyList.Count; i++)
        {
            gridLibInfo[int.Parse(keyList[i])] = int.Parse(jsonData[keyList[i]].ToString());
        }

        int[][] GridItemRateList = XBGetItemConfig.Get(treasureID).GridItemRateList1;
        Dictionary<int, int> rateDict = ConfigParse.GetRateDict(GridItemRateList);

        var InfoKey = gridLibInfo.Keys.ToList();
        for (int i = 0; i < InfoKey.Count; i++)
        {
            int grid = InfoKey[i];
            int lib = gridLibInfo[grid];
            result[lib] = rateDict[grid];
        }

        return result;
    }

    public List<string> GetGubaoEffects(int gubaoID, bool includeShentong = true, int star = 0)
    {
        List<string> starInfo = new List<string>();
        if (includeShentong)
        {
            int shentongID = ShentongModel.Instance.GetShentongIDByGubaoID(gubaoID);
            if (shentongID != 0)
            {
                //激活神通Shentong8
                starInfo.Add(Language.Get("Shentong8", ILShentongConfig.Get(shentongID).Name));
            }
        }

        int showStar;
        if (star != 0)
        {
            showStar = star;
        }
        else
        {
            var gubaoInfo = TryGetGubaoInfo(gubaoID);
            showStar = gubaoInfo.Count == 0 ? 1 : gubaoInfo[0];
        }

        var starConfig = ILGubaoStarConfig.Get(ILGubaoStarConfig.GetGubaoStarIndex(gubaoID, showStar));
        if (starConfig.StarEffIDList[0] != 0)
        {
            starInfo.Add(ILGubaoEffAttrConfig.Get(starConfig.StarEffIDList[0]).Name);
        }
        for (int i = 0; i < starConfig.StarAttrIDList.Length; i++)
        {
            starInfo.Add(PlayerPropertyConfig.GetFullDescription(starConfig.StarAttrIDList[i], starConfig.StarAttrValueList[i]));
        }

        return starInfo;
    }
}