/****************************************************
 文件：Assets/Code/Scripts/Gameplay/UI/Energy/EnergyManager.cs
 作者：yuntao-Hu
 时间：2024/5
 描述：管理体力相关信息
 接口：
    public int ItemIDBuyEnergyCount()
    public int GetItemIDBuyEnergy(int index)
    public int GetMaxEnergyPoint()
    public uint GetNowEnergy()
    public DateTime GetNextEnergyRecoverTime()

    public void BuyEnergy(int itemID, uint usageAmount)
    public bool isItemCanBuyEnergy(int itemID)
    public int GetConvertConsumes(int itemID, int usageAmount = 1)
    public int GetConvertRecharges(int itemID, int usageAmount = 1)

 *****************************************************/

using cfg.ActorCfg;
using Framework;
using Gameplay;
using Gameplay.Common;
using Gameplay.Net;
using NLDPB;
using PhxhSDK;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;

public class EnergyManager : Singlenton<EnergyManager>
{
    //private List<int> itemIdBuyEnergy = new List<int>(); //= { ENERGY_ITEM_ID, GLConfig.Inst.data.DiamondItemId };//更新体力补充方式时在此处添加物品ID
                                                                                                  //按优先级顺序，将钻石补充方式放在最后

    ConvertRatesWrap convertRatesWrap;

    #region class
    /// <summary>
    /// 存储体力转换率
    /// </summary>
    class ConvertRatesWrap
    {
        public int energyItemID;
        public readonly List<int> itemList;
        private Dictionary<int, ConversionRate> convertRates;

        public ConvertRatesWrap(int energyItemID)
        {
            this.energyItemID = energyItemID;
            convertRates = new Dictionary<int, ConversionRate>();
            itemList = new List<int>();

            List<DataItem> consumeItems = CategoryManager.Instance.GetItemsByType(StorageItemType.ConsumableItem, inStorage: false);
            foreach (var item in consumeItems)
            {
                if (item.Param2 == energyItemID)//物品可以转化为体力
                {
                    int itemID = item.ID;
                    AddRate(itemID, RateConfig(itemID));
                    itemList.Add(itemID);
                }
            }

            AddRate(GLConfig.Inst.data.DiamondItemId, CategoryManager.Instance.GetItemData(energyItemID).ExchangeParam[2], CategoryManager.Instance.GetItemData(energyItemID).ExchangeParam[0]);
            //AddRate(GLConfig.Inst.data.DiamondItemId, RateConfig(GLConfig.Inst.data.DiamondItemId));        //按优先级顺序，将钻石补充方式放在最后
            itemList.Add(GLConfig.Inst.data.DiamondItemId);

            //itemIdBuyEnergy.Add(GLConfig.Inst.data.DiamondItemId);

            //if (EnergyManager.Instance.itemIdBuyEnergy.Count == 0)
            //    Instance.loadAndInit(energyItemID);

            //for (int i = 0; i < EnergyManager.Instance.itemIdBuyEnergy.Count; i++)
            //{
            //    int itemID = EnergyManager.Instance.itemIdBuyEnergy[i];
            //    AddRate(itemID, RateConfig(itemID));
            //}
        }

        List<int> RateConfig(int itemID)
        {

            //if (itemID == GLConfig.Inst.data.DiamondItemId)
            //{
            //    return GLConfig.Inst.data.DiamondExchangeEnergy;
            //}
            //else
            //{
                DataItem itemData = CategoryManager.Instance.GetItemData(itemID);
                if (itemData == null || itemData.Param2 != energyItemID)//param2为转化物品ID
                {
                    DebugUtil.LogError("该道具不具备补充体力功能或并非可使用道具，错误物品id： " + itemID
                        + "\n请检查是否错误的将其加入itemIdBuyEnergy数组，或Item配置表中未配置道具转化参数");
                    return default;
                }
                return new List<int> { 1, itemData.Param3 };//兑换比例：1→Param3
            //}
        }
        void AddRate(int itemID, int consume, int recharge)
        {
            convertRates.Add(itemID, new ConversionRate(consume, recharge));
        }
        void AddRate(int itemID, List<int> exchangeRate)
        {
            if (exchangeRate == null)
            {
                DebugUtil.LogError("传入转化率list为null\n该物品已加入EnergyManager内itemIDBuyEnergy数组，但未配置转化率，错误物品id： " + itemID);
                return;
            }
            if (exchangeRate.Count >= 2)
                convertRates.Add(itemID, new ConversionRate(exchangeRate[0], exchangeRate[1]));
            else
                DebugUtil.LogError("转化率list传入参数不足！\n错误物品id： " + itemID);
        }

        //API
        public bool isRateContained(int itemID)
        {
            return convertRates.ContainsKey(itemID);
        }
        public int GetConsume(int itemID)
        {
            if (convertRates.ContainsKey(itemID))
            {
                return convertRates[itemID].consume;
            }
            else
            {
                DebugUtil.LogError("不包含的体力补充方式！请检查！");
                return default;
            }
        }
        public int GetRecharge(int itemID)
        {
            if (convertRates.ContainsKey(itemID))
            {
                return convertRates[itemID].recharge;
            }
            else
            {
                DebugUtil.LogError("不包含的体力补充方式！请检查！");
                return default;
            }
        }

        //class
        public class ConversionRate
        {
            public int consume;
            public int recharge;

            public ConversionRate(int consume, int recharge)
            {
                this.consume = consume;
                this.recharge = recharge;
            }
        }
    }
    #endregion

    void loadAndInit(int energyID)
    {
        if (convertRatesWrap == null || energyID != convertRatesWrap.energyItemID)
        {
            convertRatesWrap = new ConvertRatesWrap(energyID);
        }
    }

    #region API
    public int ItemIDBuyEnergyCount(int energyID)
    {
        if (convertRatesWrap == null || convertRatesWrap.energyItemID != energyID)
        {
            loadAndInit(energyID);
        }
        return convertRatesWrap.itemList.Count;
    }
    /// <summary>
    /// 根据索引获取购买体力物品ID
    /// </summary>
    /// <param name="index">补充体力方式索引</param>
    /// <returns></returns>
    public int GetItemIDBuyEnergy(int index, int energyID)
    {
        if (index < ItemIDBuyEnergyCount(energyID))
            return convertRatesWrap.itemList[index];
        else
        {
            DebugUtil.LogError("购买体力物品ID超出范围，请检查！");
            return 0;
        }
    }

    /// <summary>
    /// 获取最大体力
    /// </summary>
    /// <returns></returns>
    public int GetMaxEnergyPoint()
    {
        var level = Actor.Instance.Base.GetProp(ActorProp.Level);  
        var actorCfg = ActorLevelTableHelper.Instance.Get((int)level);
        return actorCfg.MaxEnergy;
    }
    /// <summary>
    /// 获取当前体力
    /// </summary>
    /// <returns></returns>
    public uint GetNowEnergy(int energyID = 0)
    {
        if (energyID == 0)
        {
            energyID = GLConfig.Inst.data.EnergyPointID;
        }
        return CategoryManager.Instance.GetItemCount(energyID);
    }
    /// <summary>
    /// 获取下一次体力恢复时间
    /// </summary>
    /// <returns></returns>
    public DateTime GetNextEnergyRecoverTime()
    {
        DateTime lastDateTime = CommonUtils.GetTimeByTimestamp(Actor.Instance.Logic.GetCount((uint)LogicID.EnergyRecoverTime));

        return lastDateTime.AddSeconds(TableManager.Instance.Tables.GlobalConfig.EnergyPointRecoverTime);
    }

    /// <summary>
    /// 检查体力是否足够
    /// </summary>
    /// <param name="requireEnergy"></param>
    /// <returns></returns>
    public bool EnergyCheck(int requireEnergy)
    {
        int nowEnergy = (int)GetNowEnergy();
        return nowEnergy >= requireEnergy;
    }

    /// <summary>
    /// 获取最大战斗次数
    /// </summary>
    /// <param name="oneEnergy">一次战斗所需的体力</param>
    /// <returns></returns>
    public int GetMaxFightCount(int oneEnergy)
    {
        int nowEnergy = (int)GetNowEnergy();

        return nowEnergy / oneEnergy;
    }

    /// <summary>
    /// 兑换体力
    /// </summary>
    /// <param name="itemID">消耗物品ID</param>
    /// <param name="usageAmount">物品使用份数</param>
    public void BuyEnergy(int itemID, uint usageAmount, int energyID)
    {
        if (isItemCanBuyEnergy(itemID, energyID))
        {
            if (itemID == GLConfig.Inst.data.DiamondItemId)
            {
                NetHelper.ConvertResources((uint)itemID, usageAmount, (uint)energyID);
            }
            else
            {
                CategoryManager.Instance.UseItem(itemID, (int)usageAmount, energyID);
            }//如果不是货币兑换方式，直接使用道具补充逻辑
        }
    }
    /// <summary>
    /// 该物品是否有补充体力功能
    /// </summary>
    /// <param name="itemID"></param>
    /// <returns></returns>
    public bool isItemCanBuyEnergy(int itemID,int energyID)
    {
        if (convertRatesWrap == null)
        {
            convertRatesWrap = new ConvertRatesWrap(energyID);
        }
        else
        {
            if (convertRatesWrap.energyItemID != energyID)
            {
                convertRatesWrap = new ConvertRatesWrap(energyID);
            }
        }
        return convertRatesWrap.isRateContained(itemID);
    }
    /// <summary>
    /// 每份物品补充体力时的物品实际消耗量，参数可设定份数
    /// </summary>
    /// <param name="itemID"></param>
    /// <param name="usageAmount">物品份数</param>
    /// <returns></returns>
    public int GetConvertConsumes(int itemID, int usageAmount = 1)
    {
        if (isItemCanBuyEnergy(itemID, convertRatesWrap.energyItemID))
            return usageAmount * convertRatesWrap.GetConsume(itemID);
        else
        {
            DebugUtil.LogError("补充体力列表内不包含该物品，不可补充体力!请检查\n错误物品ID: " + itemID);
            return 0;
        }

    }
    /// <summary>
    /// 每份物品补充体力时的体力补充量，参数可设定份数
    /// </summary>
    /// <param name="itemID"></param>
    /// <param name="usageAmount">物品份数</param>
    /// <returns></returns>
    public int GetConvertRecharges(int itemID, int usageAmount = 1)
    {
        if (isItemCanBuyEnergy(itemID, convertRatesWrap.energyItemID))
            return usageAmount * convertRatesWrap.GetRecharge(itemID);
        else
        {
            DebugUtil.LogError("补充体力列表内不包含该物品，不可补充体力!请检查\n错误物品ID: " + itemID);
            return 0;
        }
    }

    /// <summary>
    /// 获取当前选中状态下的最大消耗数目(实际数据需要乘比例转化)
    /// </summary>
    /// <param name="itemID"></param>
    /// <param name="itemLimited"></param>
    /// <returns></returns>
    public int MaxConsumeAmountWithoutConvert(int itemID, out bool itemLimited)
    {
        int maxConsumeRate = 0;
        int maxConsumeRateByEnergy = 0;

        if (!ValueValidator.IsIdValid(itemID))
        {
            DebugUtil.LogError("补充体力方式对应的物品ID不合规，请检查配置！\n错误物品ID: " + itemID);
        }
        int consumePerItem = GetConvertConsumes(itemID);
        int rechargePerItem = GetConvertRecharges(itemID);
        //道具数目限制
        uint AmountInStorage = CategoryManager.Instance.GetItemCount(itemID);
        if (consumePerItem != 0)
            maxConsumeRate = (int)(AmountInStorage / consumePerItem);

        //体力上限限制
        uint energyToMax = (uint)CategoryManager.Instance.GetItemMaxCount(convertRatesWrap.energyItemID) - CategoryManager.Instance.GetItemCount(convertRatesWrap.energyItemID);
        if (rechargePerItem != 0)
            maxConsumeRateByEnergy = (int)(energyToMax / rechargePerItem);

        itemLimited = maxConsumeRate <= maxConsumeRateByEnergy;

        return Math.Min(maxConsumeRate, maxConsumeRateByEnergy);
    }

    public int GetMaxEnergyByLevel(int level)
    {
        var cfg = ActorLevelTableHelper.Instance.Get(level);
        if (cfg != null)
        {
            return cfg.MaxEnergy;
        }

        return 0;
    }
    #endregion
}