using Core.Utilities;
using System.Collections.Generic;
using UnityEngine;

namespace KTGMGemClient
{
    /// <summary>
    /// 无尽模式buff管理器
    /// </summary>
    public class EndlessBuffManager : Singleton<EndlessBuffManager>
    {
        /// <summary>
        /// 玩家拥有的buff列表
        /// </summary>
        public List<EndlessBuffConfig> BuffList;

        /// <summary>
        /// buff处理类实例列表
        /// </summary>
        private List<EndlessBuff> instanceList;

        private void Start()
        {
            BuffList = new List<EndlessBuffConfig>();
            // 新增buff，需要把实例添加进来
            instanceList = new List<EndlessBuff>()
            {
                // 攻击力增加的buff没有什么需要处理的，如果需要新写个类继承EndlessBuff即可
                new EndlessBuff(),
                new GoldAdd(),
                new ObtainTower(),
                new DecreaseTowerAttackCD(),
                new CritProbabilityAdd(),
                new CritDamageAdd(),
                new CritBulletAdd(),
                new SlowDown(),
                new FireRateAdd()
            };
        }

        /// <summary>
        /// 玩家获得一个buff
        /// </summary>
        public void AddBuff(EndlessBuffConfig buff)
        {
            ++buff.SelectCount;

            // 0表示只要被选择过，以后就不再出现了
            if (buff.Config.is_repeated == 0)
                EndlessBuffData.RemoveFromBuffPool(buff.Config.id);

            BuffList.Add(buff);
            EndlessBuff endlessBuff = GetBuffInstanceByType((EndlessBuffEffectType)buff.Config.buff_effect[0]);

            endlessBuff.BuffList.Add(buff);
            endlessBuff.Handle();

            // 如果是一次性生效的buff，直接移除掉
            if (buff.LifeCycleType == EndlessBuffLifeCycleType.Once)
            {
                endlessBuff.BuffList.Remove(buff);
                RemoveBuff(buff);
            }
        }

        /// <summary>
        /// 直接从buff列表中移除某一个buff
        /// </summary>
        /// <param name="buff"></param>
        public void RemoveBuff(EndlessBuffConfig buff)
        {
            BuffList.Remove(buff);
            EndlessBuff endlessBuff = GetBuffInstanceByType((EndlessBuffEffectType)buff.Config.buff_effect[0]);
            endlessBuff.LoseEffect();
        }

        /// <summary>
        /// 更新buff列表，以波为单位，一个波次结束后调用此方法去更新buff列表
        /// 这个方法主要是处理buff的生命周期，把无效的移除掉
        /// </summary>
        /// <param name="waves">一次更新的波数，默认以一波为一个节点去更新</param>
        public void UpdateBuffList(int waves = 1)
        {
            int len = BuffList.Count;

            for (int i = 0; i < len; ++i)
            {
                if (BuffList[i].LifeCycleType == EndlessBuffLifeCycleType.LimitedWave)
                {
                    BuffList[i].TackEffectWaves += waves;

                    if (BuffList[i].TackEffectWaves >= BuffList[i].TotalEffectWaves)
                    {
                        // 超过波次数量限制，移除掉
                        RemoveBuff(BuffList[i]);
                        len = BuffList.Count;
                    }
                }
            }

            EventCenter.Ins.BroadCast((int)KTGMGemClient.EventType.EndlessBuffRefresh);
        }

        /// <summary>
        /// 根据buff效果类型获得buff列表数据
        /// </summary>
        /// <param name="type">buff效果类型</param>
        /// <param name="id">宝石技能id</param>
        public List<EndlessBuffConfig> GetBuffListByEffectType(EndlessBuffEffectType type, int id)
        {
            List<EndlessBuffConfig> ret = new List<EndlessBuffConfig>();
            // 暂且先这么处理吧 如果1：火 2：水 3：木
            int attributeId = (int)Mathf.Floor(id / 10000f);

            for (int i = 0; i < BuffList.Count; ++i)
            {
                if (BuffList[i].EffectType == type)
                {
                    bool isWork = false;

                    switch (BuffList[i].UseTarget)
                    {
                        case EndlessBuffUseTarget.All:
                            isWork = true;
                            break;
                        case EndlessBuffUseTarget.Element:
                            isWork = attributeId == BuffList[i].Config.target_type[1];
                            break;
                        case EndlessBuffUseTarget.Designated:
                            isWork = id == BuffList[i].Config.target_type[1];
                            break;
                    }

                    if (isWork)
                        ret.Add(BuffList[i]);
                }
            }

            return ret;
        }

        /// <summary>
        /// 根据buff类型获得buff处理类实例
        /// </summary>
        /// <param name="type"></param>
        /// <returns></returns>
        public EndlessBuff GetBuffInstanceByType(EndlessBuffEffectType type)
        {
            return instanceList[(int)type - 1];
        }
    }
}