using System;
using System.Collections.Generic;
using System.Linq;
using LitJson;
using UnityEngine;

namespace Snxxz.UI
{
    [XLua.LuaCallCSharp]
    public class ItemLogicUtility : Singleton<ItemLogicUtility>
    {
        private string jadeDynastyGSFormula;
        private string dogzGSFormula;
        private string normalGSFormula;

        private int[] preciousItemTypes;
        private int[] drugIDs;
        private int[] onekeySellTypes;
        private int[] pushItemIds;
        private int[] pushBuffTypeIds;

        private List<int> equipBaseProperties = new List<int>();
        private Dictionary<int, int> promptUseLimitDict;
        private Dictionary<int, List<int>> betterEquipExceptDungeonDict;

        PackModel playerPack { get { return ModelCenter.Instance.GetModel<PackModel>(); } }
        ItemTipsModel itemTipsModel { get { return ModelCenter.Instance.GetModel<ItemTipsModel>(); } }
        PlayerBuffDatas buffDatas { get { return ModelCenter.Instance.GetModel<PlayerBuffDatas>(); } }
        PlayerMountDatas mountDatas { get { return ModelCenter.Instance.GetModel<PlayerMountDatas>(); } }
        PlayerPetDatas petDatas { get { return ModelCenter.Instance.GetModel<PlayerPetDatas>(); } }
        PlayerStrengthengDatas strengthDatas { get { return ModelCenter.Instance.GetModel<PlayerStrengthengDatas>(); } }
        MagicianModel magicianModel { get { return ModelCenter.Instance.GetModel<MagicianModel>(); } }
        TrialDungeonModel trialModel { get { return ModelCenter.Instance.GetModel<TrialDungeonModel>(); } }
        ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }

        public void Init()
        {
            var GSFormulaConfig = FuncConfigConfig.Get("EquipGSFormula");
            jadeDynastyGSFormula = GSFormulaConfig.Numerical4;
            dogzGSFormula = GSFormulaConfig.Numerical3;
            normalGSFormula = GSFormulaConfig.Numerical1;

            var baseAttr = JsonMapper.ToObject(GSFormulaConfig.Numerical2);
            if (baseAttr.IsArray)
            {
                for (int i = 0; i < baseAttr.Count; i++)
                {
                    equipBaseProperties.Add(int.Parse(baseAttr[i].ToString()));
                }
            }

            preciousItemTypes = ConfigParse.GetMultipleStr<int>(FuncConfigConfig.Get("ItemPush").Numerical1);
            promptUseLimitDict = ConfigParse.GetDic<int, int>(FuncConfigConfig.Get("NoPromptUsetItem").Numerical1);

            drugIDs = ConfigParse.GetMultipleStr<int>(FuncConfigConfig.Get("LifePotionlist").Numerical1);
            onekeySellTypes = ConfigParse.GetMultipleStr<int>(FuncConfigConfig.Get("OneKeySellItemType").Numerical1);

            pushItemIds = ConfigParse.GetMultipleStr<int>(FuncConfigConfig.Get("IntroductionItem").Numerical1);
            pushBuffTypeIds = ConfigParse.GetMultipleStr<int>(FuncConfigConfig.Get("IntroductionItem").Numerical2);

            betterEquipExceptDungeonDict = new Dictionary<int, List<int>>();
            var excEquipData = JsonMapper.ToObject(FuncConfigConfig.Get("GoodItemDungeon").Numerical1);
            foreach (var dungeonId in excEquipData.Keys)
            {
                var itemIds = new List<int>();
                betterEquipExceptDungeonDict.Add(int.Parse(dungeonId), itemIds);
                for (var i = 0; i < excEquipData[dungeonId].Count; i++)
                {
                    var itemId = int.Parse(excEquipData[dungeonId][i].ToString());
                    itemIds.Add(itemId);
                }
            }

            DTC0102_tagCDBPlayer.beforePlayerDataInitializeEvent += OnBeforePlayerDataInitialize;
        }

        void OnBeforePlayerDataInitialize()
        {
            isPackResetOk = true;
            ClearSortedBetterEquip();
        }

        #region 计算装备评分

        class EquipSorceProperties
        {
            Dictionary<int, int> properties = new Dictionary<int, int>();

            public int this[int id] { get { return properties[id]; } }

            public List<int> Keys { get { return new List<int>(properties.Keys); } }

            void Add(int id, int value)
            {
                if (properties.ContainsKey(id))
                {
                    properties[id] += value;
                }
                else
                {
                    properties[id] = value;
                }
            }

            public void AddRange(List<int> ids, List<int> values)
            {
                if (ids == null || values == null)
                {
                    return;
                }

                var count = Mathf.Min(ids.Count, values.Count);
                for (int i = 0; i < count; i++)
                {
                    Add(ids[i], values[i]);
                }
            }

            public void AddRange(int[] ids, int[] values)
            {
                if (ids == null || values == null)
                {
                    return;
                }

                var length = Mathf.Min(ids.Length, values.Length);
                for (int i = 0; i < length; i++)
                {
                    Add(ids[i], values[i]);
                }
            }

            public void AddRange(Dictionary<int, int> keyValues)
            {
                if (keyValues == null)
                {
                    return;
                }

                foreach (var item in keyValues)
                {
                    properties.Add(item.Key, item.Value);
                }
            }

            public void AddBaseProperties(int itemId, List<int> reference)
            {
                var config = ItemConfig.Get(itemId);
                if (config.Effect1 != 0 && reference.Contains(config.Effect1))
                {
                    properties.Add(config.Effect1, config.EffectValueA1);
                }

                if (config.Effect2 != 0 && reference.Contains(config.Effect2))
                {
                    properties.Add(config.Effect2, config.EffectValueA2);
                }

                if (config.Effect3 != 0 && reference.Contains(config.Effect3))
                {
                    properties.Add(config.Effect3, config.EffectValueA3);
                }

                if (config.Effect4 != 0 && reference.Contains(config.Effect4))
                {
                    properties.Add(config.Effect4, config.EffectValueA4);
                }

                if (config.Effect5 != 0 && reference.Contains(config.Effect5))
                {
                    properties.Add(config.Effect5, config.EffectValueA5);
                }
            }

            public void AddCustomProperties(int itemId)
            {
                if (AppointItemConfig.Has(itemId))
                {
                    return;
                }

                var config = AppointItemConfig.Get(itemId);
                AddRange(config.LegendAttrID, config.LegendAttrValue);
                AddRange(config.OutOfPrintAttr, config.OutOfPrintAttrValue);
            }
        }

        public int GetEquipScore(PackType type, int itemId, Dictionary<int, List<int>> useDataDic = null, bool isPreview = false)
        {
            var config = ItemConfig.Get(itemId);
            var properties = new EquipSorceProperties();

            if (IsCustomItem(itemId))
            {
                properties.AddBaseProperties(config.EffectValueA1, equipBaseProperties);
                properties.AddCustomProperties(itemId);
                return CalculateEquipScore(type, config.EffectValueA1, properties);
            }

            properties.AddBaseProperties(itemId, equipBaseProperties);
            if (isPreview)
            {
                switch (config.EquipPlace)
                {
                    case 11:
                        properties.AddRange(GetWingsLegendProperties(itemId));
                        break;
                    case 1:
                    case 2:
                    case 3:
                    case 4:
                    case 5:
                    case 6:
                    case 7:
                    case 8:
                    case 9:
                    case 10:
                    case 12:
                        properties.AddRange(GetEquipLegendProperties(itemId));
                        break;
                }

                var packType = GeneralDefine.GetPackTypeByItemType(config.Type);
                switch (packType)
                {
                    case PackType.JadeDynastyItem:
                        properties.AddRange(CalculateJadeDynastyLegendAttr(itemId));
                        break;
                }

                return CalculateEquipScore(type, itemId, properties);
            }

            if (useDataDic != null)
            {
                if (useDataDic.ContainsKey((int)ItemUseDataKey.legendAttrID))
                {
                    properties.AddRange(useDataDic[(int)ItemUseDataKey.legendAttrID], useDataDic[(int)ItemUseDataKey.legendAttrValue]);
                }

                if (useDataDic.ContainsKey((int)ItemUseDataKey.outOfPrintAttrID))
                {
                    properties.AddRange(useDataDic[(int)ItemUseDataKey.outOfPrintAttrID], useDataDic[(int)ItemUseDataKey.outOfPrintAttrValue]);
                }
            }

            return CalculateEquipScore(type, itemId, properties);
        }

        private Dictionary<int, int> GetEquipLegendProperties(int itemId)
        {
            var config = ItemConfig.Get(itemId);
            var legendIdlist = new List<int>();

            if (LegendPropertyUtility.HasEquipPlace(config.EquipPlace))
            {
                for (var i = 0; i < 3; i++)
                {
                    var type = (LegendAttrType)i;
                    var count = LegendPropertyUtility.GetEquipPropertyCount(config.ItemColor, config.StarLevel, type);
                    if (count > 0)
                    {
                        var propertyIds = LegendPropertyUtility.GetEquipPlaceProperties(config.EquipPlace, type);
                        legendIdlist.AddRange(propertyIds.GetRange(0, count));
                    }
                }
            }

            var properties = new Dictionary<int, int>();
            for (int i = 0; i < legendIdlist.Count; i++)
            {
                var propertyId = legendIdlist[i];
                var qualityPropertyValue = LegendPropertyUtility.GetEquipQualityPropertyValue(propertyId, config.ItemColor);
                if (qualityPropertyValue != 0)
                {
                    properties[propertyId] = qualityPropertyValue;
                }
                else
                {
                    var levelPropertyValue = LegendPropertyUtility.GetEquipLevelPropertyValue(propertyId, config.LV);
                    if (levelPropertyValue != 0)
                    {
                        properties[propertyId] = levelPropertyValue;
                    }
                }
            }

            return properties;
        }

        public Dictionary<int, int> GetWingsLegendProperties(int itemId)
        {
            var config = ItemConfig.Get(itemId);
            var properties = new Dictionary<int, int>();
            var level = config.LV;
            var count = LegendPropertyUtility.GetWingPropertyCount(level);
            var ids = LegendPropertyUtility.GetWingProperties(level);
            if (ids != null)
            {
                for (var i = 0; properties.Count < count && i < properties.Count; i++)
                {
                    var propertyId = ids[i];
                    properties[propertyId] = LegendPropertyUtility.GetWingPropertyValues(level, propertyId)[0];
                }
            }

            return properties;
        }

        private Dictionary<int, int> CalculateJadeDynastyLegendAttr(int itemId)
        {
            Dictionary<int, int> attrDict = null;
            itemTipsModel.TryGetJadeDynastyLegendAttr(itemId, out attrDict);
            return attrDict;
        }

        bool IsCustomItem(int itemId)
        {
            if (!ItemConfig.Has(itemId))
            {
                return false;
            }

            return ItemConfig.Get(itemId).Effect1 == 220;
        }

        /// <summary>
        /// 得到装备的评分
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        private Dictionary<AttrEnum, float> curEquipAttrDict = new Dictionary<AttrEnum, float>(); //存储当前装备属性对应的数值 key 属性 value 属性值
        private int CalculateEquipScore(PackType type, int itemId, EquipSorceProperties properties)
        {
            var config = ItemConfig.Get(itemId);
            if (config == null || !GeneralDefine.CompareEquipPlaces.Contains(config.EquipPlace))
            {
                return 0;
            }

            Equation.Instance.Clear();
            curEquipAttrDict.Clear();

            var GSProValueDict = EquipGSParamConfig.GetTagGsProValueDict(config.LV, config.ItemColor, config.StarLevel);
            foreach (var key in properties.Keys)
            {
                var attrType = (AttrEnum)key;
                switch (attrType)
                {
                    case AttrEnum.ATKSPEED:
                    case AttrEnum.OnlyFinalHurt:
                    case AttrEnum.PVPAtkBackHP:
                        curEquipAttrDict.Add(attrType, properties[key]);
                        break;
                    default:
                        if (GSProValueDict != null && GSProValueDict.ContainsKey(attrType))
                        {
                            var curProValue = properties[key] * GSProValueDict[attrType];
                            curEquipAttrDict.Add(attrType, curProValue);
                        }
                        else
                        {
                            curEquipAttrDict.Add(attrType, properties[key]);
                        }
                        break;
                }
            }

            foreach (var key in curEquipAttrDict.Keys)
            {
                var propertyConfig = PlayerPropertyConfig.Get((int)key);
                if (propertyConfig != null)
                {
                    Equation.Instance.AddKeyValue(propertyConfig.Parameter, curEquipAttrDict[key]);
                }
            }

            var gSParamModel = EquipGSParamConfig.GetGSModel(config.LV, config.ItemColor, config.StarLevel);
            if (gSParamModel != null)
            {
                Equation.Instance.AddKeyValue("AtkSpeedC", gSParamModel.AtkSpeedC);
            }
            else
            {
                Equation.Instance.AddKeyValue("AtkSpeedC", 0);
            }

            if (type == PackType.Deleted)
            {
                type = GeneralDefine.GetPackTypeByItemType(config.Type);
            }

            switch (type)
            {
                case PackType.DogzEquip:
                case PackType.DogzItem:
                    return Equation.Instance.Eval<int>(dogzGSFormula);
                case PackType.JadeDynastyItem:
                case PackType.JadeDynastyEquip:
                    return Equation.Instance.Eval<int>(jadeDynastyGSFormula);
                default:
                    return Equation.Instance.Eval<int>(normalGSFormula);
            }
        }

        private void ConvertAttrId(int attrId, int attrValue, Dictionary<int, int> keyValues)
        {
            switch ((AttrEnum)attrId)
            {
                case AttrEnum.ATK:
                    if (!keyValues.ContainsKey((int)AttrEnum.MinAtk))
                    {
                        keyValues.Add(((int)AttrEnum.MinAtk), attrValue);
                    }
                    else
                    {
                        keyValues[(int)AttrEnum.MinAtk] += attrValue;
                    }

                    if (!keyValues.ContainsKey((int)AttrEnum.MaxAtk))
                    {
                        keyValues.Add(((int)AttrEnum.MaxAtk), attrValue);
                    }
                    else
                    {
                        keyValues[(int)AttrEnum.MaxAtk] += attrValue;
                    }
                    break;
                default:
                    if (!keyValues.ContainsKey(attrId))
                    {
                        keyValues.Add(attrId, attrValue);
                    }
                    else
                    {
                        keyValues[attrId] += attrValue;
                    }
                    break;
            }
        }
        #endregion

        #region 主界面物品弹框展示
        public event Action<PackType, string> GetPreciousItemEvent; //得到珍品  value 物品的实例ID

        public void RecommendItem(ItemModel item)
        {
            if (item.packType != PackType.Item)
            {
                return;
            }

            if (item.config.UseLV > PlayerDatas.Instance.baseData.LV)
            {
                return;
            }

            if (IsOverdue(item.guid, item.itemId, item.useDataDict))
            {
                return;
            }

            if (!preciousItemTypes.Contains(item.config.Type))
            {
                return;
            }

            if (!IsAbleToUse(item))
            {
                return;
            }

            if (GetPreciousItemEvent != null)
            {
                GetPreciousItemEvent(item.packType, item.guid);
            }
        }

        bool IsAbleToUse(ItemModel item)
        {
            var windowSearch = WindowSearchConfig.Get(item.config.Jump);
            if (windowSearch != null)
            {
                if (!FuncOpen.Instance.IsFuncOpen(windowSearch.Lv) && windowSearch.Lv != 0)
                {
                    return false;
                }
            }

            if (pushItemIds.Contains(item.itemId))
            {
                var itemCnt = playerPack.GetItemCountByID(PackType.Item, item.itemId) - item.count;
                if (itemCnt > 0)
                {
                    return false;
                }
                else
                {
                    if (item.preItemCount > 0)
                    {
                        return false;
                    }
                }
            }

            if (promptUseLimitDict.ContainsKey(item.itemId))
            {
                var playerLv = PlayerDatas.Instance.baseData.LV;
                if (playerLv < promptUseLimitDict[item.itemId])
                {
                    return false;
                }
            }

            ulong canUseCnt = 0;
            if (playerPack.IsReachUseLimit(item.guid, out canUseCnt))
            {
                return false;
            }

            bool isBox = false;
            bool isCanOpen = ModelCenter.Instance.GetModel<BoxGetItemModel>().CheckOpenBoxCondition(item.itemId, out isBox);
            if (isBox)
            {
                if (!isCanOpen)
                {
                    return false;
                }
            }

            if (trialModel.trialTokens.Contains(item.itemId))
            {
                if (!trialModel.IsAnySatisfyExchangeBetter(item.itemId))
                {
                    return false;
                }
            }

            if (playerPack.CheckIsDrugById(item.itemId))
            {
                if (item.config.RealmLimit > PlayerDatas.Instance.baseData.realmLevel)
                {
                    return false;
                }
            }

            switch (item.config.Type)
            {
                case 8:
                    if (buffDatas.BastBuff(item.itemId))
                    {
                        return false;
                    }
                    break;
                case 20:
                    if (magicianModel.IsGodWeaponMaxLevelByItem(item.itemId))
                    {
                        return false;
                    }
                    break;
                case 21:
                    if (!mountDatas.IsHint(HorseEnum.HorseDan, item.itemId))
                    {
                        return false;
                    }
                    break;
                case 22:
                    if (!mountDatas.IsHint(HorseEnum.HorseStone, item.itemId))
                    {
                        return false;
                    }
                    break;
                case 41:
                    if (!mountDatas.IsHint(HorseEnum.HorseDebris, item.itemId))
                    {
                        return false;
                    }
                    break;
                case 26:
                    if (!petDatas.IsHint(PetEnum.PetDebris, item.itemId))
                    {
                        return false;
                    }
                    break;
                case 27:
                    if (!petDatas.IsHint(PetEnum.PetDan, item.itemId))
                    {
                        return false;
                    }
                    break;
                case 28:
                    if (!petDatas.IsHint(PetEnum.PetStone, item.itemId))
                    {
                        return false;
                    }
                    break;
                case 25:
                    if (!ModelCenter.Instance.GetModel<GemModel>().SatisfyBetter(item.itemId))
                    {
                        return false;
                    }
                    break;
                case 39:
                    if (!IsBetterWings(item))
                    {
                        return false;
                    }
                    break;
                case 52:
                    if (!strengthDatas.IsHint(item.itemId))
                    {
                        return false;
                    }
                    break;
                case 127:
                    var error = 0;
                    bool isHaveMakeNum = ItemOperateUtility.Instance.CanUseItem(item.itemPlace, 1, out error);
                    int remainNum = CrossServerOneVsOnePlayerInfo.Instance.GetDayRemainNum();
                    if (!CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch
                        || remainNum > 0
                        || !isHaveMakeNum)
                    {
                        return false;
                    }
                    break;
                default:
                    break;
            }

            switch (item.itemId)
            {
                case 951:
                    if (!CheckIsExtendGrid(item.itemId))
                    {
                        return false;
                    }
                    break;
                case 952:
                    int willTime = HangUpSetModel.Instance.offlinePluginTime + item.config.EffectValueA1;
                    if (HangUpSetModel.Instance.offlinePluginTime >= HangUpSetModel.Instance.maxOfflinePluginTime)
                    {
                        return false;
                    }
                    break;

            }

            return true;
        }

        private bool IsBetterWings(ItemModel item)
        {
            if (item == null)
            {
                return false;
            }

            var putModel = playerPack.GetItemByIndex(PackType.Equip, (int)RoleEquipType.Wing);
            var singlePack = playerPack.GetSinglePack(PackType.Item);
            if (singlePack == null)
            {
                return false;
            }

            int[] composeTypes = item.config.JumpComposeCondi;
            bool isOpenCompose = false;
            if (composeTypes != null && composeTypes.Length >= 3)
            {
                int first = composeTypes[0];
                int second = composeTypes[1];
                int third = composeTypes[2];
                ComposeWinModel.ComposeThirdTypeData thirdTypeData = null;
                composeModel.TryGetThirdTypeData(first, second, third, out thirdTypeData);
                if (thirdTypeData != null)
                {
                    var itemCompound = thirdTypeData.itemCompound;
                    if (itemCompound.levelNeed <= PlayerDatas.Instance.baseData.LV)
                    {
                        isOpenCompose = true;
                    }
                }
            }

            if (!isOpenCompose)
            {
                return false;
            }

            if (putModel != null && putModel.config.LV >= item.config.LV)
            {
                return false;
            }

            var itemModels = singlePack.GetItemsByType((int)ItemType.Wings);
            if (itemModels != null)
            {
                for (int i = 0; i < itemModels.Count; i++)
                {
                    if (itemModels[i].config.JobLimit / 100 == PlayerDatas.Instance.baseData.Job)
                    {
                        if (itemModels[i].config.LV >= item.config.LV)
                        {
                            return false;
                        }
                    }
                }
            }

            return true;
        }

        private bool CheckIsExtendGrid(int itemId)
        {
            SinglePack singlePack = playerPack.GetSinglePack(PackType.Item);
            if (singlePack == null) return false;

            int startLockIndex = singlePack.unlockedGridCount - GeneralDefine.initBagGridCount;
            FuncConfigConfig _tagFuncModel = FuncConfigConfig.Get("OpenBagItem");
            int haveCount = playerPack.GetItemCountByID(PackType.Item, itemId);
            Equation.Instance.Clear();
            Equation.Instance.AddKeyValue("index", startLockIndex + 1);
            int needTool = Equation.Instance.Eval<int>(_tagFuncModel.Numerical2);
            if (haveCount >= needTool)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public event Action<string> GetBetterEquipEvent; //得到更好的装备 value 物品的实例ID

        public void OnGetEquip(ItemModel item)
        {
            if (item == null)
            {
                return;
            }

            if (item.packType != PackType.Item && item.packType != PackType.JadeDynastyItem)
            {
                return;
            }

            if (!IsSameJob(item.config.JobLimit))
            {
                return;
            }

            int equipPlace = item.config.EquipPlace;
            switch ((RoleEquipType)equipPlace)
            {
                case RoleEquipType.Weapon:
                case RoleEquipType.Weapon2:
                case RoleEquipType.Hat:
                case RoleEquipType.Clothes:
                case RoleEquipType.Belt:
                case RoleEquipType.Trousers:
                case RoleEquipType.Shoes:
                case RoleEquipType.Neck:
                case RoleEquipType.FairyCan:
                case RoleEquipType.FairyCan2:
                case RoleEquipType.Wing:
                case RoleEquipType.SpiritAnimal:
                case RoleEquipType.JadeDynasty_Cloak:
                case RoleEquipType.JadeDynasty_FaceMask:
                case RoleEquipType.JadeDynasty_Glove1:
                case RoleEquipType.JadeDynasty_Glove2:
                case RoleEquipType.JadeDynasty_Ruyi:
                case RoleEquipType.JadeDynasty_Pendant:
                case RoleEquipType.JadeDynasty_Ring1:
                case RoleEquipType.JadeDynasty_Ring2:
                case RoleEquipType.JadeDynasty_Sword1:
                case RoleEquipType.JadeDynasty_Sword2:
                case RoleEquipType.JadeDynasty_Sword3:
                case RoleEquipType.JadeDynasty_Sword4:
                    if (betterEquipExceptDungeonDict.ContainsKey(PlayerDatas.Instance.baseData.MapID))
                    {
                        if (betterEquipExceptDungeonDict[PlayerDatas.Instance.baseData.MapID].Contains(item.itemId))
                        {
                            return;
                        }
                    }
                    SetGetBetterEquipEvent(item);
                    break;
            }
        }

        bool IsSameJob(int jobLimit)
        {
            return jobLimit == 0 || jobLimit / 100 == PlayerDatas.Instance.baseData.Job;
        }

        private void SetGetBetterEquipEvent(ItemModel model)
        {
            List<int> itemEffectTime = model.GetUseDataModel((int)ItemUseDataKey.createTime);
            if (itemEffectTime != null)
            {
                if (itemEffectTime[0] != 0)
                {
                    ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(model.guid);
                    double remainTime = 0;
                    if (cool != null)
                    {
                        remainTime = cool.GetRemainTime();
                    }

                    if (remainTime >= 0 && remainTime < 120 && model.config.ExpireTime > 0)
                    {
                        return;
                    }
                }
            }

            int isFightUp = IsFightUp(model.itemId, model.equipScore);
            int equipPlace = model.config.EquipPlace;
            if (isFightUp == 1)
            {
                switch (equipPlace)
                {
                    case 9:
                        break;
                    default:
                        if (model.packType == PackType.Item)
                        {
                            var equipItemModel = playerPack.GetItemByIndex(PackType.Equip, model.config.EquipPlace);
                            if (PlayerDatas.Instance.baseData.LV >= 200)
                            {
                                if (model.equipPlace > (int)RoleEquipType.Weapon2 && model.equipPlace < (int)RoleEquipType.Neck)
                                {
                                    if (equipItemModel != null && equipItemModel.config.ItemColor > model.config.ItemColor)
                                    {
                                        return;
                                    }
                                }
                            }
                        }
                        break;
                }

                if (GetBetterEquipEvent != null)
                {
                    GetBetterEquipEvent(model.guid);
                }

            }
        }

        public event Action<PackType, string> PickItemEvent; //捡起的物品

        public void RefreshPickItem(PackType type, string guid)
        {
            if (type != PackType.Item) return;

            if (PickItemEvent != null)
            {
                PickItemEvent(type, guid);
            }
        }

        Dictionary<int, ItemModel> RealmBetterDict = new Dictionary<int, ItemModel>();
        public Dictionary<int, ItemModel> CheckBetterEquipByRealm()
        {
            RealmBetterDict.Clear();
            SinglePack singlePack = playerPack.GetSinglePack(PackType.Item);
            if (singlePack == null) return RealmBetterDict;

            int realmLv = PlayerDatas.Instance.baseData.realmLevel;
            Dictionary<int, ItemModel> pairs = singlePack.GetAllItems();
            foreach (var model in pairs.Values)
            {
                if (model.config.EquipPlace > 0
                    && model.config.EquipPlace != (int)RoleEquipType.SpiritAnimal
                    && model.config.RealmLimit <= realmLv
                    && !IsOverdue(model.guid, model.itemId, model.useDataDict)
                    && IsFightUp(model.itemId, model.equipScore) == 1)
                {
                    if (!RealmBetterDict.ContainsKey(model.equipPlace))
                    {
                        RealmBetterDict.Add(model.equipPlace, model);
                    }
                    else
                    {
                        if (model.equipScore > RealmBetterDict[model.equipPlace].equipScore)
                        {
                            RealmBetterDict[model.equipPlace] = model;
                        }
                    }
                }
            }
            return RealmBetterDict;
        }

        List<ItemModel> RealmDruglist = new List<ItemModel>();
        public List<ItemModel> GetDruglistByRealm()
        {
            RealmDruglist.Clear();
            SinglePack singlePack = playerPack.GetSinglePack(PackType.Item);
            if (singlePack == null) return RealmDruglist;

            int realmLv = PlayerDatas.Instance.baseData.realmLevel;
            Dictionary<int, ItemModel> pairs = singlePack.GetAllItems();
            foreach (var model in pairs.Values)
            {
                if (playerPack.CheckIsDrugById(model.itemId))
                {
                    AttrFruitConfig fruitConfig = AttrFruitConfig.Get(model.itemId);
                    if (!playerPack.IsReachMaxUseDrug(fruitConfig)
                        && model.config.RealmLimit <= realmLv)
                    {
                        RealmDruglist.Add(model);
                    }
                }
            }
            return RealmDruglist;
        }
        #endregion

        #region 物品处于CD中的逻辑处理

        private List<string> itemEffectTimelist = new List<string>(); //key 物品实例ID
        /// <summary>
        /// 物品使用时间限制
        /// </summary>
        public void SetItemEffectCDTime(string guid, int itemID, int getTime, int serverSurplusTime)
        {
            double time = GetTimeOffest(TimeUtility.GetTime((uint)getTime));
            if (time < 0)
            {
                time = 0;
            }

            ItemConfig itemConfig = ItemConfig.Get(itemID);
            if (time >= itemConfig.ExpireTime)
            {
                KnapsackTimeCDMgr.Instance.UnRegister(guid);
                return;
            }
            double remainTime = (serverSurplusTime > 0 ? serverSurplusTime : itemConfig.ExpireTime) - time;
            KnapsackTimeCDMgr.Instance.Register(guid, itemID, remainTime);
        }

        public double GetTimeOffest(DateTime getTime)
        {
            DebugEx.Log("现在时间：" + TimeUtility.ServerNow + "获得时间:" + getTime);
            //TimeUtility.SyncServerTime();
            TimeSpan t = TimeUtility.ServerNow - getTime;
            DebugEx.Log("时间差：" + t.TotalSeconds);
            return t.TotalSeconds;
        }

        #endregion

        #region 设置可以一键出售的物品数据

        private int playerLv;
        private Dictionary<int, List<ItemModel>> _lifePotionDict = new Dictionary<int, List<ItemModel>>(); //key 药水等级
        private List<int> _sellItemScorelist = new List<int>();
        private Dictionary<int, Dictionary<int, List<ItemModel>>> _sameIndexEquipDict = new Dictionary<int, Dictionary<int, List<ItemModel>>>();  //存储相同装备位的装备
                                                                                                                                                  // private  _sameEquipScoreDict = new Dictionary<int, List<ItemModel>>(); //存储相同ID中相同装备评分的装备
        private Dictionary<int, ItemModel> _packModelDict;
        private List<ItemModel> _sellItemlist = new List<ItemModel>();

        public List<ItemModel> GetSellItemList()
        {
            GetOneKeySellModel();
            _sellItemlist.Sort(SetSellItemOrder);
            return _sellItemlist;
        }

        public int SetSellItemOrder(ItemModel startModel, ItemModel endModel)
        {
            bool startIsEquip = IsEquip(startModel);
            bool endIsEquip = IsEquip(endModel);
            if (startIsEquip.CompareTo(endIsEquip) != 0) return -startIsEquip.CompareTo(endIsEquip);
            int order1 = startModel.config.Type;
            int order2 = endModel.config.Type;
            if (order1.CompareTo(order2) != 0) return order1.CompareTo(order2);
            int color1 = startModel.config.ItemColor;
            int color2 = endModel.config.ItemColor;
            if (color1.CompareTo(color2) != 0) return -color1.CompareTo(color2);
            int code1 = startModel.itemId;
            int code2 = endModel.itemId;
            if (code1.CompareTo(code2) != 0) return -code1.CompareTo(code2);
            return 0;
        }

        public bool IsEquip(ItemModel model)
        {
            return model.config.EquipPlace != 0;
        }

        public void GetOneKeySellModel()
        {
            SinglePack singlePack = playerPack.GetSinglePack(PackType.Item);
            if (singlePack == null)
                return;

            _sellItemlist.Clear();
            _lifePotionDict.Clear();
            _sameIndexEquipDict.Clear();
            _sellItemScorelist.Clear();
            playerLv = PlayerDatas.Instance.baseData.LV;
            _packModelDict = singlePack.GetAllItems();
            foreach (var key in _packModelDict.Keys)
            {
                GetCanSellEquipList(_packModelDict[key]);
                ItemModel itemModel = _packModelDict[key];
                if (drugIDs.Contains(itemModel.itemId))
                {
                    if (!_lifePotionDict.ContainsKey(itemModel.config.LV))
                    {
                        List<ItemModel> modellist = new List<ItemModel>();
                        modellist.Add(itemModel);
                        _lifePotionDict.Add(itemModel.config.LV, modellist);
                    }
                    else
                    {
                        _lifePotionDict[itemModel.config.LV].Add(itemModel);
                    }
                }
            }

            #region 得到可以出售的装备
            foreach (var key in _sameIndexEquipDict.Keys)
            {
                _sellItemScorelist = _sameIndexEquipDict[key].Keys.ToList();
                _sellItemScorelist.Sort();
                if (_sellItemScorelist.Count > 0)
                {
                    int score = 0;
                    int curJob = PlayerDatas.Instance.baseData.Job;
                    for (score = _sellItemScorelist.Count - 1; score > -1; score--)
                    {
                        SinglePack equipPack = playerPack.GetSinglePack(PackType.Equip);
                        ItemModel model = null;
                        if (equipPack != null)
                        {
                            model = equipPack.GetItemByIndex(key);
                        }

                        List<ItemModel> modellist = _sameIndexEquipDict[key][_sellItemScorelist[score]];
                        int i = 0;
                        bool remainBetter = true;
                        for (i = 0; i < modellist.Count; i++)
                        {
                            double joblimit = Math.Floor((double)modellist[i].config.JobLimit / 100);
                            if (model != null)
                            {
                                if (remainBetter)
                                {
                                    if (model.equipScore < _sellItemScorelist[score] && curJob == joblimit)
                                    {
                                        _sameIndexEquipDict[key].Remove(_sellItemScorelist[score]);
                                        remainBetter = false;
                                        break;
                                    }
                                }

                            }
                            else
                            {
                                if (curJob == joblimit)
                                {
                                    if (remainBetter)
                                    {
                                        _sameIndexEquipDict[key].Remove(_sellItemScorelist[score]);
                                        remainBetter = false;
                                        break;
                                    }
                                }
                            }
                        }

                        if (!remainBetter)
                        {
                            break;
                        }

                    }
                    int j = 0;
                    for (j = 0; j < _sellItemScorelist.Count; j++)
                    {

                        if (_sameIndexEquipDict[key].ContainsKey(_sellItemScorelist[j]))
                        {
                            int k = 0;
                            List<ItemModel> sellModlelist = _sameIndexEquipDict[key][_sellItemScorelist[j]];
                            for (k = 0; k < sellModlelist.Count; k++)
                            {
                                _sellItemlist.Add(sellModlelist[k]);
                            }
                        }
                    }

                }

            }
            #endregion

            List<int> drugLvlist = new List<int>();
            drugLvlist.AddRange(_lifePotionDict.Keys.ToList());
            drugLvlist.Sort();
            for (int i = drugLvlist.Count - 1; i > -1; i--)
            {
                if (drugLvlist[i] > playerLv)
                {
                    _lifePotionDict.Remove(drugLvlist[i]);
                }
                else
                {
                    _lifePotionDict.Remove(drugLvlist[i]);
                    break;
                }
            }

            foreach (var list in _lifePotionDict.Values)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    _sellItemlist.Add(list[i]);
                }

            }
        }


        //得到满足出售条件的装备列表
        public void GetCanSellEquipList(ItemModel model)
        {

            if (model.config.EquipPlace == 0 || !onekeySellTypes.Contains(model.config.Type))
                return;

            Dictionary<int, List<ItemModel>> sameScoreDict;
            List<ItemModel> sameScorelist;

            if (model.config.ItemColor < 3)
            {
                if (!_sameIndexEquipDict.ContainsKey(model.config.EquipPlace))
                {
                    sameScoreDict = new Dictionary<int, List<ItemModel>>();
                    sameScorelist = new List<ItemModel>();
                    sameScorelist.Add(model);
                    sameScoreDict.Add(model.equipScore, sameScorelist);
                    _sameIndexEquipDict.Add(model.config.EquipPlace, sameScoreDict);

                }
                else
                {
                    if (_sameIndexEquipDict[model.config.EquipPlace].ContainsKey(model.equipScore))
                    {
                        _sameIndexEquipDict[model.config.EquipPlace][model.equipScore].Add(model);
                    }
                    else
                    {
                        sameScorelist = new List<ItemModel>();
                        sameScorelist.Add(model);
                        _sameIndexEquipDict[model.config.EquipPlace].Add(model.equipScore, sameScorelist);
                    }

                }
            }


        }

        #endregion

        #region 发送请求
        /// <summary>
        /// 一键出售物品的请求
        /// </summary>
        /// <param name="_oneKeySelllist"></param>
        public void SendOneKeySellQuest(List<ItemModel> _oneKeySelllist)
        {
            if (!isPackResetOk || SettingEffectMgr.Instance.isStartOneKeySell) return;

            SettingEffectMgr.Instance.isStartOneKeySell = true;
            byte[] itemIndexs = new byte[_oneKeySelllist.Count];
            int i = 0;
            for (i = 0; i < _oneKeySelllist.Count; i++)
            {
                itemIndexs[i] = (byte)_oneKeySelllist[i].itemPlace;
            }
            CA311_tagCMSellItem sellItem = new CA311_tagCMSellItem();
            sellItem.PackType = (int)PackType.Item;
            sellItem.Count = (byte)_oneKeySelllist.Count;
            sellItem.ItemIndex = itemIndexs;
            GameNetSystem.Instance.SendInfo(sellItem);
        }

        /// <summary>
        /// 整理包裹物品
        /// </summary>
        /// <param name="type"></param>
        public bool isPackResetOk { get; set; }
        public void SendPackResetQuest(PackType type)
        {
            if (lookLineIndex > -1)
            {
                SetLookIndex(null);
            }

            if (KnapSackWin.titleType == KnapsackFuncTitle.bag)
            {
                playerPack.isPlayBetterEquipEffect = true;
            }

            SinglePack singlePack = playerPack.GetSinglePack(type);
            if (singlePack != null)
            {
                C070F_tagCItemPackReset packReset = new C070F_tagCItemPackReset();
                packReset.Type = (byte)type;
                packReset.ItemBeginIndex = 0;
                packReset.ItemEndIndex = (ushort)(singlePack.unlockedGridCount - 1);
                GameNetSystem.Instance.SendInfo(packReset); //整理物品
                if (type == PackType.Item)
                {
                    isPackResetOk = false;
                }
            }
        }
        #endregion

        #region 查看某个位置的物品
        public event Action lookEquipEvent;
        private int _lookLineIndex = -1;
        public int lookLineIndex { get { return _lookLineIndex; } private set { _lookLineIndex = value; } }

        public string lookItemGUID { get; private set; }

        public void SetLookIndex(string guid, int singleRowCount = 5)
        {

            if (string.IsNullOrEmpty(guid) || guid == "")
            {
                lookLineIndex = -1;
            }
            else
            {
                int index = playerPack.GetItemByGuid(guid).itemPlace;
                lookLineIndex = index / singleRowCount;
                lookItemGUID = guid;
            }

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

        }
        #endregion

        #region 判断是否有更好的装备替换
        /// <summary>
        /// 过滤装备位判断
        /// </summary>
        /// <param name="ignoreType"></param>
        /// <returns></returns>
        public bool CheckBetterEquip(RoleEquipType ignoreType)
        {
            SinglePack singlePack = playerPack.GetSinglePack(PackType.Equip);
            if (singlePack != null)
            {
                Dictionary<int, ItemModel> putOnDic = singlePack.GetAllItems();
                foreach (var key in putOnDic.Keys)
                {
                    if ((RoleEquipType)key == ignoreType)
                    {
                        continue;
                    }
                    if (key < 13)
                    {
                        List<ItemModel> itemlist = GetSameEquipPlacelist(key);
                        int i = 0;
                        for (i = 0; i < itemlist.Count; i++)
                        {
                            bool isOverdue = IsOverdue(itemlist[i].guid, itemlist[i].itemId, itemlist[i].useDataDict);
                            bool isRealm = PlayerDatas.Instance.baseData.realmLevel >= itemlist[i].config.RealmLimit ? true : false;
                            if (itemlist[i].equipScore > putOnDic[key].equipScore && !isOverdue && isRealm)
                            {
                                return true;
                            }
                        }
                    }
                }
            }
            else
            {
                int i = 1;
                for (i = 1; i < 13; i++)
                {
                    List<ItemModel> itemlist = GetSameEquipPlacelist(i);
                    if (itemlist.Count > 0)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private List<ItemModel> GetSameEquipPlacelist(int equipPlace)
        {
            List<ItemModel> modellist = new List<ItemModel>();
            Dictionary<int, ItemModel> dic = null;
            SinglePack singlePack = playerPack.GetSinglePack(PackType.Item);
            if (singlePack != null)
            {
                dic = singlePack.GetAllItems();
                foreach (var model in dic.Values)
                {
                    if (model.config.EquipPlace == equipPlace)
                    {
                        double equipJob = Math.Floor((double)model.config.JobLimit / 100);
                        if (equipJob == 0 || equipJob == PlayerDatas.Instance.baseData.Job)
                        {
                            modellist.Add(model);
                        }
                    }
                }
            }
            return modellist;
        }

        /// <summary>
        /// 获取装备评分最高可提升战力的装备
        /// </summary>
        /// <param name="_places"></param>
        /// <returns></returns>
        public string GetHighestScoreEquipByPlace(int equipPlace)
        {
            var itemPackage = playerPack.GetSinglePack(PackType.Item);
            var allItems = itemPackage.GetAllItems();
            ItemModel putModel = playerPack.GetItemByIndex(PackType.Equip, equipPlace);
            equipPlace = (equipPlace == 9 || equipPlace == 10) ? 9 : equipPlace;
            var guid = string.Empty;
            var equips = new List<string>();
            var score = putModel == null ? 0 : putModel.equipScore;
            var job = PlayerDatas.Instance.baseData.Job;
            foreach (var item in allItems.Values)
            {
                if (item.config.EquipPlace == equipPlace)
                {
                    if (!IsOverdue(item.guid, item.itemId, item.useDataDict)
                       && (item.config.JobLimit == 0 || (item.config.JobLimit / 100) == job) && item.equipScore > score)
                    {
                        guid = item.guid;
                        score = item.equipScore;
                    }
                }
            }

            return guid;
        }
        #endregion

        #region 背包整理后好的同类型最好的装备
        Dictionary<int, Dictionary<int, ItemModel>> itemModelDict = new Dictionary<int, Dictionary<int, ItemModel>>();  // key1 装备位置索引 key2 背包位置索引

        public void ClearSortedBetterEquip()
        {
            itemModelDict.Clear();
        }

        public void SetBagSortBetterEquipList(ItemModel itemModel)
        {
            if (itemModel == null || itemModel.packType != PackType.Item) return;

            if (!IsCanPutOn(itemModel)) return;

            int equipPlace = itemModel.config.EquipPlace;
            if (!itemModelDict.ContainsKey(equipPlace))
            {
                Dictionary<int, ItemModel> dict = new Dictionary<int, ItemModel>();
                if (IsFightUp(itemModel.itemId, itemModel.equipScore) == 1)
                {
                    dict.Add(itemModel.itemPlace, itemModel);
                    itemModelDict.Add(equipPlace, dict);
                }
            }
            else
            {
                if (IsFightUp(itemModel.itemId, itemModel.equipScore) == 1)
                {
                    itemModelDict[equipPlace].Add(itemModel.itemPlace, itemModel);
                }
            }

        }

        public ItemModel GetBagSortBetterEquip(int equipPlace, int index)
        {
            ItemModel itemModel = null;
            if (itemModelDict.ContainsKey(equipPlace))
            {
                itemModelDict[equipPlace].TryGetValue(index, out itemModel);
            }
            return itemModel;
        }

        public bool IsCanPutOn(ItemModel itemModel)
        {
            double equipJob = Math.Floor((double)itemModel.config.JobLimit / 100);
            int playerJob = PlayerDatas.Instance.baseData.Job;
            int equipPlace = itemModel.config.EquipPlace;
            if (equipPlace == 0 || equipPlace > 12) return false;
            if (equipJob != 0 && equipJob != playerJob) return false;

            List<int> putOnlimitList = itemModel.GetUseDataModel((int)ItemUseDataKey.cancelUseLimit);
            if (putOnlimitList != null)
            {
                if (putOnlimitList[0] == 1)
                {
                    return true;
                }
            }

            return CheckPutOnRealm(itemModel.config);
        }

        private bool CheckPutOnRealm(ItemConfig config)
        {
            var _realmLv = config.RealmLimit;
            if (PlayerDatas.Instance.baseData.realmLevel < _realmLv)
            {
                return false;
            }
            return true;
        }
        #endregion

        #region 得到物品的品质颜色
        private Dictionary<int, int> wingRefineQualityDict;
        private int[] wingsQualitys;
        private int[] wingsRefineExps;
        public int GetItemQuality(int itemId, Dictionary<int, List<int>> useDataDic = null)
        {
            wingsQualitys = null;
            wingsRefineExps = null;
            ItemConfig itemConfig = ItemConfig.Get(itemId);
            wingRefineQualityDict = WingRefineAttrConfig.GetWingsQualityModel(itemConfig.LV);
            if (useDataDic != null)
            {
                if (useDataDic.ContainsKey(42) && wingRefineQualityDict != null)
                {
                    wingsQualitys = wingRefineQualityDict.Keys.ToArray();
                    wingsRefineExps = wingRefineQualityDict.Values.ToArray();
                    int i = 0;
                    for (i = wingsRefineExps.Length - 1; i > -1; i--)
                    {
                        if (useDataDic[42][0] >= wingsRefineExps[i])
                        {
                            return wingsQualitys[i];
                        }
                    }
                }
            }
            return itemConfig.ItemColor;
        }
        #endregion

        //设置玩家货币显示
        public string OnChangeCoinsUnit(ulong value)
        {

            string strCoins = value.ToString();
            if (strCoins.Length > 4 && strCoins.Length < 9)
            {
                double coins = Math.Floor((double)value / 10000);
                strCoins = coins + Language.Get("KnapS114");
            }
            else if (strCoins.Length >= 9 && strCoins.Length < 13)
            {
                double coins = Math.Floor((double)value / 100000000);
                strCoins = coins + Language.Get("KnapS115");
            }
            else if (strCoins.Length >= 13 && strCoins.Length < 19)
            {
                double coins = Math.Floor((double)value / 1000000000000);
                strCoins = coins + Language.Get("KnapS126");
            }
            else if (strCoins.Length >= 19)
            {
                ServerTipDetails.DisplayNormalTip(Language.Get("KnapS127"));
            }
            return strCoins;
        }

        /// <summary>
        /// 装备是否可以提升战力
        /// </summary>
        /// <param name="_itemID"></param>
        /// <param name="_score"></param>
        /// <returns></returns>
        public int IsFightUp(int _itemID, int _score)//-1低级，0不是本职业，1更好
        {
            ItemConfig chinItemModel = ItemConfig.Get(_itemID);
            if (chinItemModel != null)
            {
                ItemModel putOnModel = null;
                switch ((RoleEquipType)chinItemModel.EquipPlace)
                {
                    case RoleEquipType.Clothes:
                    case RoleEquipType.FairyCan:
                    case RoleEquipType.Belt:
                    case RoleEquipType.Hat:
                    case RoleEquipType.Neck:
                    case RoleEquipType.Shoes:
                    case RoleEquipType.SpiritAnimal:
                    case RoleEquipType.Trousers:
                    case RoleEquipType.Weapon:
                    case RoleEquipType.Weapon2:
                    case RoleEquipType.Wing:
                        putOnModel = playerPack.GetItemByIndex(PackType.Equip, chinItemModel.EquipPlace);
                        break;
                    case RoleEquipType.JadeDynasty_Cloak:
                    case RoleEquipType.JadeDynasty_FaceMask:
                    case RoleEquipType.JadeDynasty_Glove1:
                    case RoleEquipType.JadeDynasty_Pendant:
                    case RoleEquipType.JadeDynasty_Ring1:
                    case RoleEquipType.JadeDynasty_Ruyi:
                    case RoleEquipType.JadeDynasty_Sword1:
                    case RoleEquipType.JadeDynasty_Sword2:
                    case RoleEquipType.JadeDynasty_Sword3:
                    case RoleEquipType.JadeDynasty_Sword4:
                        putOnModel = playerPack.GetItemByIndex(PackType.JadeDynastyEquip, chinItemModel.EquipPlace);
                        break;
                    default:
                        return 0;
                }

                ItemModel putOnModel2 = null;
                switch ((RoleEquipType)chinItemModel.EquipPlace)
                {
                    case RoleEquipType.FairyCan:
                        putOnModel2 = playerPack.GetItemByIndex(PackType.Equip, (int)RoleEquipType.FairyCan2);
                        break;
                    case RoleEquipType.JadeDynasty_Glove1:
                        putOnModel2 = playerPack.GetItemByIndex(PackType.JadeDynastyEquip, (int)RoleEquipType.JadeDynasty_Glove2);
                        break;
                    case RoleEquipType.JadeDynasty_Ring1:
                        putOnModel2 = playerPack.GetItemByIndex(PackType.JadeDynastyEquip, (int)RoleEquipType.JadeDynasty_Ring2);
                        break;
                }

                switch ((RoleEquipType)chinItemModel.EquipPlace)
                {
                    case RoleEquipType.FairyCan:
                    case RoleEquipType.JadeDynasty_Glove1:
                    case RoleEquipType.JadeDynasty_Ring1:
                        if (putOnModel2 != null)
                        {
                            if (putOnModel != null)
                            {
                                if (putOnModel2.equipScore < putOnModel.equipScore)
                                {
                                    putOnModel = putOnModel2;
                                }
                            }
                        }
                        else
                        {
                            putOnModel = putOnModel2;
                        }
                        break;
                }

                int equipScore1 = 0;
                if (putOnModel != null)
                {
                    equipScore1 = (int)putOnModel.equipScore;
                }

                int playerJob = PlayerDatas.Instance.baseData.Job;

                if (playerJob == Math.Floor((double)chinItemModel.JobLimit / 100) || chinItemModel.JobLimit == 0)
                {
                    if (equipScore1 > _score)
                        return -1;
                    else if (equipScore1 < _score)
                        return 1;
                    else
                        return 0;
                }
                else
                {
                    return 0;
                }
            }
            return 0;
        }

        #region 物品是否过期
        public bool IsOverdue(string guid, int itemId, Dictionary<int, List<int>> useDataDict = null)
        {
            ItemConfig itemConfig = ItemConfig.Get(itemId);
            if (itemConfig == null) return false;

            if (itemConfig.ExpireTime > 0)
            {
                ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(guid);
                switch ((EquipReduceType)itemConfig.EndureReduceType)
                {
                    case EquipReduceType.Def_EquipReduceType_Time:
                        if (guid != "")
                        {
                            List<int> itemEffectTime = null;
                            if (useDataDict != null)
                            {
                                if (useDataDict.ContainsKey((int)ItemUseDataKey.createTime))
                                {
                                    itemEffectTime = useDataDict[(int)ItemUseDataKey.createTime];
                                }
                            }

                            if (itemEffectTime != null && itemEffectTime[0] != 0)
                            {
                                if (cool == null || cool.GetRemainTime() <= 0)
                                {
                                    return true;
                                }
                            }
                        }
                        break;

                    case EquipReduceType.Def_EquipReduceType_RTimeItem:
                        if (guid != "")
                        {
                            if (cool == null || cool.GetRemainTime() <= 0)
                            {
                                return true;
                            }
                        }
                        break;

                }
            }

            return false;
        }
        #endregion
    }
}