//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, March 12, 2019
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System.Collections.Generic;

namespace Snxxz.UI
{

    public enum TipType
    {
        Normal = 1,
        Good = 2,
    }

    public class EquipTipUtility
    {

        public class TipData
        {
            public int itemId;
            public string guid;

            public BaseInfo baseInfo;
            public BaseProperty baseProperty;
            public LegendProperty legendProperty;
            public SkillInfo skillInfo;
            public SuitInfo suitInfo;
            public StarInfo starInfo;
            public StrengthenProperty strengthenProperty;
            public GemInfo gemInfo;
            public TrainProperty trainProperty;
            public List<ItemOperateType> operates;

        }

        public struct BaseInfo
        {
            public int itemId;
            public int count;
            public bool isAuction;
            public bool isEquiped;

            public int star;
            public int strengthenLevel;
            public int score;
            public int auctionSurplusTime;
            public int levelLimit;
            public int realmLimit;
        }

        public struct BaseProperty
        {
            public List<Int2> baseProperties;
            public int star;
            public List<Int2> starProperties;
        }

        public struct LegendProperty
        {
            public bool isPreview;
            public int trueCount;
            public List<Int2> properties;
        }

        public struct SuitInfo
        {
            public int job;
            public string name;
            public int level;
            public int maxSuitLevel;
            public List<int> places;
            public Dictionary<int, EquipSuitPropertyEntry> twoSuitProperties;
            public Dictionary<int, EquipSuitPropertyEntry> fiveSuitProperties;
            public Dictionary<int, bool> eightSuits;
        }

        public struct StarInfo
        {
            public Int2 equipPosition;
            public int starLevel;
            public int maxLevel;
        }

        public struct StrengthenProperty
        {
            public int strengthenLevel;
            public List<Int2> properties;
        }

        public struct GemInfo
        {
            public Dictionary<int, bool> activeStates;
            public Dictionary<int, int> gems;
        }

        public struct TrainProperty
        {
            public int level;
            public List<Int2> properties;
        }

        public struct SkillInfo
        {
            public List<int> skills;
        }

        static PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        static EquipModel equipModel { get { return ModelCenter.Instance.GetModel<EquipModel>(); } }
        static EquipStarModel starModel { get { return ModelCenter.Instance.GetModel<EquipStarModel>(); } }
        static EquipGemModel gemModel { get { return ModelCenter.Instance.GetModel<EquipGemModel>(); } }
        static EquipTrainModel trainModel { get { return ModelCenter.Instance.GetModel<EquipTrainModel>(); } }
        static EquipStrengthModel strengthenModel { get { return ModelCenter.Instance.GetModel<EquipStrengthModel>(); } }

        public static TipType tipType { get; private set; }
        public static TipData mainTipData { get; private set; }
        public static TipData secondaryData { get; private set; }

        public static void Show(TipType type, int itemId)
        {
            tipType = type;
            secondaryData = null;

            var isEquip = ItemLogicUtility.Instance.IsEquip(itemId);
            if (isEquip)
            {
                mainTipData = CreateNormalEquipData(itemId);
            }
            else
            {
                mainTipData = CreateItemData(itemId);
            }

            switch (type)
            {
                case TipType.Normal:
                    if (isEquip)
                    {
                        WindowCenter.Instance.Open<EquipTipWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<ItemTipWin>();
                    }
                    break;
                case TipType.Good:
                    WindowCenter.Instance.Open<GoodTipWin>();
                    break;
            }
        }

        public static void Show(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return;
            }

            secondaryData = null;
            var packType = item.packType;
            var isEquip = ItemLogicUtility.Instance.IsEquip(item.itemId);
            switch (packType)
            {
                case PackType.Equip:
                    tipType = TipType.Normal;
                    mainTipData = CreateNormalEquipData(guid);
                    break;
                default:
                    tipType = TipType.Normal;

                    if (isEquip)
                    {
                        if (item.isAuction)
                        {
                            mainTipData = CreateEquipAuctionData(guid);
                        }
                        else
                        {
                            mainTipData = CreateNormalEquipData(guid);
                            var equipedGuid = equipModel.GetEquip(new Int2(item.config.LV, item.config.EquipPlace));
                            if (equipedGuid != guid)
                            {
                                secondaryData = CreateNormalEquipData(equipedGuid);
                            }
                        }
                    }
                    else
                    {
                        mainTipData = CreateItemData(guid);
                    }
                    break;
            }

            switch (tipType)
            {
                case TipType.Normal:
                    if (isEquip)
                    {
                        WindowCenter.Instance.Open<EquipTipWin>();
                    }
                    else
                    {
                        WindowCenter.Instance.Open<ItemTipWin>();
                    }
                    break;
                case TipType.Good:
                    WindowCenter.Instance.Open<GoodTipWin>();
                    break;
            }
        }

        static TipData CreateNormalEquipData(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(TipData);
            }

            return new TipData()
            {
                itemId = item.itemId,
                guid = guid,

                baseInfo = GetBaseInfo(guid),
                baseProperty = GetBaseProperty(guid),
                legendProperty = GetLegendProperty(guid),
                skillInfo = GetSkillInfo(item.itemId),
                suitInfo = GetSuitInfo(guid),
                starInfo = GetStarInfo(item.itemId),
                strengthenProperty = GetStrengthenProperty(guid),
                gemInfo = GetGemInfo(guid),

                trainProperty = GetTrainProperty(guid),
                operates = GetOperates(guid),
            };
        }

        static TipData CreateNormalEquipData(int itemId)
        {
            return new TipData()
            {
                itemId = itemId,
                guid = string.Empty,

                baseInfo = GetBaseInfo(itemId),
                baseProperty = GetBaseProperty(itemId),
                legendProperty = GetLegendProperty(itemId),
                skillInfo = GetSkillInfo(itemId),
                suitInfo = GetSuitInfo(itemId),
                gemInfo = GetGemInfo(itemId),
            };
        }

        static TipData CreateEquipAuctionData(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(TipData);
            }

            return new TipData()
            {
                itemId = item.itemId,
                guid = guid,

                baseInfo = GetBaseInfo(guid),
                baseProperty = GetBaseProperty(item.itemId),
                legendProperty = GetLegendProperty(item.itemId),
                skillInfo = GetSkillInfo(item.itemId),
                suitInfo = GetSuitInfo(item.itemId),
                operates = GetOperates(guid),
            };
        }

        static TipData CreateItemData(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(TipData);
            }

            return new TipData()
            {
                itemId = item.itemId,
                guid = guid,

                baseInfo = GetBaseInfo(guid),
                operates = GetOperates(guid),
            };
        }

        static TipData CreateItemData(int itemId)
        {
            return new TipData()
            {
                itemId = itemId,
                baseInfo = GetBaseInfo(itemId),
            };
        }

        public static void Operate(ItemOperateType type, string guid)
        {
            switch (type)
            {
                case ItemOperateType.putOn:
                    ItemOperateUtility.Instance.PutOnItem(guid);
                    break;
                case ItemOperateType.putOff:
                    ItemOperateUtility.Instance.PutOffEquip(guid);
                    break;
                case ItemOperateType.putAway:
                    ItemOperateUtility.Instance.PutAway(guid);
                    break;
                case ItemOperateType.putIn:
                    ItemOperateUtility.Instance.PutInWareHouse(guid);
                    break;
                case ItemOperateType.putOut:
                    ItemOperateUtility.Instance.TakeOutFromWarehouse(guid);
                    break;
                case ItemOperateType.sell:
                    var item = packModel.GetItemByGuid(guid);
                    ItemOperateUtility.Instance.SendSellQuest(PackType.Item, item.gridIndex);
                    break;
                case ItemOperateType.strength:
                    ItemOperateUtility.Instance.GotoStrengthen(guid);
                    break;
                case ItemOperateType.star:
                    ItemOperateUtility.Instance.GotoStarUpgrade(guid);
                    break;
                case ItemOperateType.inlay:
                    ItemOperateUtility.Instance.GotoInlayItem(guid);
                    break;
                case ItemOperateType.train:
                    ItemOperateUtility.Instance.GotoTrain(guid);
                    break;
                case ItemOperateType.makeUse:
                    ItemOperateUtility.Instance.GotoUseItem(guid);
                    break;
                case ItemOperateType.split:
                    ItemOperateUtility.Instance.OnClickSplitBtn(guid);
                    break;
            }
        }

        private static BaseInfo GetBaseInfo(int itemId)
        {
            var config = ItemConfig.Get(itemId);
            var baseInfo = new BaseInfo()
            {
                itemId = itemId,
                isAuction = false,
                isEquiped = false,
                score = ItemLogicUtility.Instance.GetEquipScore(PackType.Item, itemId, null, true),
                auctionSurplusTime = 0,
                levelLimit = config.UseLV,
                realmLimit = config.RealmLimit,
            };

            return baseInfo;
        }

        private static BaseInfo GetBaseInfo(string guid)
        {
            var item = packModel.GetItemByGuid(guid);

            var level = item.config.LV;
            var place = item.config.EquipPlace;

            var isEquiped = equipModel.GetEquip(new Int2(level, place)) == guid;

            var type = strengthenModel.GetEquipStrengthType(place);
            var star = starModel.GetEquipStarLevel(new Int2(level, place));
            var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, level);
            var maxStrengthenLevel = strengthenModel.GetEquipLevelMax(type, Mathf.Min(star, maxStar));
            var placeStrengthenLevel = strengthenModel.GetStrengthLevel(level, place);

            var baseInfo = new BaseInfo()
            {
                itemId = item.itemId,
                count = item.count,
                isAuction = item.isAuction,
                isEquiped = isEquiped,
                score = item.score,
                auctionSurplusTime = item.isAuction ? item.auctionSurplusTime : 0,
                levelLimit = item.isAuction ? 0 : item.config.UseLV,
                realmLimit = item.isAuction ? 0 : item.config.RealmLimit,
                star = isEquiped ? star : -1,
                strengthenLevel = Mathf.Min(placeStrengthenLevel, maxStrengthenLevel)
            };

            return baseInfo;
        }

        private static BaseProperty GetBaseProperty(int itemId)
        {
            var baseProperties = new List<Int2>();
            var config = ItemConfig.Get(itemId);

            if (config.Effect1 != 0)
            {
                baseProperties.Add(new Int2(config.Effect1, config.EffectValueA1));
            }

            if (config.Effect2 != 0)
            {
                baseProperties.Add(new Int2(config.Effect2, config.EffectValueA2));
            }

            if (config.Effect3 != 0)
            {
                baseProperties.Add(new Int2(config.Effect3, config.EffectValueA3));
            }

            if (config.Effect4 != 0)
            {
                baseProperties.Add(new Int2(config.Effect4, config.EffectValueA4));
            }

            if (config.Effect5 != 0)
            {
                baseProperties.Add(new Int2(config.Effect5, config.EffectValueA5));
            }

            var baseProperty = new BaseProperty()
            {
                baseProperties = baseProperties,
            };

            return baseProperty;
        }

        private static BaseProperty GetBaseProperty(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            var baseProperty = GetBaseProperty(item.itemId);

            var starProperties = new List<Int2>();
            var currentStar = starModel.GetEquipStarLevel(new Int2(item.config.LV, item.config.EquipPlace));
            var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV);
            var star = Mathf.Min(currentStar, maxStar);
            if (star > 0)
            {
                baseProperty.star = star;
                var starConfig = EquipStarConfig.Get(item.config.LV, item.config.EquipPlace, star);
                starProperties.AddRange(starConfig.BaseAttrInfo);
            }

            baseProperty.starProperties = starProperties;
            return baseProperty;
        }

        private static LegendProperty GetLegendProperty(int itemId)
        {
            var data = new LegendProperty();
            data.isPreview = true;
            data.trueCount = LegendPropertyUtility.GetEquipPropertyCount(itemId);
            data.properties = LegendPropertyUtility.GetEquipProperties(itemId);

            return data;
        }

        private static LegendProperty GetLegendProperty(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(LegendProperty);
            }

            var data = new LegendProperty();
            data.isPreview = false;

            var ids = item.GetUseData(17);
            var values = item.GetUseData(19);
            if (!ids.IsNullOrEmpty() && !values.IsNullOrEmpty())
            {
                var properties = new List<Int2>();
                var count = Mathf.Min(ids.Count, values.Count);
                for (int i = 0; i < count; i++)
                {
                    properties.Add(new Int2(ids[i], values[i]));
                }

                data.properties = properties;
            }

            return data;
        }

        private static SuitInfo GetSuitInfo(int itemId)
        {
            var config = ItemConfig.Get(itemId);
            if (config == null || config.SuiteiD <= 0)
            {
                return default(SuitInfo);
            }

            var job = config.JobLimit;
            var twoConfigs = EquipSuitConfig.GetConfigs(job, config.LV, EquipSuitType.TwoSuit);

            var name = twoConfigs[0].name;
            var level = config.LV;
            var places = new List<int>();
            places.Add(config.EquipPlace);
            var suitInfo = new SuitInfo()
            {
                name = name,
                level = level,
                job = job,
                places = places,
            };

            return suitInfo;
        }

        private static SuitInfo GetSuitInfo(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(SuitInfo);
            }

            var config = ItemConfig.Get(item.itemId);
            if (config == null || config.SuiteiD <= 0)
            {
                return default(SuitInfo);
            }

            var job = config.JobLimit;
            var twoConfigs = EquipSuitConfig.GetConfigs(job, config.LV, EquipSuitType.TwoSuit);

            var name = twoConfigs[0].name;

            var level = config.LV;
            var maxSuitLevel = EquipStarModel.GetMaxStarLevel(level);
            var places = new List<int>();
            for (int i = 1; i <= 8; i++)
            {
                var equip = packModel.GetItemByGuid(equipModel.GetEquip(new Int2(level, i)));
                var hasSuit = equip != null && equip.config.SuiteiD > 0;
                if (hasSuit)
                {
                    places.Add(i);
                }
            }

            var twoSuitProperties = new Dictionary<int, EquipSuitPropertyEntry>();
            var fiveSuitProperties = new Dictionary<int, EquipSuitPropertyEntry>();
            var eightSuits = new Dictionary<int, bool>();
            var eightSuitLevel = equipModel.GetSuitLevel(config.LV, EquipSuitType.EightSuit);

            twoSuitProperties[0] = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.TwoSuit);
            fiveSuitProperties[0] = equipModel.GetEquipSuitEntry(config.LV, 0, EquipSuitType.FiveSuit);
            eightSuits[0] = eightSuitLevel >= 0;

            if (maxSuitLevel >= 3)
            {
                twoSuitProperties[3] = equipModel.GetEquipSuitEntry(config.LV, 3, EquipSuitType.TwoSuit);
                fiveSuitProperties[3] = equipModel.GetEquipSuitEntry(config.LV, 3, EquipSuitType.FiveSuit);
                eightSuits[3] = eightSuitLevel >= 3;
            }

            if (maxSuitLevel >= 6)
            {
                twoSuitProperties[6] = equipModel.GetEquipSuitEntry(config.LV, 6, EquipSuitType.TwoSuit);
                fiveSuitProperties[6] = equipModel.GetEquipSuitEntry(config.LV, 6, EquipSuitType.FiveSuit);
                eightSuits[6] = eightSuitLevel >= 3;
            }

            if (maxSuitLevel >= 9)
            {
                twoSuitProperties[9] = equipModel.GetEquipSuitEntry(config.LV, 9, EquipSuitType.TwoSuit);
                fiveSuitProperties[9] = equipModel.GetEquipSuitEntry(config.LV, 9, EquipSuitType.FiveSuit);
                eightSuits[9] = eightSuitLevel >= 9;
            }

            var suitInfo = new SuitInfo()
            {
                name = name,
                level = level,
                job = job,
                maxSuitLevel = maxSuitLevel,
                places = places,
                twoSuitProperties = twoSuitProperties,
                fiveSuitProperties = fiveSuitProperties,
                eightSuits = eightSuits
            };

            return suitInfo;
        }

        private static StarInfo GetStarInfo(int itemId)
        {
            var config = ItemConfig.Get(itemId);
            if (!EquipModel.IsRealmEquip(config.EquipPlace))
            {
                return default(StarInfo);
            }

            var starInfo = new StarInfo();
            starInfo.equipPosition = new Int2(config.LV, config.EquipPlace);
            starInfo.maxLevel = EquipStarModel.GetMaxStarLevel(config.ItemColor, config.LV);
            starInfo.starLevel = starModel.GetStarLevel(new Int2(config.LV, config.EquipPlace));

            return starInfo;
        }

        private static StrengthenProperty GetStrengthenProperty(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(StrengthenProperty);
            }

            var level = item.config.LV;
            var place = item.config.EquipPlace;
            var data = new StrengthenProperty();

            var strengthenLevel = strengthenModel.GetStrengthLevel(level, place);
            var type = strengthenModel.GetEquipStrengthType(place);
            var star = starModel.GetEquipStarLevel(new Int2(level, place));
            var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV);
            var maxStrengthenLevel = strengthenModel.GetEquipLevelMax(type, Mathf.Min(star, maxStar));

            data.strengthenLevel = Mathf.Min(strengthenLevel, maxStrengthenLevel);

            data.properties = new List<Int2>();
            var config = ItemPlusConfig.GetTypeAndLevel(type, data.strengthenLevel);
            for (int i = 0; i < config.attType.Length; i++)
            {
                data.properties.Add(new Int2(config.attType[i], config.attValue[i]));
            }

            return data;
        }

        private static GemInfo GetGemInfo(int itemId)
        {
            return default(GemInfo);
        }

        private static GemInfo GetGemInfo(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(GemInfo);
            }

            var level = item.config.LV;
            var place = item.config.EquipPlace;
            var gemInfo = new GemInfo();

            var maxStar = EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV);
            gemInfo.activeStates = new Dictionary<int, bool>();
            for (int i = 0; i < 4; i++)
            {
                gemInfo.activeStates[i] = IsEquipGemHoleOpen(new Int2(level, place), maxStar, i);
            }

            gemInfo.gems = new Dictionary<int, int>();
            if (item.packType == PackType.Equip)
            {
                int[] gems;
                if (gemModel.TryGetEquipGems(item.config.LV, item.config.EquipPlace, out gems))
                {
                    for (int i = 0; i < gems.Length; i++)
                    {
                        gemInfo.gems[i] = gems[i];
                    }
                }
            }

            return gemInfo;
        }

        private static TrainProperty GetTrainProperty(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return default(TrainProperty);
            }

            var equipPosition = new Int2(item.config.LV, item.config.EquipPlace);
            var trainProperty = new TrainProperty();

            var star = Mathf.Min(EquipStarModel.GetMaxStarLevel(item.config.ItemColor, item.config.LV), starModel.GetEquipStarLevel(equipPosition));
            var type = EquipTrainModel.GetTrainType(equipPosition.y);
            var maxConfig = WashLevelMaxConfig.Get(type, star);
            var maxLevel = maxConfig == null ? 1 : maxConfig.levelMax;
            var trainLevel = Mathf.Min(maxLevel, trainModel.GetTrainLevel(equipPosition));
            trainProperty.level = trainLevel;

            var trainConfig = EquipWashConfig.Get(type, trainLevel);
            trainProperty.properties = new List<Int2>();

            if (trainConfig == null)
            {
                var trainConfigLevel1 = EquipWashConfig.Get(type, 1);
                trainProperty.properties.Add(new Int2(trainConfigLevel1.config.attType1, 0));
                trainProperty.properties.Add(new Int2(trainConfigLevel1.config.attType2, 0));
                trainProperty.properties.Add(new Int2(trainConfigLevel1.config.attType3, 0));
            }
            else
            {
                var trainedProperties = trainModel.GetTrainedProperties(equipPosition);
                trainProperty.properties.Add(new Int2(trainConfig.config.attType1, Mathf.Min(trainedProperties.x, trainConfig.config.attMax1)));
                trainProperty.properties.Add(new Int2(trainConfig.config.attType2, Mathf.Min(trainedProperties.y, trainConfig.config.attMax2)));
                trainProperty.properties.Add(new Int2(trainConfig.config.attType3, Mathf.Min(trainedProperties.z, trainConfig.config.attMax3)));
            }

            return trainProperty;
        }

        private static SkillInfo GetSkillInfo(int itemId)
        {
            var config = ItemConfig.Get(itemId);
            if (config == null)
            {
                return default(SkillInfo);
            }

            var skillInfo = new SkillInfo();
            skillInfo.skills = new List<int>();

            if (config.AddSkill1 != 0)
            {
                skillInfo.skills.Add(config.AddSkill1);
            }

            if (config.AddSkill2 != 0)
            {
                skillInfo.skills.Add(config.AddSkill2);
            }

            return skillInfo;
        }

        private static List<ItemOperateType> GetOperates(int itemId)
        {
            var config = ItemConfig.Get(itemId);
            var operates = new List<ItemOperateType>();
            if (config.CanSell == 1)
            {
                operates.Add(ItemOperateType.sell);
            }

            if (config.UseTag == 1)
            {
                operates.Add(ItemOperateType.makeUse);
            }

            if (config.Type == 25 || config.Effect1 == 225)
            {
                operates.Add(ItemOperateType.inlay);
            }

            return operates;
        }

        private static List<ItemOperateType> GetOperates(string guid)
        {
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return null;
            }

            var operates = new List<ItemOperateType>();
            var packType = item.packType;

            if (WindowCenter.Instance.IsOpen("DepotWin"))
            {
                switch (packType)
                {
                    case PackType.Warehouse:
                        operates.Add(ItemOperateType.putOut);
                        break;
                    default:
                        operates.Add(ItemOperateType.putIn);
                        break;
                }

                return operates;
            }

            switch (packType)
            {
                case PackType.Equip:
                    if (WindowCenter.Instance.IsOpen("RealmEquipWin"))
                    {
                        operates.Add(ItemOperateType.putOff);

                        if (FuncOpen.Instance.IsFuncOpen(1))
                        {
                            operates.Add(ItemOperateType.strength);
                        }

                        operates.Add(ItemOperateType.star);
                        if (FuncOpen.Instance.IsFuncOpen(1))
                        {
                            operates.Add(ItemOperateType.inlay);
                        }

                        operates.Add(ItemOperateType.train);
                    }
                    break;
                case PackType.Warehouse:
                    operates.Add(ItemOperateType.putOut);
                    break;
                default:
                    if (item.isAuction)
                    {
                        operates.Add(ItemOperateType.putAway);
                    }
                    else
                    {
                        var isEquip = ItemLogicUtility.Instance.IsEquip(item.itemId);
                        if (isEquip)
                        {
                            operates.Add(ItemOperateType.sell);
                            operates.Add(ItemOperateType.putOn);
                        }
                        else
                        {
                            operates.AddRange(GetOperates(item.itemId));
                            if (item.count > 1)
                            {
                                operates.Add(ItemOperateType.split);
                            }
                        }
                    }
                    break;
            }

            return operates;
        }

        private static bool IsEquipGemHoleOpen(Int2 equipPosition, int maxStar, int hole)
        {
            GemHoleCondition condition;
            if (gemModel.TryGetGemHoleCondition(hole, out condition))
            {
                var star = starModel.GetStarLevel(equipPosition);
                if (Mathf.Min(star, maxStar) < condition.equipStar)
                {
                    return false;
                }

                var vipLevel = PlayerDatas.Instance.baseData.VIPLv;
                if (vipLevel < condition.vipLevel)
                {
                    return false;
                }
            }

            return true;
        }

    }

}