using System.Linq;
using CombatLibrary.CombatLibrary.CombatCore.CustomizeTimeLogic.FxLogic;
using GameLogic.Combat.Buff;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using UnityEngine;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;

namespace GameLogic.Combat.Skill
{
    /// <summary>
    /// 火烧
    /// </summary>
    public class S30001 : SkillBasic
    {
        protected float _harm;
        protected float _maxTime;
        protected float _currTime;
        // private BetterList<ILifetCycleHitPoint> _currTrigger = new BetterList<ILifetCycleHitPoint>();
        protected TimeLineEventLogicGroupBasic loopGroupBasic;
        protected TimeLineEventLogicGroupBasic currMyLoopGroupBasic;
        protected bool _isUpdate;
        protected float _currAllTime;

        private BetterList<ILifetCycleHitPoint> _diffusionBuff = new BetterList<ILifetCycleHitPoint>();
        private BetterList<ILifetCycleHitPoint> _triggerDiffusion = new BetterList<ILifetCycleHitPoint>();

        protected override void ProInitSkillConfig()
        {
            _harm = SelfSkillConfig.effectValue[0];
            _maxTime = SelfSkillConfig.effectValue[1];
        }

        protected override void ProInitSkill()
        {
            SkillBasic skillBasic = CombatHeroEntity.CombatHeroSkillControl.GetSkillBasic(30004);
            if (skillBasic != null)
            {
                _maxTime += skillBasic.SelfSkillConfig.effectValue[0];
            }
        }
        // protected override ILifetCycleHitPoint[] ProGetTineLineTargetEntity(
        //     TimeLineEventLogicBasic timeLineEventLogicBasic)
        // {
        //     ILifetCycleHitPoint[] allHero = new ILifetCycleHitPoint[_enterAlertTarget.Count];
        //     for (int i = 0; i < _enterAlertTarget.Count; i++)
        //     {
        //         allHero[i] = _enterAlertTarget[i].GetMainHotPoin<ILifetCycleHitPoint>();
        //     }
        //
        //     return allHero;
        // }


        protected override void ProUseSkill()
        {
            _finishTimeLineGroupName = "-1";
            currMyLoopGroupBasic = ActivationTimeLineData("sk1");
            _isUpdate = true;
            _currTime = 0;
            _currAllTime = 0;
            _triggerDiffusion.Clear();
            _diffusionBuff.Clear();
        }

        protected override void ProBreakSkill()
        {
            Finish();
        }

        protected void Finish()
        {
            currMyLoopGroupBasic?.BreakTimeLine(CombatHeroEntity);
            if (loopGroupBasic != null)
            {
                loopGroupBasic.BreakTimeLine(CombatHeroEntity);
            }

            loopGroupBasic = null;
            _isUpdate = false;
            SpecialDotInfo specialDotInfo = CombatHeroEntity.GetMainHotPoin<ILifetCycleHitPoint>(true)
                .GetSpecialDotInfo("sk1_trigger");
            specialDotInfo.targetTran.gameObject.SetActive(false);
        }

        protected override void ProSkillPlayFinish()
        {
            Finish();
        }

        protected override void ProCombatUpdate(float time)
        {
            if (!_isUpdate)
            {
                return;
            }

            if (CombatHeroEntity.CombatAIBasic.currFocusTarget != null
                && !CombatHeroEntity.isDie)
            {
                Vector3 nextPos = CombatHeroEntity.CombatAIBasic.currFocusTarget.dotPos;
                Vector3 p = nextPos - CombatHeroEntity.dotPos;
                if (p.sqrMagnitude > 0.00001)
                {
                    CombatHeroEntity.combatHeroGameObject.rotation = Quaternion.Lerp(
                        CombatHeroEntity.combatHeroGameObject.rotation, Quaternion.LookRotation(p.normalized), 0.02f);
                }
            }

            _currTime += time;
            _currAllTime += time;
            if (_currTime > 0.2f)
            {
                _currTime -= 0.2f;
                long v = CombatCalculateTool.Instance.GetVlaueRatioForLong(
                    CombatHeroEntity.CurrCombatHeroInfo.attack.Value,
                    _harm);
                if (loopGroupBasic != null)
                {
                    loopGroupBasic.BreakTimeLine(CombatHeroEntity);
                }


                // _currTrigger.Clear();

                for (int i = 0; i < _enterAlertTarget.Count; i++)
                {
                    ILifetCycleHitPoint targetEntity = _enterAlertTarget[i].GetMainHotPoin<ILifetCycleHitPoint>();
                    // _currTrigger.Add(targetEntity);
                    HarmReturnInfo harmReturnInfo = Harm(CombatHeroEntity, targetEntity as CombatHeroHitPoint,
                        v, AttType.Skill, triggerData);
                    DiffusionBuff(targetEntity);
                }

                for (int i = 0; i < _diffusionBuff.Count; i++)
                {
                    DiffusionBuff(_diffusionBuff[i]);
                }

                // "sk1_hit"
                // string hitName = "sk1_hit_lv4";
                // loopGroupBasic = ActivationTimeLineData(hitName, _currTrigger);
            }

            if (_currAllTime > _maxTime)
            {
                SkillPlayFinish();
            }
        }

        protected void DiffusionBuff(ILifetCycleHitPoint diffusion)
        {
            if (diffusion == null)
            {
                return;
            }

            CombatHeroEntity diffusionCombatHeroEntity = diffusion.IfLifeCycle as CombatHeroEntity;
            if (diffusionCombatHeroEntity.isDie||!diffusionCombatHeroEntity.isActive)
            {
                _diffusionBuff.Remove(diffusion);
                return;
            }

            if (!_diffusionBuff.Contains(diffusion))
            {
                BuffInfo buffInfo = BuffInfo.GetBuffInfo(100101, 0.5f, 1);
               
                diffusionCombatHeroEntity.BuffControl.AddBuff(CombatHeroEntity, buffInfo);
                _diffusionBuff.Add(diffusion);
            }

            if (_triggerDiffusion.Contains(diffusion))
            {
                return;
            }

            _triggerDiffusion.Add(diffusion);
            ILifetCycleHitPoint[] allHitPoints =
                CombatController.currActiveCombat.CombatHeroController.GetHeroHitPoint(true);
            for (int i = 0; i < allHitPoints.Length; i++)
            {
                ILifetCycleHitPoint cycleHitPoint = allHitPoints[i];
                if (_diffusionBuff.Contains(cycleHitPoint))
                {
                    continue;
                }

                if (Vector3.SqrMagnitude(cycleHitPoint.Position - diffusion.Position) < 4)
                {
                    BuffInfo buffInfo = BuffInfo.GetBuffInfo(1001, -1, 1);
                    CombatHeroEntity combatHeroEntity = cycleHitPoint.IfLifeCycle as CombatHeroEntity;
                    combatHeroEntity.BuffControl.AddBuff(CombatHeroEntity, buffInfo);
                    _diffusionBuff.Add(diffusion);
                }
            }
        }
    }
}