using System.Collections.Generic;
using cfg.BuffCfg;
using Gameplay.Unit.Data;
using UnityEngine;
namespace Gameplay.Buff
{
    public class BuffChangeProp : BaseBuff
    {

        private List<EPropType> _propList;
        private List<float> _changeList;
        private Queue<float> _cacheValues = new Queue<float>(10);
        private int _propCount;

        protected override void _OnInit()
        {
            base._OnInit();

            _propList = configData.PorpParams;
            _changeList = configData.FloatParams;
            _cacheValues.Clear();

            if (_propList.Count != _changeList.Count)
            {
                DebugUtil.LogError("BuffChangeProp的属性数量和变化值数量不一致: buff id- {0}", configData.ID);
                _propCount = Mathf.Min(_propList.Count, _changeList.Count);
            }
            else
            {
                // 数据一致
                _propCount = _propList.Count;
            }
        }

        private void _ReCalcShootCD()
        {
            DebugUtil.Log("原始射击间隔:{0},射速加成:{1}", owner.fightData.baseShootCd, owner.fightData.p_shootCdScale);
            owner.fightData.shootCd = owner.fightData.baseShootCd * (1 + (1 / Mathf.Max(1 + owner.fightData.p_shootCdScale, 0.01f) - 1));
            DebugUtil.Log("新射击间隔:{0}", owner.fightData.shootCd);
        }

        protected override void _OnAdd()
        {
            base._OnAdd();
            for (int i = 0; i < _propCount; i++)
            {
                var propType = _propList[i];
                var changeValue = _changeList[i];
                _HandleForAddSingle(propType, changeValue);
            }
        }

        private void _HandleForAddSingle(EPropType propType,
            float changeValue)
        {
            switch (propType)
            {
                case EPropType.MoveSpeed:
                {
                    var cacheValue = changeValue;
                    owner.fightData.moveSpeed += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.BeDamageScale:
                {
                    var cacheValue = changeValue;
                    owner.fightData.beDamageScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.FinalDamageScale:
                {
                    var cacheValue = changeValue;
                    owner.fightData.finalDamageScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.MoraleDamageScale:
                {
                    var cacheValue = changeValue;
                    owner.fightData.moraleDamageScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.BeMoraleDamageScale:
                {
                    var cacheValue = changeValue;
                    owner.fightData.moraleBeDamageScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.AttackValue:
                {
                    var cacheValue = changeValue;
                    owner.fightData.attack += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.DefenseValue:
                {
                    var cacheValue = changeValue;
                    owner.fightData.defense += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.ShootRate:
                {
                    var cacheValue = changeValue;
                    owner.fightData.p_shootCdScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    // 射击间隔 * ( 1+ （1/(1+射速加成) -1) )
                    _ReCalcShootCD();
                    _UpdateViewShootCd();
                    break;
                case EPropType.MoveShoot:
                {
                    var cacheValue = changeValue;
                    _cacheValues.Enqueue(cacheValue);
                    // 只有角色才有移动射击
                    if (owner.gameunitType == EGameUnitType.Character)
                    {
                        if (owner is Character.Character character)
                            character.runtimeData.fightData.moveShootType += (int)cacheValue;
                    }
                }

                    break;
                case EPropType.MoveSpeedPercent:
                {
                    var cacheValue = creator.fightData.baseMoveSpeed * changeValue;
                    owner.fightData.moveSpeed += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.RetretSpeedPercent:
                {
                    var cacheValue = creator.fightData.baseRetreatSpeed * changeValue;
                    owner.fightData.retreatSpeed += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.AttackValuePercent:
                {
                    var cacheValue = creator.fightData.baseAttack * changeValue;
                    owner.fightData.attack += (int)cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.DefenseValuePercent:
                {
                    var cacheValue = creator.fightData.baseDefense * changeValue;
                    owner.fightData.defense += (int)cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.AttackDistancePercent:
                {
                    var cacheValue = changeValue;
                    creator.fightData.baseAttackDistanceScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    _UpdateBaseAttackDistance();
                    break;
                case EPropType.AttackDistance:
                {
                    var cacheValue = Mathf.RoundToInt(changeValue);
                    creator.fightData.baseAttackDistanceFixed += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    _UpdateBaseAttackDistance();
                    break;
                case EPropType.SkillReleaseDistancePercent:
                {
                    var cacheValue = changeValue;
                    creator.fightData.skillReleaseDistanceScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.ReloadTimePercent:
                {
                    var cacheValue = creator.fightData.baseReloadTime * changeValue;
                    owner.fightData.reloadTime += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    _UpdateViewReloadCd();
                    break;
                case EPropType.MoraleRecoverScale:
                {
                    var cacheValue = changeValue;
                    owner.fightData.moraleRecoverScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.DamageScaleForVehicle:
                {
                    var cacheValue = changeValue;
                    owner.fightData.scaleForVehicle += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.IgnoreShieldRate:
                {
                    var cacheValue = changeValue;
                    owner.fightData.ignoreShieldRate += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.ignoreDebuffRate:
                {
                    var cacheValue = changeValue;
                    owner.fightData.ignoreDebuffRate += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.MaxBullet:
                {
                    var cacheValue = Mathf.CeilToInt(changeValue * owner.fightData.baseMaxBulletCount);
                    owner.fightData.maxBulletCount += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.RetreatTime:
                {
                    var cacheValue = changeValue;
                    owner.fightData.retreateTime += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.RetreatTimePercent:
                {
                    var cacheValue = owner.fightData.baseRetreateTime * changeValue;
                    owner.fightData.retreateTime += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.LastBulletDamageScale:
                {
                    var cacheValue = changeValue;
                    owner.fightData.lastBulletDamageScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.DamageScaleForHuman:
                {
                    var cacheValue = changeValue;
                    owner.fightData.scaleForHuman += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.SkillCDReduceScale:
                {
                    var cacheValue = changeValue;
                    owner.fightData.skillCdReduceScale += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.MoraleDamage:
                {
                    var cacheValue = changeValue;
                    owner.fightData.moraleAttack += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.AttackEndTimeFix:
                {
                    var cacheValue = changeValue;
                    owner.fightData.attackEndTime += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    _UpdateViewAttackEndTime();
                    break;
                case EPropType.AttackEndTimePercent:
                {
                    var cacheValue = owner.fightData.baseAttackEndTime * changeValue;
                    owner.fightData.attackEndTime += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    _UpdateViewAttackEndTime();
                    break;
                case EPropType.HitRateFix:
                {
                    var cacheValue = changeValue;
                    _ChangeHitRateFix(cacheValue);
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.HitRatePercent:
                    // 在内部进行缓存处理
                    _ChangeHitRatePercent(changeValue);
                    break;
                case EPropType.MaxBulletPercent:
                {
                    var cacheValue = Mathf.CeilToInt(changeValue * owner.fightData.baseMaxBulletCount);
                    owner.fightData.maxBulletCount += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                case EPropType.PerReloadPercent:
                {
                    var cacheValue = Mathf.CeilToInt(changeValue * owner.fightData.basePerReloadCount);
                    owner.fightData.perReloadCount += cacheValue;
                    _cacheValues.Enqueue(cacheValue);
                }
                    break;
                default:
                    DebugUtil.LogError("暂未处理的属性类型:{0}", propType);
                    break;
            }
        }

        private void _ChangeHitRatePercent(float changePercent)
        {
            for (int i = 0; i < owner.fightData.distanceHitRate.Count; i++)
            {
                var baseHitRate = owner.fightData.baseDistanceHitRate[i];
                var cacheValue = baseHitRate * changePercent;
                owner.fightData.distanceHitRate[i] += cacheValue;
                _cacheValues.Enqueue(cacheValue);
            }
        }

        private void _RevertChangeHitRatePercent()
        {
            for (int i = 0; i < owner.fightData.distanceHitRate.Count; i++)
            {
                var cacheValue = _cacheValues.Dequeue();
                owner.fightData.distanceHitRate[i] -= cacheValue;
            }
        }

        private void _ChangeHitRateFix(float changeValue)
        {
            for (int i = 0; i < owner.fightData.distanceHitRate.Count; i++)
            {
                owner.fightData.distanceHitRate[i] += changeValue;
            }
        }

        private void _UpdateBaseAttackDistance()
        {
            owner.fightData.normalAttackDistance = Mathf.CeilToInt(
                creator.fightData.baseAttackDistance * creator.fightData.baseAttackDistanceScale
                + creator.fightData.baseAttackDistanceFixed);
        }

        private void _UpdateViewReloadCd()
        {
            switch (owner.gameunitType)
            {
                case EGameUnitType.Character:
                {
                    if (owner is Character.Character character)
                    {
                        character.cAnim.ResetReloadAnim();
                    }
                }
                    break;
            }
        }

        private void _UpdateViewShootCd()
        {
            switch (owner.gameunitType)
            {
                case EGameUnitType.Character:
                {
                    if (owner is Character.Character character)
                    {
                        character.cAnim.ResetShootAnim();
                    }
                }
                    break;
            }
        }

        private void _UpdateViewAttackEndTime()
        {
            switch (owner.gameunitType)
            {
                case EGameUnitType.Character:
                {
                    if (owner is Character.Character character)
                    {
                        character.cAnim.ResetAttackEndAnim();
                    }
                }
                    break;
            }
        }

        protected override void _OnRemove()
        {
            base._OnRemove();
            for (int i = 0; i < _propCount; i++)
            {
                var propType = _propList[i];
                switch (propType)
                {
                    case EPropType.MoveSpeed:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.moveSpeed -= cacheValue;
                    }
                        break;
                    case EPropType.BeDamageScale:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.beDamageScale -= cacheValue;
                    }
                        break;
                    case EPropType.FinalDamageScale:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.finalDamageScale -= cacheValue;
                    }
                        break;
                    case EPropType.MoraleDamageScale:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.moraleDamageScale -= cacheValue;
                    }
                        break;
                    case EPropType.BeMoraleDamageScale:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.moraleBeDamageScale -= cacheValue;
                    }
                        break;
                    case EPropType.AttackValue:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.attack -= cacheValue;
                    }
                        break;
                    case EPropType.DefenseValue:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.defense -= cacheValue;
                    }
                        break;
                    case EPropType.ShootRate:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.p_shootCdScale -= cacheValue;
                    }
                        // 射击间隔 * ( 1+ （1/(1+射速加成) -1) )
                        _ReCalcShootCD();
                        _UpdateViewShootCd();
                        break;
                    case EPropType.MoveShoot:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        // 只有角色才有移动射击
                        if (owner.gameunitType == EGameUnitType.Character)
                        {
                            if (owner is Character.Character character)
                                character.runtimeData.fightData.moveShootType -= (int)cacheValue;
                        }
                    }
                        break;
                    case EPropType.MoveSpeedPercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.moveSpeed -= cacheValue;
                    }
                        break;
                    case EPropType.RetretSpeedPercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.retreatSpeed -= cacheValue;
                    }
                        break;
                    case EPropType.AttackValuePercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.attack -= cacheValue;
                    }
                        break;
                    case EPropType.DefenseValuePercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.defense -= cacheValue;
                    }
                        break;
                    case EPropType.AttackDistancePercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.baseAttackDistanceScale -= cacheValue;
                    }
                        _UpdateBaseAttackDistance();
                        break;
                    case EPropType.AttackDistance:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.baseAttackDistanceFixed -= Mathf.RoundToInt(cacheValue);
                    }
                        _UpdateBaseAttackDistance();
                        break;
                    case EPropType.SkillReleaseDistancePercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.skillReleaseDistanceScale -= cacheValue;
                    }
                        break;
                    case EPropType.ReloadTimePercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.reloadTime -= cacheValue;
                    }
                        _UpdateViewReloadCd();
                        break;
                    case EPropType.MoraleRecoverScale:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.moraleRecoverScale -= cacheValue;
                    }
                        break;
                    case EPropType.DamageScaleForVehicle:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.scaleForVehicle -= cacheValue;
                    }
                        break;
                    case EPropType.IgnoreShieldRate:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.ignoreShieldRate -= cacheValue;
                    }
                        break;
                    case EPropType.ignoreDebuffRate:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.ignoreDebuffRate -= cacheValue;
                    }
                        break;
                    case EPropType.MaxBullet:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.maxBulletCount -= Mathf.RoundToInt(cacheValue);
                    }
                        break;
                    case EPropType.RetreatTime:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.retreateTime -= cacheValue;
                    }
                        break;
                    case EPropType.RetreatTimePercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.retreateTime -= cacheValue;
                    }
                        break;
                    case EPropType.LastBulletDamageScale:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.lastBulletDamageScale -= cacheValue;
                    }
                        break;
                    case EPropType.DamageScaleForHuman:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.scaleForHuman -= cacheValue;
                    }
                        break;
                    case EPropType.SkillCDReduceScale:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.skillCdReduceScale -= cacheValue;
                    }
                        break;
                    case EPropType.MoraleDamage:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.moraleAttack -= cacheValue;
                    }
                        break;
                    case EPropType.AttackEndTimeFix:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.attackEndTime -= cacheValue;
                    }
                        _UpdateViewAttackEndTime();
                        break;
                    case EPropType.AttackEndTimePercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.attackEndTime -= cacheValue;
                    }
                        _UpdateViewAttackEndTime();
                        break;
                    case EPropType.HitRateFix:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        _ChangeHitRateFix(-cacheValue);
                    }
                        break;
                    case EPropType.HitRatePercent:
                        // 内部处理
                        _RevertChangeHitRatePercent();
                        break;
                    case EPropType.MaxBulletPercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.maxBulletCount -= Mathf.RoundToInt(cacheValue);
                    }
                        break;
                    case EPropType.PerReloadPercent:
                    {
                        var cacheValue = _cacheValues.Dequeue();
                        owner.fightData.perReloadCount -= Mathf.RoundToInt(cacheValue);
                    }
                        break;
                    default:
                        DebugUtil.LogError("暂未处理的属性类型:{0}", propType);
                        break;
                }
            }
        }

    }
}