using Animancer;
using Common.Utility.CombatEvent;
using Excel2Json;
using Fort23.Core;
using Fort23.UTool;
using GameLogic.Combat.Buff;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero.State;
using GameLogic.Combat.Skill;
using UnityEngine;
using UnityEngine.AI;

namespace GameLogic.Combat.Hero
{
    /// <summary>
    /// 法宝对象
    /// </summary>
    public class CombatMagicWeaponEntity : CombatHeroEntity
    {
        /// <summary>
        /// 碰撞的target
        /// </summary>
        public CombatMagicWeaponEntity CollidingTarget;

        public int MagicWeaponCollisionId = -1;
        protected MagicWeaponConfig _magicWeaponConfig;
        public float cd = 2;


        public float HpBl
        {
            get { return _HpBl; }
        }

        private float _HpBl = 100;

        public int useIndex;

        /// <summary>
        /// 是否进入战斗状态
        /// </summary>
        public bool isCombatState;

        private MagicWeaponControl _magicWeaponControl;

        public MagicWeaponControl MagicWeaponControl
        {
            get { return _magicWeaponControl; }
        }

        private BetterList<SkillBasic> allSkill = new BetterList<SkillBasic>();

        private MagicWeaponConfig magicWeaponConfig;

        public void ReduceHp(float value)
        {
            _HpBl -= value;
            if (_HpBl <= 0)
            {
                HeroDieEventData heroDieEventData = HeroDieEventData.Create();
                heroDieEventData.combatHeroEntity = this;
                CombatEventManager.Instance.Dispatch(CombatEventType.MagicWeaponDie,
                    heroDieEventData);

                CombatAIBasic.ChangeState(CombatHeroStateType.dile);
            }
        }

        public async CTask<CombatMagicWeaponEntity> Init(MagicWeaponControl magicWeaponControl,
            MagicWeaponConfig magicWeaponConfig,
            System.Action<CombatMagicWeaponEntity> callBack = null)
        {
            this.magicWeaponConfig = magicWeaponConfig;
            this._magicWeaponControl = magicWeaponControl;
            string modelName = magicWeaponConfig.model;

            cd = magicWeaponConfig.cd;

            // 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 = Vector3.one;

            poolInterface.own.SetActive(false);

            combatHeroTimeLineControl = new CombatHeroTimeLineControl();
            combatHeroTimeLineControl.Init(this);
            AssetHandle assetHandle =
                await AssetBundleLoadManager.Instance.LoadAssetAsyncTask<TextAsset>(
                    modelName + "_TD.txt");
            if (assetHandle != null)
            {
                TextAsset textAsset = assetHandle.AssetObject<TextAsset>();
                TimeLienData timeLienData = JsonManager.FromJson<TimeLienData>(textAsset.text);
                timeLienData.DeserializeData();
                assetHandle.Release();
                combatHeroTimeLineControl.AddTimeLienData(timeLienData);
            }

            combatHeroGameObject = new CombatHeroGameObject();
            combatHeroGameObject.Init(this, poolInterface);
            CombatHeroSkillControl = new CombatHeroSkillControlBasic();
            CombatHeroSkillControl.Init(this);
            if (magicWeaponConfig.skillID != null)
            {
                for (int i = 0; i < magicWeaponConfig.skillID.Length; i++)
                {
                    int id = magicWeaponConfig.skillID[i] * 10 + 1;
                    SkillConfig skillConfig = ConfigComponent.Instance.Get<SkillConfig>(id);
                    CombatHeroSkillControl.AddSkill(skillConfig);
                }
            }


            if (CombatAIBasic == null)
            {
                CombatAIBasic = new MagicWeaponAi();
            }

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

            heroEntityMono.combatHeroEntity = this;

            CombatAIBasic.Init(this);


            // AnimancerComponent animancerComponent = poolInterface.own.GetComponentInChildren<AnimancerComponent>();
            combatHeroAnimtion = new CombatHeroAnimtion();

            poolInterface.own.SetActive(true);
            combatHeroAnimtion.Init(this);
            CombatAIBasic.ChangeState(CombatHeroStateType.XiuMian);
#endif
            callBack?.Invoke(this);
            return this;
        }

        public override float GetAttSpeed()
        {
            return 1;
        }

        public override void Update(float t)
        {
            combatHeroTimeLineControl.Update(t);
            CombatAIBasic?.Update(t);
            CombatHeroSkillControl?.Update(t);
            if (CombatAIBasic.CurrState.GetType() == typeof(MagicWeapomDormancyState))
            {
                cd -= t;

                if (cd <= 0 && _magicWeaponControl.combatHeroEntity.CombatAIBasic.currFocusTarget != null)
                {
                    _HpBl = 100;
                    cd = magicWeaponConfig.cd;
                    CollidingTarget = null;
                    _magicWeaponControl.UseMagicWeapon(this);
                }
            }
        }
    }
}