using System.Collections;
using System.Collections.Generic;
using Animancer;
using Common.Utility.CombatEvent;
using Fort23.Common;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using GameLogic.Combat.Hero.HeroGPU;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Rendering;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;

public class CombatHeroEntity : CObject, ITimeLineSpecialDotPos, ILifeCycle, ITimeLineAnimtion, ITimeLineGetAttSpeed,
    IHero
{
    /// <summary>
    /// 死亡时的节点ID
    /// </summary>
    public int heroDieNodeId;

    public string guidName
    {
        get { return CurrCombatHeroInfo.modelName; }
    }

    public bool IsEnemy { get; set; }
    public bool isDie { get; set; }
    public int number;
    public CombatAIBasic CombatAIBasic;
    public CombatHeroGameObject combatHeroGameObject;
    public CombatHeroInfo CurrCombatHeroInfo;
    public CombatHeroInfo MaxCombatHeroInfo;
    public CombatHeroTimeLineControl combatHeroTimeLineControl;
    public HeroAnimtionBasic combatHeroAnimtion;
    public CombatHeroSkillControl CombatHeroSkillControl;

    public bool isFollowState;
    public BetterList<CombatParticleSystemPool> heroLoopParticle = new BetterList<CombatParticleSystemPool>();
    private float _lasetShowHarmTime;


    private float _injuriedShowTime;
    private bool _isAddinjuriedShow;
    private float _addInjuiedValue = (1.0f / 0.2f) * 0.3f;

    private bool _isDis;
    
    public float DisTime;

    public float HpBl {
        get
        {
            return CurrCombatHeroInfo.hp.Value*100f/MaxCombatHeroInfo.hp.Value;
        }
    }

    public Vector3 dotPos
    {
        get { return combatHeroGameObject.position; }
    }


    public T GetThis<T>() where T : IHero
    {
        return (T)(object)this;
    }

    public GameObject GameObject
    {
        get { return combatHeroGameObject.transform.gameObject; }
    }


    public Vector3 faceDir
    {
        get { return combatHeroGameObject.transform.forward; }
    }

    public async CTask<CombatHeroEntity> Init(CombatAIBasic combatAIBasic, CombatHeroInfo combatHeroInfo, Vector3 pos,
        System.Action<CombatHeroEntity> callBack = null)
    {
        //后面记到检查战斗里面不要出现异步加载，也不要出现同步IO加载

        string modelName = combatHeroInfo.modelName;
        if (combatHeroInfo.isGpu)
        {
            modelName += "_gpu";
        }

        CurrCombatHeroInfo = combatHeroInfo.Copy();
        MaxCombatHeroInfo = combatHeroInfo.Copy();
        // GameTimeLineParticleFactory
        CombatHeroGameObjectPool poolInterface =
            await GObjectPool.Instance.FetchAsync<CombatHeroGameObjectPool>(modelName + ".prefab", null);
#if !COMBAT_SERVER
        if (poolInterface == null || poolInterface.own == null)
        {
            return null;
        }

        poolInterface.own.transform.position = pos;
        if (!IsEnemy)
        {
            GameObjectPool fx_hero_quan =
                await GObjectPool.Instance.FetchAsync<GameObjectPool>("fx_hero_quan.prefab", null);
            fx_hero_quan.own.transform.SetParent(poolInterface.own.transform);
            fx_hero_quan.own.transform.localPosition = Vector3.zero;
        }

        poolInterface.own.SetActive(false);
        AssetHandle assetHandle =
            await AssetBundleLoadManager.Instance.LoadAssetAsyncTask<TextAsset>(combatHeroInfo.modelName + "_TD.txt");
        TextAsset textAsset = assetHandle.AssetObject<TextAsset>();
        combatHeroGameObject = new CombatHeroGameObject();
        combatHeroGameObject.Init(this, poolInterface);

        TimeLienData timeLienData = JsonManager.FromJson<TimeLienData>(textAsset.text);
        timeLienData.DeserializeData();
        assetHandle.Release();
        combatHeroTimeLineControl = new CombatHeroTimeLineControl();
        combatHeroTimeLineControl.Init(this, timeLienData);


        NavMeshAgent navMeshAgent = poolInterface.own.GetComponent<NavMeshAgent>();
        if (combatAIBasic == null)
        {
            combatAIBasic = new CombatAIBasic();
        }

        HeroEntityMono heroEntityMono = poolInterface.own.GetComponent<HeroEntityMono>();
        if (heroEntityMono == null)
        {
            heroEntityMono = poolInterface.own.AddComponent<HeroEntityMono>();
        }

        heroEntityMono.combatHeroEntity = this;
        CombatAIBasic = combatAIBasic;
        CombatAIBasic.Init(this, navMeshAgent);


        CombatHeroSkillControl = new CombatHeroSkillControl();
        CombatHeroSkillControl.Init(this);

        AnimancerComponent animancerComponent = poolInterface.own.GetComponent<AnimancerComponent>();
        if (animancerComponent != null)
        {
            combatHeroAnimtion = new CombatHeroAnimtion();
        }
        else
        {
            combatHeroAnimtion = new CombatHeroGPUAnimtion();
        }

        poolInterface.own.SetActive(true);
        combatHeroAnimtion.Init(this);
        CombatAIBasic.ChangeState(CombatHeroStateType.XiuMian);
        if (!IsEnemy|| CurrCombatHeroInfo.heroType==3)
        {
            CreateHeroHpEventData createHeroHpEventData = CreateHeroHpEventData.Create();
            createHeroHpEventData.combatHeroEntity = this;
            EventManager.Instance.Dispatch(CustomEventType.CreateHeroHp, createHeroHpEventData);
        }

       
        callBack?.Invoke(this);
#endif
        return this;
    }


    public void Update(float t)
    {
        // if (!CombatController.currActiveCombat.isStopAi)
        // {
            CombatAIBasic.Update(t);
        // }

        CombatHeroSkillControl.Update(t);
        combatHeroTimeLineControl.Update(t);
        combatHeroAnimtion.Update(t);
        combatHeroGameObject.Update(t);
        if (combatHeroGameObject.HeroGPUMono != null)
        {
            if (_injuriedShowTime > 0)
            {
                _injuriedShowTime -= t;
                if (_isAddinjuriedShow)
                {
                    combatHeroGameObject.HeroGPUMono.injuriedStrength += t * (_addInjuiedValue);
                    if (combatHeroGameObject.HeroGPUMono.injuriedStrength >= 0.3f)
                    {
                        _isAddinjuriedShow = false;
                    }
                }
                else
                {
                    combatHeroGameObject.HeroGPUMono.injuriedStrength -= t * (_addInjuiedValue);
                    if (combatHeroGameObject.HeroGPUMono.injuriedStrength < 0)
                    {
                        combatHeroGameObject.HeroGPUMono.injuriedStrength = 0;
                    }
                }
            }
            else
            {
                combatHeroGameObject.HeroGPUMono.injuriedStrength = 0;
            }
        }
    }


    public T This<T>()
    {
        return (T)(object)this;
    }

    public T GetILifetCycleHitPoint<T>(string hitPoinName, bool isStandType, bool isIgnoreHind)
        where T : ILifetCycleHitPoint
    {
        return combatHeroGameObject.GetILifetCycleHitPoint<T>(hitPoinName, isStandType, isIgnoreHind);
    }

    public T GetMainHotPoin<T>(bool isIgnoreHind = false) where T : ILifetCycleHitPoint
    {
        return combatHeroGameObject.GetMainHotPoin<T>(isIgnoreHind);
    }

    public void PlayAnim(string animName, bool isLoop, int layerId, bool repeat, float speed)
    {
        combatHeroAnimtion.Play(animName, speed);
    }

    public SpecialDotInfo GetSpecialDotInfo(string specialDotName)
    {
        return combatHeroGameObject.GetMainHotPoin<CombatHeroHitPoint>(true).GetSpecialDotInfo(specialDotName);
    }

    public float GetAttSpeed()
    {
        return CombatHeroSkillControl.NormalAttSpeedScale;
    }

    public void HeroResurrection()
    {
        isDie = false;
        CombatAIBasic.ChangeState(CombatHeroStateType.idle,isQiangZhi:true);
        HeroHpUpdateEventData heroHpUpdateEventData = HeroHpUpdateEventData.Create();
        heroHpUpdateEventData.combatHeroEntity = this;
        CombatEventManager.Instance.Dispatch(CombatEventType.HeroHpUpdate, heroHpUpdateEventData);
    }

    public void HeroDie(HarmReturnInfo harmReturnInfo)
    {
        heroDieNodeId = CombatController.currActiveCombat.CombatTypeBasic.allWinNodeCount;
        isDie = true;
        HeroDieEventData heroDieEventData = HeroDieEventData.Create();
        heroDieEventData.combatHeroEntity = this;
        heroDieEventData.HarmReturnInfo = harmReturnInfo;
        CombatEventManager.Instance.Dispatch(CombatEventType.HeroDie, heroDieEventData);

        combatHeroGameObject.HeroDie();
        CombatAIBasic.ChangeState(CombatHeroStateType.dile);
    }

    public void HeroHurt(HarmReturnInfo harmReturnInfo)
    {
        CurrCombatHeroInfo.hp -= harmReturnInfo.att;
        UpdateHarmText(harmReturnInfo);
        if (combatHeroGameObject.HeroGPUMono != null)
        {
            _injuriedShowTime = 0.4f;
            combatHeroGameObject.HeroGPUMono.injuriedStrength = 0;
            _isAddinjuriedShow = true;
        }

        HeroHpUpdateEventData heroHpUpdateEventData = HeroHpUpdateEventData.Create();
        heroHpUpdateEventData.combatHeroEntity = this;
        CombatEventManager.Instance.Dispatch(CombatEventType.HeroHpUpdate, heroHpUpdateEventData);
        if (CurrCombatHeroInfo.hp <= 0)
        {
            HeroDie(harmReturnInfo);
        }
    }

    private void UpdateHarmText(HarmReturnInfo harmReturnInfo)
    {
        float currTime = Time.time;
        if (currTime - _lasetShowHarmTime < 0.1f)
        {
            return;
        }

        _lasetShowHarmTime = currTime;
        HarmUpdateEventData harmUpdateEventData = HarmUpdateEventData.Create();
        harmUpdateEventData.HarmReturnInfo = harmReturnInfo;
        CombatEventManager.Instance.Dispatch(CombatEventType.HarmUpdate, harmUpdateEventData);
    }

    public void Recover(HarmReturnInfo harmReturnInfo)
    {
        CurrCombatHeroInfo.hp += harmReturnInfo.att;
        HarmUpdateEventData harmUpdateEventData = HarmUpdateEventData.Create();
        harmUpdateEventData.HarmReturnInfo = harmReturnInfo;
        CombatEventManager.Instance.Dispatch(CombatEventType.RecoverUpdate, harmUpdateEventData);

        HeroHpUpdateEventData heroHpUpdateEventData = HeroHpUpdateEventData.Create();
        heroHpUpdateEventData.combatHeroEntity = this;
        CombatEventManager.Instance.Dispatch(CombatEventType.HeroHpUpdate, heroHpUpdateEventData);
    }

    public void CloseLoopFx()
    {
        for (int i = 0; i < heroLoopParticle.Count; i++)
        {
            GObjectPool.Instance.Recycle(heroLoopParticle[i]);
        }

        heroLoopParticle.Clear();
    }

    public bool IsAttDis(Vector3 pos)
    {
        return Vector3.SqrMagnitude(pos - combatHeroGameObject.transform.position) < CurrCombatHeroInfo.maxDisTo;
    }

    public void Dispose()
    {
        if (_isDis)
        {
            return;
        }

        _isDis = true;
        combatHeroGameObject.Dispose();
        isDie = true;
        CombatHeroSkillControl.Dispose();
       
        CombatAIBasic.Dispose();
        combatHeroTimeLineControl.Dispose();
        combatHeroAnimtion.Dispose();
        CloseLoopFx();
    }

    private void ProDormancyObj()
    {
        CombatHeroSkillControl.ProDormancyObj();
    }

    public override void ActiveObj()
    {
        isDie = false;
        _isDis = false;
    }

   

    public override void DormancyObj()
    {
        Dispose();
        ProDormancyObj();
        _isDis = false;
        CombatAIBasic = null;
        combatHeroGameObject = null;
        CurrCombatHeroInfo = null;
        MaxCombatHeroInfo = null;
        combatHeroTimeLineControl = null;
        combatHeroAnimtion = null;
        CombatHeroSkillControl = null;
        isFollowState = false;
        heroLoopParticle.Clear();
        isDie = true;
    }
}