// ***********************************************************************
// Assembly         : Unity
// Author           : Kimch
// Created          : 2019-06-05
// Description      :
// Last Modified By : 
// Last Modified On : 
// ***********************************************************************
// <copyright file= "PlayerProxy" company="Kunpo"></copyright>
// <summary></summary>
// ***********************************************************************
using CodeStage.AntiCheat.ObscuredTypes;
using F;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

namespace G
{
    /// <summary>
    /// 
    /// </summary>
    partial class PlayerProxy
    {
        #region 角色装备 

        /// <summary>
        /// 装备槽
        /// </summary>
        public class EquipmentSlotInfo
        {
            public readonly int id;

            #region Grade


            private ObscuredInt _grade;
            /// <summary>
            /// 
            /// </summary>
            public int grade
            {
                get { return _grade; }
                set { _grade = value; }
            }

            public int maxGrade
            {
                get { return curEquipment != null ? curEquipment.level + 9 : 0; }
            }

            /// <summary>
            /// 强化战力
            /// </summary>
            public int gradeCombatValue
            {
                get;
                private set;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="value"></param>
            public void SetGrade(int value)
            {
                grade = value;
                if (curEquipment != null)
                {
                    gradeCombatValue = curEquipment.SetGrade(this.grade, upgradeAttributes);
                }
            }

            #endregion

            #region Suit

            /// <summary>
            /// 
            /// </summary>
            private ObscuredInt _slotSuitGrade;

            /// <summary>
            /// 
            /// </summary>
            public int slotSuitGrade
            {
                get { return _slotSuitGrade; }
                set { _slotSuitGrade = value; }
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="value"></param>
            public void SetSlotSuitGrade(int value)
            {
                slotSuitGrade = value;
            }

            public ItemSuit slotSuitItem
            {
                get { return ItemProxy.Instance.GetStaticItem<ItemSuit>(1); }
            }

            #endregion

            #region Gem

            public const int MAX_GEM_COUNT = 3;

            /// <summary>
            /// 
            /// </summary>
            public readonly EntityItemGem[] gems = new EntityItemGem[MAX_GEM_COUNT];

            /// <summary>
            /// 宝石开启
            /// </summary>
            public bool gemEnabled
            {
                get { return this.equipment != null; }
            }

            /// <summary>
            /// 最大可镶嵌宝石数量
            /// </summary>
            public int setGemCountMax
            {
                get
                {
                    int tmpGrade = this.grade;
                    if (tmpGrade >= 80)
                    {
                        return 3;
                    }
                    else if (tmpGrade >= 60)
                    {
                        return 2;
                    }
                    else if (tmpGrade >= 40)
                    {
                        return 1;
                    }
                    else
                    {
                        return 0;
                    }
                }
            }

            public int GetGemUnlockGrade(int index)
            {
                if (index == 1)
                {
                    return 40;
                }
                else if (index == 2)
                {
                    return 60;
                }
                else if (index == 3)
                {
                    return 80;
                }
                else
                {
                    return 40;
                }
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="index"></param>
            /// <returns></returns>
            public EntityItemGem GetGem(int index)
            {
                if (index >= 0 & index < MAX_GEM_COUNT)
                {
                    return gems[index];
                }
                return null;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="gemId"></param>
            /// <returns></returns>
            public bool SetGem(int index, int gemId)
            {
                if (gemId > 0 && index < MAX_GEM_COUNT)
                {
                    gems[index] = ItemProxy.Instance.NewTemporaryGem(gemId);
                }
                return true;
            }

            #endregion

            /// <summary>
            /// 
            /// </summary>
            public EntityItemEquipment curEquipment;
            /// <summary>
            /// 试用装备
            /// </summary>
            public EntityItemEquipment tryEquipment;

            /// <summary>
            /// 升级属性
            /// </summary>
            public readonly List<CombatAttribute> upgradeAttributes = new List<CombatAttribute>(1);

            public int equipmentId
            {
                get { return curEquipment != null ? curEquipment.id : 0; }
            }

            /// <summary>
            /// 
            /// </summary>
            public EntityItemEquipment equipment
            {
                get { return tryEquipment ?? curEquipment; }
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="equipment"></param>
            /// <returns></returns>
            public bool IsSetEquipment(EntityItemEquipment equipment)
            {
                return equipmentId == equipment.id;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="equipment"></param>
            /// <returns></returns>
            public bool SetEquipment(EntityItemEquipment equipment)
            {
                if (equipment.id == this.equipmentId)
                {
                    return false;
                }
                curEquipment = equipment;
                if (curEquipment != null)
                {
                    curEquipment.SetGrade(this.grade, upgradeAttributes);
                }
                return true;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="equipmentId"></param>
            /// <returns></returns>
            public bool SetEquipment(int equipmentId)
            {
                if (this.equipmentId == equipmentId)
                {
                    return false;
                }
                curEquipment = ItemProxy.Instance.GetEquipment(equipmentId);
                if (curEquipment != null)
                {
                    gradeCombatValue = curEquipment.SetGrade(this.grade, upgradeAttributes);
                }
                return true;
            }

            public EquipmentSlotInfo(int id)
            {
                this.id = id;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="results"></param>
            /// <returns></returns>
            public int GetAttributes(List<CombatAttribute> results)
            {
                int resultCombatValue = 0;
                var tmp = this.equipment;
                if (tmp != null)
                {
                    results.Add(tmp.basicAttribute);
                    results.AddRange(tmp.extraAttributes);
                    results.AddRange(tmp.specialAttributes);
                    results.AddRange(upgradeAttributes);
                    resultCombatValue = tmp.combatValue + gradeCombatValue;
                }

                for (int i = 0; i < gems.Length; i++)
                {
                    if (gems[i] != null)
                    {
                        results.Add(gems[i].attribute);
                        resultCombatValue += gems[i].combatValue;
                    }
                }
                return resultCombatValue;
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private readonly EquipmentSlotInfo[] _equipmentSlots = new EquipmentSlotInfo[(int)Item.EquipmentType.kMax];

        /// <summary>
        /// 
        /// </summary>
        private void InitEquipmentSlots()
        {
            for (int i = 0; i < _equipmentSlots.Length; i++)
            {
                _equipmentSlots[i] = new EquipmentSlotInfo(i);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public int GetValidEquipmentSlotCount()
        {
            int result = 0;
            for (int i = 0; i < _equipmentSlots.Length; i++)
            {
                if (_equipmentSlots[i].curEquipment != null)
                    result++;
            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public EquipmentSlotInfo GetEquipmentSlot(EntityItemEquipment equipment)
        {
            if (equipment != null)
            {
                var result = _equipmentSlots[equipment.equipmentType];
                if (result.IsSetEquipment(equipment))
                    return result;
            }
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public EquipmentSlotInfo GetEquipmentSlot(int index)
        {
            if (index < _equipmentSlots.Length)
            {
                return _equipmentSlots[index];
            }
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public EquipmentSlotInfo[] GetEquipmentSlots()
        {
            return _equipmentSlots;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index"></param>
        /// <param name="onekey"></param>
        /// <returns></returns>
        public bool UpgradeEquipmentSlot(int index, bool onekey, bool sendNotification)
        {
            var equipment = _equipmentSlots[index].curEquipment;
            if (equipment == null)
            {
                return false;
            }
            int maxGrade = equipment.level + 9;
            int tmpGrade = _equipmentSlots[index].grade;
            if (tmpGrade >= maxGrade)
            {
                PostNotification(GlobalDefine.EVENT_SHOW_TOAST, KLocalization.GetLocalString(16));
                return false;
            }

            int costId = Item.Id.kChip;

            bool result = false;
            var costReduce = Mathf.Clamp01(GetAttributeValue(CombatAttributeId.CoinUpgradeCostReduce) * 0.01f);

            int lastCost = 0;
            if (tmpGrade > 0)
            {
                lastCost = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(tmpGrade).equipmentUpgradeCostCount;
            }

            int gradeAdd = 0;
            if (!onekey)
            {
                var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(tmpGrade + 1);
                costId = chaLevelItem.equipmentUpgradeCostId;
                int currCost = chaLevelItem.equipmentUpgradeCostCount;

                int cost = currCost - lastCost;

                cost -= (int)(cost * costReduce);
                if (MoneyProxy.Instance.CheckMoney(costId, cost))
                {
                    tmpGrade += 1;
                    gradeAdd += 1;
                    MoneyProxy.Instance.CostMoney(costId, cost);
                    result = true;
                }
            }
            else
            {
                int cost = 0;
                while (tmpGrade < maxGrade)
                {
                    var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(tmpGrade + 1);
                    costId = chaLevelItem.equipmentUpgradeCostId;
                    int currCost = chaLevelItem.equipmentUpgradeCostCount;

                    int tmpCost = currCost - lastCost;
                    tmpCost -= (int)(tmpCost * costReduce);
                    if (MoneyProxy.Instance.CheckMoney(costId, tmpCost))
                    {
                        tmpGrade += 1;
                        gradeAdd += 1;
                        cost = tmpCost;
                        result = true;
                    }
                    else
                    {
                        break;
                    }
                }
                MoneyProxy.Instance.CostMoney(costId, cost);
            }

            if (result)
            {
                _equipmentSlots[index].SetGrade(tmpGrade);

                SaveSlots();
                UpdateAttributes();
                int totalGrade = 0;
                for (int i = 0; i < _equipmentSlots.Length; i++)
                {
                    totalGrade += _equipmentSlots[i].grade;
                }
                MissionProxy.Instance.OnEvent2(MissionProxy.累计强化次数, totalGrade);
                if (sendNotification)
                    PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, onekey.ToString(), "upgrade");
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED);
                UI.ToastBox.ShowText("强化成功", 5);
            }
            else
            {
                UI.AdMoneyBox.ShowAdMoney(costId, true);
            }

            return result;
        }

        /// <summary>
        /// 代码有bug
        /// </summary>
        /// <param name="index"></param>
        /// <param name="onekey"></param>
        /// <param name="costId"></param>
        /// <param name="costCount"></param>
        /// <returns></returns>
        public bool GetUpgradeEquipmentSlotCost(int index, bool onekey, out int costId, out int costCount)
        {
            costId = Item.Id.kChip;
            costCount = 0;

            var slot = _equipmentSlots[index];
            if (slot.curEquipment == null)
            {
                return false;
            }

            int playerGrade = _equipmentSlots[index].maxGrade;
            int slotGrade = slot.grade;
            if (slotGrade >= playerGrade)
            {
                return false;
            }

            bool result = false;
            var costReduce = Mathf.Clamp01(GetAttribute(CombatAttributeId.CoinUpgradeCostReduce).value * 0.01f);

            int gradeAdd = 0;
            int lastCost = 0;
            if (slotGrade > 0)
            {
                lastCost = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(slotGrade).equipmentUpgradeCostCount;
            }

            if (!onekey)
            {
                var chaLevelItem = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(slotGrade + 1);
                costId = chaLevelItem.equipmentUpgradeCostId;
                int currCost = chaLevelItem.equipmentUpgradeCostCount;

                costCount = currCost - lastCost;
                costCount -= (int)(costCount * costReduce);
                if (MoneyProxy.Instance.CheckMoney(costId, costCount))
                {
                    slotGrade += 1;
                    gradeAdd += 1;
                    result = true;
                }
            }
            else
            {
                costCount = 0;
                while (slotGrade < playerGrade)
                {
                    int currCost = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(slotGrade + 1).equipmentUpgradeCostCount;
                    int tmpCost = currCost - lastCost;
                    tmpCost -= (int)(tmpCost * costReduce);
                    if (MoneyProxy.Instance.CheckMoney(costId, tmpCost))
                    {
                        slotGrade += 1;
                        gradeAdd += 1;
                        costCount = tmpCost;
                        result = true;
                    }
                    else
                    {
                        break;
                    }
                }
            }

            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public bool IsSetEquipment(EntityItemEquipment equipment)
        {
            if (equipment != null)
            {
                return _equipmentSlots[equipment.equipmentType].IsSetEquipment(equipment);
            }
            return false;
        }

        /// <summary>
        /// Item.EquipmentType
        /// </summary>
        /// <param name="id">部位</param>
        /// <returns></returns>
        public EntityItemEquipment GetCurEquipment(int id)
        {
            return _equipmentSlots[id].curEquipment;
        }

        /// <summary>
        /// 获取武器 包括试用
        /// </summary>
        /// <returns></returns>
        public EntityItemEquipment GetCurWeapon()
        {
            return _equipmentSlots[0].equipment;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemId"></param>
        public void SetDefaultEquipment(int itemId)
        {
            var equipment = BagProxy.Instance.NewEquipment(itemId);
            if (equipment != null)
            {
                if (_equipmentSlots[equipment.equipmentType].SetEquipment(equipment))
                {
                    SaveSlots();
                    UpdateAttributes(false);
                    this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipment, "set");
                }
            }
        }

        /// <summary>
        /// 装装备
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public bool SetEquipment(EntityItemEquipment equipment)
        {
            if (equipment == null /*|| equipment.propLevel > grade*/)
            {
                return false;
            }

            if (_equipmentSlots[equipment.equipmentType].SetEquipment(equipment))
            {
                UpdateAttributes();
                SaveSlots();

                if (_equipmentSlots[0].tryEquipment == null)
                    this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipment, "set");
                MissionProxy.Instance.OnOverEvent(MissionProxy.装备累计穿戴_等级_品质_数量, 1, equipment.propLevel, equipment.quality);
            }
            return true;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="equipments"></param>
        public void SetEquipments(EntityItemEquipment[] equipments)
        {
            bool flag = false;
            foreach (var equipment in equipments)
            {
                if (equipment != null)
                {
                    if (_equipmentSlots[equipment.equipmentType].SetEquipment(equipment))
                    {
                        flag = true;
                        MissionProxy.Instance.OnOverEvent(MissionProxy.装备累计穿戴_等级_品质_数量, 1, equipment.propLevel, equipment.quality);
                    }
                }
            }

            if (flag)
            {
                SaveSlots();
                UpdateAttributes();
                this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipments, "sets");
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public bool IsBetterEquipment(EntityItemEquipment equipment)
        {
            if (equipment == null /*|| equipment.propLevel > grade*/ || (equipment.isWeapon && _equipmentSlots[0].tryEquipment != null))
            {
                return false;
            }

            var setEquipment = GetCurEquipment(equipment.equipmentType);
            if (setEquipment == null || setEquipment.combatValue < equipment.combatValue)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 试用
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public bool TryoutEquipment(int equipmentId)
        {
            var equipment = ItemProxy.Instance.NewTemporaryEquipment(equipmentId);
            if (equipment == null)
            {
                return false;
            }
            _equipmentSlots[0].tryEquipment = equipment;

            UpdateAttributes();
            this.PostNotification(GlobalDefine.EVENT_PLAYER_EQUIPMENT_CHANGED, equipment, "set");
            return true;
        }

        /// <summary>
        /// 试用结束
        /// </summary>
        public void TryoutFinish()
        {
            bool flag = false;
            for (int i = 0; i < _equipmentSlots.Length; i++)
            {
                if (_equipmentSlots[i].tryEquipment != null)
                {
                    _equipmentSlots[i].tryEquipment = null;
                    flag = true;
                }
            }

            if (flag)
            {
                UpdateAttributes(false);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="gem"></param>
        /// <returns></returns>
        public bool SetGem(EntityItemGem gem)
        {
            if (gem.count <= 0)
                return false;

            var slot = GetEquipmentSlot(gem.item.slot);
            if (slot != null)
            {
                int gemLevel = gem.level;
                int lowGemIndex = -1;
                for (int i = 0; i < slot.setGemCountMax; i++)
                {
                    var slotGem = slot.gems[i];
                    if (slotGem == null)
                    {
                        slot.SetGem(i, gem.itemId);
                        gem.count -= 1;
                        return true;
                    }
                    else if (slotGem.level < gemLevel)
                    {
                        lowGemIndex = i;
                        gemLevel = slotGem.level;
                    }
                }

                if (lowGemIndex >= 0)
                {
                    var slotGem = slot.GetGem(lowGemIndex);
                    slotGem.count += 1;

                    slot.SetGem(lowGemIndex, gem.itemId);
                    gem.count -= 1;
                }

                SaveSlots();
                UpdateAttributes(true);
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="gemKVs"></param>
        /// <returns></returns>
        public bool SetGems(Dictionary<int, List<EntityItemGem>> gemKVs)
        {
            bool result = false;
            foreach (var gemKV in gemKVs)
            {
                var slot = GetEquipmentSlot(gemKV.Key);
                if (slot != null && slot.gemEnabled)
                {
                    int maxSetCount = slot.setGemCountMax;
                    int setCount = 0;
                    for (int j = gemKV.Value.Count - 1; j >= 0 && setCount < 3; j--)
                    {
                        var gem = gemKV.Value[j];
                        for (int i = 0; i < maxSetCount; i++)
                        {
                            if (gem.count > 0)
                            {
                                var slotGem = slot.GetGem(i);
                                if (slotGem == null)
                                {
                                    slot.SetGem(i, gem.itemId);
                                    gem.count -= 1;
                                    setCount += 1;
                                }
                                else if (slotGem.level < gem.level)
                                {
                                    slot.SetGem(i, gem.itemId);
                                    gem.count -= 1;
                                    slotGem.count += 1;
                                    setCount += 1;
                                }
                            }
                        }
                    }
                    if (setCount > 0)
                        result = true;
                }
            }

            if (result)
            {
                SaveSlots();
                UpdateAttributes(true);
                PostNotification(GlobalDefine.EVENT_GEM_CHANGED, null, "set");
            }

            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="gem"></param>
        /// <returns></returns>
        public bool IsBetterGem(EntityItemGem gem)
        {
            var slot = GetEquipmentSlot(gem.item.slot);
            if (slot != null)
            {
                for (int i = 0; i < slot.setGemCountMax; i++)
                {
                    var slotGem = slot.gems[i];
                    if (slotGem == null || slotGem.level < gem.level)
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sendNotification"></param>
        private void UpdateAttributes(bool sendNotification = true)
        {
            UpdateAttributes(_equipmentSlots, sendNotification);
        }

        private readonly Dictionary<int, int> _equipmentSuits = new Dictionary<int, int>();
        /// <summary>
        /// 
        /// </summary>
        /// <param name="equipmentSlots"></param>
        /// <param name="sendNotification"></param>
        private void UpdateAttributes(EquipmentSlotInfo[] equipmentSlots, bool sendNotification)
        {
            var results = F.ListPool<CombatAttribute>.Get();

            _equipmentSuits.Clear();
            int combatV = 0;
            for (int i = 0; i < equipmentSlots.Length; i++)
            {
                combatV += equipmentSlots[i].GetAttributes(results);
                if (equipmentSlots[i].curEquipment != null)
                {
                    var equipmentSuitId = equipmentSlots[i].curEquipment.suitId;
                    if (equipmentSuitId > 0)
                    {
                        if (_equipmentSuits.ContainsKey(equipmentSuitId))
                            _equipmentSuits[equipmentSuitId] += 1;
                        else
                            _equipmentSuits.Add(equipmentSuitId, 1);
                    }
                }
            }

            if (_equipmentSuits.Count > 0)
            {
                foreach (var suitKV in _equipmentSuits)
                {
                    var suitItem = ItemProxy.Instance.GetStaticItem<ItemSuit>(suitKV.Key);
                    if (suitKV.Value >= 2)
                    {
                        var attribute = suitItem.GetAttribute2();
                        combatV += attribute.combatValue;
                        results.Add(attribute);
                    }
                    if (suitKV.Value >= 4)
                    {
                        var attribute = suitItem.GetAttribute4();
                        combatV += attribute.combatValue;
                        results.Add(attribute);
                    }
                    if (suitKV.Value >= 6)
                    {
                        var attribute = suitItem.GetAttribute6();
                        combatV += attribute.combatValue;
                        results.Add(attribute);
                    }
                }
            }

            for (int i = 0; i < _suitInfos.Count; i++)
            {
                combatV += _suitInfos[i].GetAttributes(results);
            }

            UpdateEquipmentCombatValue(results, combatV, sendNotification);

            F.ListPool<CombatAttribute>.Release(results);
        }

        private const string ARCHIVE_KEY_OB = "eq_slots";
        private const string ARCHIVE_KEY_V1 = "slots_v1";

        /// <summary>
        /// 
        /// </summary>
        private void LoadEquipmentSlots()
        {
            var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
            if (dataList != null && dataList.Count > 0)
            {
                int index = 0;
                for (int i = 0; i < _equipmentSlots.Length; i++)
                {
                    _equipmentSlots[i].grade = dataList.SafeGet(index++);
                    _equipmentSlots[i].SetEquipment(dataList.SafeGet(index++));

                    var gemCount = dataList.SafeGet(index++);
                    for (int j = 0; j < gemCount; j++)
                    {
                        var gemId = dataList.SafeGet(index++);
                        _equipmentSlots[i].SetGem(j, gemId);
                    }
                }

                var suitCount = dataList.SafeGet(index++);
                for (int i = 0; i < suitCount; i++)
                {
                    int status = dataList.SafeGet(index++);
                    if (i < _suitInfos.Count)
                        _suitInfos[i].SetStatus(status);
                }

                //UpdateAttributes(false);
            }
            else
            {
                var saveList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_OB);
                if (saveList != null && saveList.Count > 0)
                {
                    bool flag = false;

                    int index = 0;
                    for (int i = 0; i < _equipmentSlots.Length; i++)
                    {
                        _equipmentSlots[i].grade = saveList.SafeGet(index++);
                        if (_equipmentSlots[i].SetEquipment(saveList.SafeGet(index++)))
                        {
                            flag = true;
                        }
                    }

                    for (int i = 0; i < _suitInfos.Count; i++)
                    {
                        _suitInfos[i].SetStatus(saveList.SafeGet(index++));
                    }

                    if (flag)
                    {
                        UpdateAttributes(false);
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        private void SaveSlots()
        {
            var saveList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
            if (saveList != null)
            {
                saveList.Clear();

                for (int i = 0; i < _equipmentSlots.Length; i++)
                {
                    var slot = _equipmentSlots[i];
                    saveList.Add(slot.grade);
                    saveList.Add(slot.equipmentId);

                    saveList.Add(slot.gems.Length);
                    for (int j = 0; j < slot.gems.Length; j++)
                    {
                        var gem = slot.gems[j];
                        saveList.Add(gem != null ? gem.id : 0);
                    }
                }

                saveList.Add(_suitInfos.Count);
                for (int i = 0; i < _suitInfos.Count; i++)
                {
                    saveList.Add(_suitInfos[i].GetStatus());
                }

                ArchiveProxy.Instance.SetIntList(ARCHIVE_KEY_V1, saveList);
            }
            ArchiveProxy.Instance.RemoveIntList(ARCHIVE_KEY_OB);
        }

        #endregion

        #region 角色套装

        /// <summary>
        /// 套装
        /// </summary>
        public class EquipmentSlotSuit
        {
            public readonly ItemSuit item;

            /// <summary>
            /// 
            /// </summary>
            public int id => item.id;

            public string description
            {
                get { return $"<color=#{ColorUtility.ToHtmlStringRGB(Item.GetQualityColor(activeGrade + 1))}>{item.name}({activeCount}/6)"; }
            }

            /// <summary>
            /// 
            /// </summary>
            public string suitFxAsset
            {
                get
                {
                    int tmp = stage;
                    if (tmp > 0)
                    {
                        return $"ef_suit_blue_{tmp}";
                    }
                    return "";
                }
            }

            public int stageMax
            {
                get => 3;
            }

            public int stage
            {
                get
                {
                    int ac = this.activeCount;
                    if (ac < 1)
                    {
                        return 0;
                    }
                    else if (ac < 3)
                    {
                        return 1;
                    }
                    else if (ac < 6)
                    {
                        return 2;
                    }
                    else
                    {
                        return 3;
                    }
                }
            }

            public int stageCount1 => 1;
            public int stageCount2 => 3;
            public int stageCount3 => 6;

            /// <summary>
            /// 
            /// </summary>
            /// <param name="stageCount"></param>
            /// <returns></returns>
            public int GetStageGrade(int stageCount)
            {
                int result = -1;
                int count = 0;
                for (int i = (int)Item.EquipmentType.kMax - 1; i >= 0; i--)
                {
                    int grade = _grades[i];
                    if (grade > result)
                    {
                        result = grade;
                        count = 1;
                    }
                    else if (grade == result)
                    {
                        count++;
                    }
                }

                return count >= stageCount ? result : result - 1;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="stageCount"></param>
            /// <returns></returns>
            public string GetStageGradeText(int stageCount)
            {
                if (activeCount < stageCount)
                    return $"<color=#7E8486>({stageCount})</color> ";
                int stageGrade = GetStageGrade(stageCount);
                return $"<color=#{ColorUtility.ToHtmlStringRGB(Item.GetQualityColor(stageGrade + 1))}>({Item.GetQualityText(stageGrade + 1) + stageCount})</color> ";
            }

            /// <summary>
            /// 
            /// </summary>
            public string suitAttributesText2
            {
                get
                {
                    var attributes = item.GetAttribute2ByGrade(GetStageGrade(stageCount1));
                    return GetStageGradeText(stageCount1) + attributes.ToString();
                }
            }

            /// <summary>
            /// 
            /// </summary>
            public string suitAttributesText4
            {
                get
                {
                    var attributes = item.GetAttribute4ByGrade(GetStageGrade(stageCount2));
                    return GetStageGradeText(stageCount2) + attributes.ToString();
                }
            }

            /// <summary>
            /// 
            /// </summary>
            public string suitAttributesText6
            {
                get
                {
                    var attributes = item.GetAttribute6ByGrade(GetStageGrade(stageCount3));
                    return GetStageGradeText(stageCount3) + attributes.ToString();
                }
            }

            private int _status;
            /// <summary>
            /// 激活数量
            /// </summary>
            public int activeCount
            {
                get
                {
                    int result = 0;
                    for (int i = 0; i < (int)Item.EquipmentType.kMax; i++)
                    {
                        if (_grades[i] > 0)
                            //if ((_status & (1 << i)) != 0)
                            result++;
                    }
                    return result;
                }
            }

            /// <summary>
            /// 激活等级
            /// </summary>
            public int activeGrade
            {
                get
                {
                    int result = 0;
                    for (int i = (int)Item.EquipmentType.kMax - 1; i >= 0; i--)
                    {
                        if (_grades[i] > result)
                            result = _grades[i];
                    }
                    return result;
                }
            }

            public EquipmentSlotSuit(ItemSuit suitItem)
            {
                this.item = suitItem;
            }

            public bool IsActiveSlot(int slot)
            {
                return (_status & (1 << slot)) != 0;
            }

            public void ActiveSuit(int slot)
            {
                _status |= (1 << slot);
            }

            private readonly ObscuredInt[] _grades = new ObscuredInt[(int)Item.EquipmentType.kMax];

            public int maxGrade
            {
                get => 5;
            }

            public int GetGrade(int slot)
            {
                return _grades[slot];
            }

            public void SetGrade(int slot, int value)
            {
                _grades[slot] = value;
            }

            public void Upgrade(int slot)
            {
                _grades[slot] += 1;
            }

            public bool CanUpgrade(int slot)
            {
                var slotGrade = (int)_grades[slot];
                if (slotGrade >= maxGrade)
                    return false;
                for (int i = 0; i < _grades.Length; i++)
                {
                    if (slotGrade > _grades[i])
                        return false;
                }
                return true;
            }

            public Item.ItemInfo GetUpgradeCost(int slot)
            {
                return item.GetCostByGrade(_grades[slot]);
            }

            public void SetStatus(int status)
            {
                if (status > 0)
                {
                    _status = status;
                    for (int i = 0; i < (int)Item.EquipmentType.kMax; i++)
                    {
                        bool active = (_status & (1 << i)) != 0;
                        if (active)
                        {
                            _grades[i] = 1;
                        }
                    }
                }
            }

            /// <summary>
            /// 
            /// </summary>
            public int GetStatus()
            {
                return _status;
            }

            /// <summary>
            /// 
            /// </summary>
            /// <param name="results"></param>
            /// <returns></returns>
            public int GetAttributes(List<CombatAttribute> results)
            {
                int resutCV = 0;
                int tmpCount = this.activeCount;
                if (tmpCount >= stageCount1)
                {
                    var attribute = item.GetAttribute2ByGrade(GetStageGrade(stageCount1));
                    resutCV += attribute.combatValue;
                    results.Add(attribute);
                }
                if (tmpCount >= stageCount2)
                {
                    var attribute = item.GetAttribute4ByGrade(GetStageGrade(stageCount2));
                    resutCV += attribute.combatValue;
                    results.Add(attribute);
                }
                if (tmpCount >= stageCount3)
                {
                    var attribute = item.GetAttribute6ByGrade(GetStageGrade(stageCount3));
                    resutCV += attribute.combatValue;
                    results.Add(attribute);
                }
                return resutCV;
            }
        }

        private readonly List<EquipmentSlotSuit> _suitInfos = new List<EquipmentSlotSuit>();

        /// <summary>
        /// 
        /// </summary>
        private void InitEquipmentSlotSuits()
        {
            _suitInfos.Clear();
            var suitItem = ItemProxy.Instance.GetStaticItem<ItemSuit>(1);
            //if (suitItems != null)
            //	for (int i = 0; i < suitItems.Count; i++)
            //	{
            _suitInfos.Add(new EquipmentSlotSuit(suitItem));
            //}
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public EquipmentSlotSuit GetCurrEquipmentSuit()
        {
            return _suitInfos[0];
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="slot"></param>
        /// <returns></returns>
        public bool UpgradeEquipmentSlotSuit(int slot)
        {
            var suit = GetCurrEquipmentSuit();
            if (slot >= 0 && suit != null && suit.CanUpgrade(slot) && MoneyProxy.Instance.CheckAndCostMoney(suit.GetUpgradeCost(slot)))
            {
                suit.Upgrade(slot);
                SaveEquipmentSuits();
                UpdateAttributes();
                PostNotification(GlobalDefine.EVENT_EQUIPMENT_SUIT, null, "upgrade");
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED, null, "suit");
                return true;
            }
            return false;
        }

        public int GetEquipmentSuitActiveCount(int suitId)
        {
            int result = 0;
            for (int i = 0; i < _equipmentSlots.Length; i++)
            {
                var equipment = _equipmentSlots[i].curEquipment;
                if (equipment != null && equipment.suitId == suitId)
                {
                    result++;
                }
            }
            return result;
        }

        private const string SUIT_ARCHIVE_KEY_V1 = "suit_v1";

        void LoadEquipmentSuits()
        {
            var dataList = ArchiveProxy.Instance.GetIntList(SUIT_ARCHIVE_KEY_V1);
            if (dataList != null && dataList.Count > 0)
            {
                int index = 0;
                int suitId = dataList[index++];
                var suitInfo = _suitInfos[0];
                for (int j = 0; j < 6; j++)
                {
                    suitInfo.SetGrade(j, dataList[index++]);
                }
            }
        }

        void SaveEquipmentSuits()
        {
            var saveList = ArchiveProxy.Instance.GetIntList(SUIT_ARCHIVE_KEY_V1);
            if (saveList != null)
            {
                saveList.Clear();

                var suitInfo = _suitInfos[0];
                saveList.Add(suitInfo.id);
                for (int j = 0; j < 6; j++)
                {
                    saveList.Add(suitInfo.GetGrade(j));
                }

                ArchiveProxy.Instance.SetIntList(SUIT_ARCHIVE_KEY_V1, saveList);
            }
        }

        #endregion

        #region 角色战斗属性

        public const int ATTRIBUTES_INDEX_TOTAL = 0;
        public const int ATTRIBUTES_INDEX_CHA = 1;
        public const int ATTRIBUTES_INDEX_EQUIPMENT = 2;
        public const int ATTRIBUTES_INDEX_KUNGFU = 3;
        public const int ATTRIBUTES_INDEX_TITLE = 4;
        public const int ATTRIBUTES_INDEX_BEAUTY = 5;
        public const int ATTRIBUTES_INDEX_PET = 6;
        public const int ATTRIBUTES_INDEX_BOOK = 7;

        public const int ATTRIBUTES_INDEX_MAX = 6 + 1;
        public const int COMBATVALUE_INDEX_MAX = 7 + 1;

        /// <summary>
        /// 
        /// </summary>
        private readonly int[] _combatValues = new int[COMBATVALUE_INDEX_MAX];

        /// <summary>
        /// 角色数值
        /// </summary>
        private readonly CombatAttribute[][] _allAttributes = new CombatAttribute[ATTRIBUTES_INDEX_MAX][];

        /// <summary>
        /// 总属性
        /// </summary>
        public CombatAttribute[] combatAttributes => _allAttributes[ATTRIBUTES_INDEX_TOTAL];
        /// <summary>
        /// 成长属性
        /// </summary>
        public CombatAttribute[] growthAttributes => _allAttributes[ATTRIBUTES_INDEX_CHA];
        /// <summary>
        /// 装备属性
        /// </summary>
        public CombatAttribute[] equipmentAttributes => _allAttributes[ATTRIBUTES_INDEX_EQUIPMENT];
        /// <summary>
        /// 武学属性
        /// </summary>
        public CombatAttribute[] kungfuAttributes => _allAttributes[ATTRIBUTES_INDEX_KUNGFU];
        /// <summary>
        /// 称号属性
        /// </summary>
        public CombatAttribute[] titleAttributes => _allAttributes[ATTRIBUTES_INDEX_TITLE];
        /// <summary>
        /// 
        /// </summary>
        public CombatAttribute[] beautyAttributes => _allAttributes[ATTRIBUTES_INDEX_BEAUTY];
        /// <summary>
        /// 
        /// </summary>
        public CombatAttribute[] petAttributes => _allAttributes[ATTRIBUTES_INDEX_PET];

        /// <summary>
        /// 
        /// </summary>
        public void InitCombatAttributes()
        {
            for (int i = 0; i < ATTRIBUTES_INDEX_MAX; i++)
            {
                var attributes = _allAttributes[i];
                if (attributes == null)
                {
                    attributes = new CombatAttribute[(int)CombatAttributeId.kMax];
                    for (var j = CombatAttributeId.kMin; j < CombatAttributeId.kMax; j++)
                    {
                        attributes[(int)j].id = j;
                    }
                    _allAttributes[i] = attributes;
                }
                else
                {
                    for (var j = CombatAttributeId.kMin; j < CombatAttributeId.kMax; j++)
                    {
                        attributes[(int)j].value = 0;
                    }
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attributeId"></param>
        /// <returns></returns>
        public CombatAttribute GetAttribute(CombatAttributeId attributeId)
        {
            return _allAttributes[0][(int)attributeId];
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="attributeId"></param>
        /// <returns></returns>
        public int GetAttributeValue(CombatAttributeId attributeId)
        {
            return _allAttributes[0][(int)attributeId].value;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="source"></param>
        /// <param name="attribute"></param>
        private void AddAttribute(CombatAttribute[] source, CombatAttribute attribute)
        {
            source[(int)attribute.id].AddValue(attribute.value);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="source"></param>
        /// <param name="attributes"></param>
        private void AddAttributes(CombatAttribute[] source, IList<CombatAttribute> attributes)
        {
            foreach (var attribute in attributes)
            {
                source[(int)attribute.id].AddValue(attribute.value);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="source"></param>
        private void ResetAttributes(CombatAttribute[] attributes)
        {
            for (int i = 1; i < (int)CombatAttributeId.kMax; i++)
            {
                attributes[i].ResetValue();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public int GetCombatValue(int index)
        {
            return _combatValues[index];
        }

        /// <summary>
        /// 更新战力
        /// </summary>
        /// <param name="index"></param>
        /// <param name="fixedCV"></param>
        /// <param name="extraCV"></param>
        /// <returns>返回战力差</returns>
        public int UpdateCombatValue(int index, int fixedCV = 0, int extraCV = 0)
        {
            //
            for (int i = 1; i < (int)CombatAttributeId.kMax; i++)
            {
                _allAttributes[0][i].ResetValue();
                for (int j = 1; j < ATTRIBUTES_INDEX_MAX; j++)
                {
                    _allAttributes[0][i].AddValue(_allAttributes[j][i].value);
                }
            }
            //
            if (fixedCV == 0)
            {
                var attributes = _allAttributes[index];
                for (int i = 1; i < (int)CombatAttributeId.kMax; i++)
                {
                    fixedCV += attributes[i].combatValue;
                }
            }
            fixedCV += extraCV;
            int result = fixedCV - _combatValues[index];
            _combatValues[index] = fixedCV;

            _combatValues[0] = 0;
            for (int i = 1; i < COMBATVALUE_INDEX_MAX; i++)
            {
                _combatValues[0] += _combatValues[i];
            }
            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="index"></param>
        /// <param name="fixedCV"></param>
        /// <returns></returns>
        public int UpdateCombatValueWithoutAttributes(int index, int fixedCV = 0)
        {
            //			
            int result = fixedCV - _combatValues[index];
            _combatValues[index] = fixedCV;

            _combatValues[0] = 0;
            for (int i = 1; i < COMBATVALUE_INDEX_MAX; i++)
            {
                _combatValues[0] += _combatValues[i];
            }
            return result;
        }

        /// <summary>
        /// 升级战力
        /// </summary>
        public void UpdateGrowthCombatValue(bool sendNotification)
        {
            var attributes = this.growthAttributes;
            ResetAttributes(attributes);

            var cha = GetCurrentCha();
            if (cha != null)
            {
                var initAttributes = cha.initAttributes;
                for (int i = 0; i < initAttributes.Length; i++)
                {
                    AddAttribute(attributes, new CombatAttribute
                    {
                        id = (CombatAttributeId)initAttributes[i][0],
                        value = initAttributes[i][1],
                    });
                }
            }

            //var chaLevel = ItemProxy.Instance.GetStaticItem<ItemChaLevel>(this.grade);
            //if (chaLevel != null)
            //{
            //	for (int i = 0; i < chaLevel.attributes.Length; i++)
            //	{
            //		AddAttribute(attributes, new CombatAttribute
            //		{
            //			id = (CombatAttributeId)chaLevel.attributes[i][0],
            //			value = chaLevel.attributes[i][1],
            //		});
            //	}
            //}

            int skinCV = ChaSkinProxy.Instance.combatValue;

            int result = UpdateCombatValue(ATTRIBUTES_INDEX_CHA, 0, skinCV);
            if (sendNotification)
                this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "growth");
        }

        /// <summary>
        /// 装备战力
        /// </summary>
        public void UpdateEquipmentCombatValue(IList<CombatAttribute> results, int combatValue, bool sendNotification)
        {
            var attributes = this.equipmentAttributes;
            if (sendNotification)
                for (int i = 0; i < results.Count; i++)
                {
                    var newAttr = results[i];
                    var oldAttr = attributes[(int)newAttr.id];
                    if (newAttr.value > oldAttr.value)
                    {
                        newAttr.value -= oldAttr.value;
                        UI.ToastBox.ShowText(newAttr.ToString2(), 4);
                    }
                }

            ResetAttributes(attributes);
            AddAttributes(attributes, results);

            int result = UpdateCombatValue(ATTRIBUTES_INDEX_EQUIPMENT, combatValue);
            if (sendNotification)
                this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "equipment");
        }

        /// <summary>
        /// 武学战力
        /// </summary>
        public void UpdateKungfuCombatValue(IList<CombatAttribute> results, bool sendNotification)
        {
            var attributes = this.kungfuAttributes;
            if (sendNotification)
                for (int i = 0; i < results.Count; i++)
                {
                    var newAttr = results[i];
                    var oldAttr = attributes[(int)newAttr.id];
                    if (newAttr.value > oldAttr.value)
                    {
                        newAttr.value -= oldAttr.value;
                        UI.ToastBox.ShowText(newAttr.ToString2(), 4);
                    }
                }

            ResetAttributes(attributes);
            AddAttributes(attributes, results);

            int result = UpdateCombatValue(ATTRIBUTES_INDEX_KUNGFU);
            if (sendNotification)
                this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "kungfu");
        }

        /// <summary>
        /// 
        /// </summary>
        public void UpdateTitleCombatValue(IList<CombatAttribute> results, int combatValue, bool sendNotification)
        {
            var attributes = this.titleAttributes;
            ResetAttributes(attributes);
            AddAttributes(attributes, results);

            int result = UpdateCombatValue(ATTRIBUTES_INDEX_TITLE, combatValue);
            if (sendNotification)
                this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "title");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="results"></param>
        public void UpdateBeautyCombatValue(IList<CombatAttribute> results, bool sendNotification)
        {
            var attributes = this.beautyAttributes;
            ResetAttributes(attributes);
            AddAttributes(attributes, results);

            int result = UpdateCombatValue(ATTRIBUTES_INDEX_BEAUTY);
            if (sendNotification)
                this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "beauty");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="results"></param>
        /// <param name="combatValue"></param>
        /// <param name="sendNotification"></param>
        public void UpdatePetCombatValue(IList<CombatAttribute> results, int combatValue, bool sendNotification)
        {
            var attributes = this.petAttributes;
            ResetAttributes(attributes);
            AddAttributes(attributes, results);

            int result = UpdateCombatValue(ATTRIBUTES_INDEX_PET, combatValue);
            if (sendNotification)
                this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "pet");
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="combatValue"></param>
        /// <param name="sendNotification"></param>
        public void UpdateBookCombatValue(int combatValue, bool sendNotification)
        {
            int result = UpdateCombatValueWithoutAttributes(ATTRIBUTES_INDEX_BOOK, combatValue);
            if (sendNotification)
                this.PostNotification(GlobalDefine.EVENT_PLAYER_ATTRIBUTES_CHANGED, result, "book");
        }

        #endregion
    }
}