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

namespace G
{
    /// <summary>
    /// 背包系统
    /// </summary>
    public partial class BagProxy : F.GameProxy
    {
        public enum BagPage
        {
            Bag = 0,
            Equipment,
            Props,
        }

        public const int CAPACITY_LIMIT = 100;

        #region Fields

        private readonly List<EntityItemEquipment> _allEquipments = new List<EntityItemEquipment>();
        private readonly List<EntityItem> _allProps = new List<EntityItem>();

        private readonly Dictionary<int, List<EntityItemProp>> _props = new Dictionary<int, List<EntityItemProp>>();
        private readonly Dictionary<int, List<EntityItemGem>> _gems = new Dictionary<int, List<EntityItemGem>>();

        private readonly Dictionary<int, List<ItemEquipment>> _recastEquipments = new Dictionary<int, List<ItemEquipment>>();

        private ObscuredInt _bagCapacity = 80;

        private bool _autoSell;
        private bool[] _sellQualityFilters = new bool[Item.Quality.kMax + 1];

        #endregion

        #region Property

        /// <summary>
        /// 
        /// </summary>
        public bool autoSell
        {
            get { return _autoSell; }
            set
            {
                if (_autoSell != value)
                {
                    _autoSell = value;
                    SaveBag();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool[] sellQualityFilters
        {
            get => _sellQualityFilters;
            set
            {
                if (value != null)
                {
                    _sellQualityFilters = value;
                    SaveBag();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public int bagCapacity
        {
            get { return _bagCapacity; }
            set
            {
                if (_bagCapacity != value)
                {
                    _bagCapacity = Mathf.Min(value, CAPACITY_LIMIT);
                    SaveBag();
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        public bool isBagCapacityLimit
        {
            get { return _bagCapacity >= CAPACITY_LIMIT; }
        }

        #endregion

        #region Method 

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public int GetRedPoint()
        {
            if (GetBagItemCount() >= GetBagItemCapacity() - 1)
            {
                return 1;
            }
            return 0;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="page"></param>
        /// <returns></returns>
        public int GetBagItemCount(BagPage page = BagPage.Bag)
        {
            if (page == BagPage.Bag)
                return ItemProxy.Instance.GetEquipmentCount() - PlayerProxy.Instance.GetValidEquipmentSlotCount();
            else
                return 0;
        }

        /// <summary>
        /// 背包容积
        /// </summary>
        /// <param name="page"></param>
        /// <returns></returns>
        public int GetBagItemCapacity(BagPage page = BagPage.Bag)
        {
            if (page == BagPage.Bag)
                return _bagCapacity;
            else
                return CAPACITY_LIMIT;
        }

        /// <summary>
        /// 背包已满
        /// </summary>
        /// <returns></returns>
        public bool BagIsFull()
        {
            AutoSell();
            return GetBagItemCount() >= GetBagItemCapacity();
        }

        /// <summary>
        /// 无法创建装备
        /// </summary>
        /// <returns></returns>
        public bool BagIsFullLimit()
        {
            return GetBagItemCount() >= CAPACITY_LIMIT;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="sortMode"></param>
        /// <returns></returns>
        public List<EntityItemEquipment> GetBagEquipments(int sortMode = 0)
        {
            _allEquipments.Clear();

            var equipments = ItemProxy.Instance.GetEquipments();
            foreach (var equipment in equipments)
            {
                if (!PlayerProxy.Instance.IsSetEquipment(equipment))
                    _allEquipments.Add(equipment);
            }

            if (sortMode == 2)
                _allEquipments.Sort(EntityItemEquipment.SortByQuality);
            else
                _allEquipments.Sort(EntityItemEquipment.SortByGrade);

            return _allEquipments;
        }

        /// <summary>
        /// 
        /// </summary>		
        /// <returns></returns>
        public List<EntityItemEquipment> GetRecastEquipments()
        {
            _allEquipments.Clear();

            var equipments = ItemProxy.Instance.GetEquipments();
            int quality = Item.Quality.kYellow;
            foreach (var equipment in equipments)
            {
                if (equipment.quality >= quality && !equipment.isLock && !equipment.isEquip)
                    _allEquipments.Add(equipment);
            }

            _allEquipments.Sort(EntityItemEquipment.SortByGrade);
            return _allEquipments;
        }

        /// <summary>
        /// 获取背包道具
        /// </summary>
        /// <returns></returns>
        public List<EntityItem> GetBagProps()
        {
            _allProps.Clear();

            var props = GetPropsByType();
            foreach (var propList in props.Values)
            {
                for (int i = 0; i < propList.Count; i++)
                {
                    if (propList[i].count > 0)
                        _allProps.Add(propList[i]);
                }
            }

            var gems = GetGemsBySlot();
            foreach (var gemList in gems.Values)
            {
                for (int i = gemList.Count - 1; i >= 0; i--)
                {
                    if (gemList[i].count > 0)
                        _allProps.Add(gemList[i]);
                }
            }

            return _allProps;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="itemId"></param>
        /// <returns></returns>
        public EntityItemEquipment NewEquipment(int itemId)
        {
            if (ItemProxy.Instance.GetEquipmentCount() < 160)
                return ItemProxy.Instance.NewEquipment(itemId);
            return null;
        }

        /// <summary>
        /// 
        /// </summary>
        public void AutoSell()
        {
            if (_autoSell)
                OneKeySellEquipments(_sellQualityFilters, 0);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a"></param>
        /// <returns></returns>
        public bool Sell(EntityItem a)
        {
            if (a != null)
            {
                var price = a.propItem.sellPriceInfo;
                int addMoneyAmout = (int)(price.count * (GlobalVar.PropSellAddition + 1f));
                if (price.id > 0)
                {
                    MoneyProxy.Instance.AddMoney(price.id, addMoneyAmout);
                }
                ItemProxy.Instance.RemoveEntityItem(a);
                MissionProxy.Instance.OnEvent(MissionProxy.装备累计回收_数量, 1);
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED);
                PostNotification(GlobalDefine.EVENT_EQUIPMENT_SELL, (price.id == Item.Id.kChip ? "晶石 x" : "晶珀石 x") + addMoneyAmout.ToString(), "sell");
                return true;
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="qualityFilters"></param>
        /// <param name="gradeFilter"></param>
        public int OneKeySellEquipments(bool[] qualityFilters, int gradeFilter)
        {
            _allEquipments.Clear();
            //int gradeScreen = PlayerProxy.Instance.grade + gradeFilter;

            var equipments = ItemProxy.Instance.GetEquipments();
            foreach (var equipment in equipments)
            {
                if (!equipment.isLock && !PlayerProxy.Instance.IsSetEquipment(equipment) && qualityFilters[equipment.quality] /*&& equipment.propLevel <= gradeScreen*/)
                    _allEquipments.Add(equipment);
            }

            //int addMoneyId = 0;
            int addMoneyAmout = 0;
            int addMoneyAmout2 = 0;
            foreach (var equipment in _allEquipments)
            {
                var price = equipment.propItem.sellPriceInfo;
                if (price.id > 0)
                {
                    //addMoneyId = price.id;
                    if (price.id == Item.Id.kChip)
                        addMoneyAmout += price.count;
                    else
                        addMoneyAmout2 += price.count;
                }
                ItemProxy.Instance.RemoveEntityItem(equipment);
            }

            MissionProxy.Instance.OnEvent(MissionProxy.装备累计回收_数量, _allEquipments.Count);

            _allEquipments.Clear();
            if (addMoneyAmout > 0)
            {
                addMoneyAmout += (int)(addMoneyAmout * GlobalVar.PropSellAddition);
                MoneyProxy.Instance.AddMoney(Item.Id.kChip, addMoneyAmout);
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED);
                PostNotification(GlobalDefine.EVENT_EQUIPMENT_SELL, "晶石 x" + addMoneyAmout.ToString(), "onekeysell");
            }
            if (addMoneyAmout2 > 0)
            {
                addMoneyAmout2 += (int)(addMoneyAmout2 * GlobalVar.PropSellAddition);
                MoneyProxy.Instance.AddMoney(Item.Id.kChip2, addMoneyAmout2);
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED);
                PostNotification(GlobalDefine.EVENT_EQUIPMENT_SELL, "晶珀石 x" + addMoneyAmout2.ToString(), "onekeysell");
            }

            return addMoneyAmout + addMoneyAmout2;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public int OneKeySellEquipments()
        {
            _allEquipments.Clear();

            var equipments = ItemProxy.Instance.GetEquipments();
            foreach (var equipment in equipments)
            {
                if (!equipment.isLock && !PlayerProxy.Instance.IsSetEquipment(equipment))
                    _allEquipments.Add(equipment);
            }

            //int addMoneyId = 0;
            int addMoneyAmout = 0;
            int addMoneyAmout2 = 0;
            foreach (var equipment in _allEquipments)
            {
                var price = equipment.propItem.sellPriceInfo;
                if (price.id > 0)
                {
                    //addMoneyId = price.id;
                    if (price.id == Item.Id.kChip)
                        addMoneyAmout += price.count;
                    else
                        addMoneyAmout2 += price.count;
                }
                ItemProxy.Instance.RemoveEntityItem(equipment);
            }

            MissionProxy.Instance.OnEvent(MissionProxy.装备累计回收_数量, _allEquipments.Count);
            _allEquipments.Clear();
            if (addMoneyAmout > 0)
            {
                addMoneyAmout += (int)(addMoneyAmout * GlobalVar.PropSellAddition);
                MoneyProxy.Instance.AddMoney(Item.Id.kChip, addMoneyAmout);
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED);
                PostNotification(GlobalDefine.EVENT_EQUIPMENT_SELL, "晶石 x" + addMoneyAmout.ToString(), "onekeysell");
            }
            if (addMoneyAmout2 > 0)
            {
                addMoneyAmout2 += (int)(addMoneyAmout2 * GlobalVar.PropSellAddition);
                MoneyProxy.Instance.AddMoney(Item.Id.kChip2, addMoneyAmout2);
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED);
                PostNotification(GlobalDefine.EVENT_EQUIPMENT_SELL, "晶珀 x" + addMoneyAmout2.ToString(), "onekeysell");
            }
            return addMoneyAmout + addMoneyAmout2;
        }

        /// <summary>
        /// 
        /// </summary>
        public void OneKeySetEquipments()
        {
            var bagEquipments = GetBagEquipments();

            //int pLv = PlayerProxy.Instance.grade;
            var equipments = new EntityItemEquipment[(int)Item.EquipmentType.kMax];
            for (int i = 0; i < equipments.Length; i++)
            {
                equipments[i] = PlayerProxy.Instance.GetCurEquipment(i);
            }
            //
            foreach (var equipment in bagEquipments)
            {
                //if (pLv >= equipment.propLevel)
                //{
                var type = equipment.equipmentType;
                if (equipments[type] == null || equipments[type].combatValue < equipment.combatValue)
                    equipments[type] = equipment;
                //}
            }

            bool change = false;
            for (int i = 0; i < equipments.Length; i++)
            {
                if (equipments[i] != PlayerProxy.Instance.GetCurEquipment(i))
                {
                    change = true;
                    break;
                }
            }

            if (change)
            {
                PlayerProxy.Instance.SetEquipments(equipments);
            }
            else
            {
                PostNotification(GlobalDefine.EVENT_SHOW_TOAST, "没有可穿戴装备");
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
        public Dictionary<int, List<EntityItemProp>> GetPropsByType()
        {
            if (_props.Count == 0)
            {
                var props = ItemProxy.Instance.GetProps();
                foreach (var prop in props)
                {
                    var propKey = prop.item.type;
                    if (_props.TryGetValue(propKey, out var list))
                    {
                        list.Add(prop);
                    }
                    else
                    {
                        _props.Add(propKey, new List<EntityItemProp> { prop });
                    }
                }
            }
            return _props;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <returns>按等级顺序排列</returns>
        public Dictionary<int, List<EntityItemGem>> GetGemsBySlot()
        {
            if (_gems.Count == 0)
            {
                var gems = ItemProxy.Instance.GetGems();
                foreach (var gem in gems)
                {
                    int gemKey = gem.item.slot;
                    if (_gems.TryGetValue(gemKey, out var list))
                    {
                        list.Add(gem);
                    }
                    else
                    {
                        _gems.Add(gemKey, new List<EntityItemGem>(10) { gem });
                    }
                }

                //foreach (var gemList in _gemHelper.Values)
                //{
                //	gemList.Sort((a, b) =>
                //	{
                //		return a.level.CompareTo(b.level);
                //	});
                //}
            }

            return _gems;
        }
        /// <summary>
        /// 宝石升级
        /// </summary>
        /// <returns></returns>
        public bool GemUpgrade(EntityItemGem gem)
        {
            if (gem != null)
            {
                return gem.Upgrade() != null;
            }
            return false;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="typeFilters"></param>
        /// <returns></returns>
        public Item.ItemInfo CalcOneKeyGemUpgradeCost(bool[] typeFilters)
        {
            Item.ItemInfo result = default;
            var gems = GetGemsBySlot();
            foreach (var gemKV in gems)
            {
                if (typeFilters[gemKV.Key])
                {
                    var gemList = gemKV.Value;
                    for (int i = 0; i < gemList.Count; i++)
                    {
                        var gem = gemList[i];
                        if (gem.count >= 2)
                        {
                            var cost = gem.GetUpdgradeCost();
                            if (cost.id > 0)
                            {
                                result.id = cost.id;
                                result.count += cost.count;
                            }
                        }
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// 宝石升级
        /// </summary>
        /// <returns></returns>
        public bool GemOneKeyUpgrade(bool[] typeFilters)
        {
            var upCost = CalcOneKeyGemUpgradeCost(typeFilters);
            if (!MoneyProxy.Instance.CheckAndCostMoney(upCost, GlobalDefine.COST_MONEY_UPGRADE_GEM))
            {
                return false;
            }

            var resultList = F.ListPool<EntityItemGem>.Get();
            var gems = GetGemsBySlot();
            foreach (var gemKV in gems)
            {
                if (typeFilters[gemKV.Key])
                {
                    var gemList = gemKV.Value;
                    for (int i = 0; i < gemList.Count; i++)
                    {
                        var gem = gemList[i];
                        if (gem.count >= 2)
                        {
                            var upResult = gem.Upgrade();
                            if (upResult != null)
                            {
                                resultList.Add(upResult);
                            }
                        }
                    }
                }
            }

            bool flag = false;
            if (resultList.Count > 0)
            {
                flag = true;
                var newGems = F.ListPool<Item.ItemInfo>.Get();
                for (int i = 0; i < resultList.Count; i++)
                {
                    int gemCount = resultList[i].count;
                    if (gemCount > 0)
                    {
                        newGems.Add(new Item.ItemInfo
                        {
                            id = resultList[i].itemId,
                            count = 1,
                        });
                    }
                }
                UI.RewardWindow.ShowRewards(newGems, null);
                F.ListPool<Item.ItemInfo>.Release(newGems);
                PostNotification(GlobalDefine.EVENT_GEM_CHANGED, null, "up_gem");
                PostNotification(GlobalDefine.EVENT_MONEY_CHANGED, null, "up_gem");
            }
            F.ListPool<EntityItemGem>.Release(resultList);
            return flag;
        }

        /// <summary>
        /// 一键镶嵌
        /// </summary>
        /// <param name="maxGemCount"></param>
        /// <returns></returns>
        public bool OneKeySetGems(int maxGemCount = 3)
        {
            var gems = GetGemsBySlot();
            return PlayerProxy.Instance.SetGems(gems);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public EntityItemEquipment RacastEquipments(EntityItemEquipment a, EntityItemEquipment b)
        {
            if (_recastEquipments.Count == 0)
            {
                var props = ItemProxy.Instance.GetStaticItems<ItemProp>();
                foreach (var prop in props)
                {
                    if (prop.quality == 6 && prop.isWeaponOrEquipment)
                    {
                        var item = ItemProxy.Instance.GetStaticItem<ItemEquipment>(prop.id);
                        if (_recastEquipments.TryGetValue(prop.level, out var list))
                        {
                            list.Add(item);
                        }
                        else
                        {
                            _recastEquipments.Add(prop.level, new List<ItemEquipment> { item });
                        }
                    }
                }
            }

            EntityItemEquipment result = null;
            if (a != null && b != null && a.propLevel == b.propLevel)
            {
                ItemProxy.Instance.RemoveEquipment(a);
                ItemProxy.Instance.RemoveEquipment(b);

                if (RandomProxy.Instance.GetRandom(RandomProxy.RACAST_RATE_ID + a.propLevel) && _recastEquipments.TryGetValue(a.propLevel, out var list))
                {
                    var aType = a.item.type;
                    var bType = b.item.type;

                    int aId = 0;
                    int bId = 0;
                    for (int i = 0; i < list.Count; i++)
                    {
                        var item = list[i];
                        if (item.type == aType)
                        {
                            if (aId == 0 || (item.type == 0 && item.subType == a.item.subType))
                                aId = item.id;
                        }
                        else if (item.type == bType)
                        {
                            if (bId == 0 || (item.type == 0 && item.subType == b.item.subType))
                                bId = item.id;
                        }
                    }

                    if (aId > 0 && bId > 0)
                        result = ItemProxy.Instance.NewEquipment(Random.value < 0.5f ? aId : bId);
                    else if (aId > 0)
                        result = ItemProxy.Instance.NewEquipment(aId);
                    else if (bId > 0)
                        result = ItemProxy.Instance.NewEquipment(bId);
                }
                else
                {
                    result = ItemProxy.Instance.NewEquipment(Random.value < 0.5f ? a.itemId : b.itemId);
                }

                if (result != null)
                {
                    MissionProxy.Instance.OnEvent(MissionProxy.装备累计重铸_次数);
                }
                return result;
            }
            return result;
        }

        #endregion

        #region Proxy

        const string ARCHIVE_KEY_V1 = "bag_V1";
        const string ARCHIVE_KEY_V2 = "bag_v2";

        void InitBag()
        {
            _bagCapacity = GlobalProxy.Instance.GetInt("bag_max");
            _autoSell = false;
            for (int i = 0; i < _sellQualityFilters.Length; i++)
            {
                _sellQualityFilters[i] = i < 4;
            }
        }

        void LoadBag()
        {
            var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V2);
            if (dataList != null && dataList.Count > 0)
            {
                _bagCapacity = dataList[0];

                _autoSell = dataList[1] != 0;
                int filter = dataList[2];
                for (int i = 0; i < _sellQualityFilters.Length; i++)
                {
                    _sellQualityFilters[i] = (filter & (1 << i)) != 0;
                }

                return;
            }

            dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V1);
            if (dataList != null && dataList.Count > 0)
            {
                _autoSell = dataList[0] != 0;
                int filter = dataList[1];
                for (int i = 0; i < _sellQualityFilters.Length; i++)
                {
                    _sellQualityFilters[i] = (filter & (1 << i)) != 0;
                }
                ArchiveProxy.Instance.RemoveIntList(ARCHIVE_KEY_V1);
            }
        }

        /// <summary>
        /// 
        /// </summary>
        void SaveBag()
        {
            var dataList = ArchiveProxy.Instance.GetIntList(ARCHIVE_KEY_V2);
            if (dataList != null)
            {
                dataList.Clear();
                dataList.Add(_bagCapacity);

                dataList.Add(autoSell ? 1 : 0);
                int sellFilter = 0;
                for (int i = 0; i < _sellQualityFilters.Length; i++)
                {
                    if (_sellQualityFilters[i])
                        sellFilter |= (1 << i);
                }
                dataList.Add(sellFilter);

                ArchiveProxy.Instance.SetIntList(ARCHIVE_KEY_V2, dataList);
            }
        }

        public static BagProxy Instance => GetInstance<BagProxy>();

        public override void ReadArchive()
        {
            InitBag();
            LoadBag();
        }

        #endregion
    }
}