using System;
using Common.Utility.CombatEvent;
using Fort23.Core;
using GameLogic.Combat.Hero;
using UnityEngine;
using UTool.CustomizeTimeLogic.FxLogic.TimeLineEventinterface;

namespace GameLogic.Combat.CombatTool
{
    public class CombatHeroController : IDisposable
    {
        private BetterList<CombatHeroEntity> myHero = new BetterList<CombatHeroEntity>();
        private BetterList<CombatHeroEntity> enemyHero = new BetterList<CombatHeroEntity>();

        private BetterList<ILifetCycleHitPoint> myHeroHitPoint = new BetterList<ILifetCycleHitPoint>();
        private BetterList<ILifetCycleHitPoint> enemyHeroHitPoint = new BetterList<ILifetCycleHitPoint>();
        protected CombatController combatController;

        private BetterList<CombatHeroEntity> heroDie = new BetterList<CombatHeroEntity>();
        private BetterList<CombatHeroEntity> heroDispose = new BetterList<CombatHeroEntity>();

        public Vector3[] followMovePos = new Vector3[]
        {
            new Vector3(0, 0, 0),
            new Vector3(-1f, 0, -0.5f),
            new Vector3(1f, 0, -0.5f),
            new Vector3(0, 0, -2f),
        };

        public CombatHeroEntity followTarget;

        public void Init(CombatController combatController)
        {
            this.combatController = combatController;
            CombatEventManager.Instance.AddEventListener(CombatEventType.UseSkill, CombatUseSkillEventData);
        }

        public void RemoveDieHero(CombatHeroEntity combatHeroEntity)
        {
            heroDie.Remove(combatHeroEntity);
            if (!heroDispose.Contains(combatHeroEntity))
            {
                heroDispose.Add(combatHeroEntity);
            }
        }

        public void Update(float t)
        {
            for (int i = 0; i < myHero.Count; i++)
            {
                myHero[i].Update(t);
            }

            for (int i = 0; i < enemyHero.Count; i++)
            {
                enemyHero[i].Update(t);
            }

            for (int i = 0; i < heroDie.Count; i++)
            {
                heroDie[i].Update(t);
            }

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

            heroDispose.Clear();
        }

        public void AddHeroDie(CombatHeroEntity hero)
        {
            heroDie.Add(hero);
        }

        public void AddHero(CombatHeroEntity hero)
        {
            if (hero.IsEnemy)
            {
                enemyHero.Add(hero);
            }
            else
            {
                myHero.Add(hero);
            }
        }

        public void FindNumberMinHero()
        {
            int min = 9999;
            followTarget = null;
            for (int i = 0; i < myHero.Count; i++)
            {
                CombatHeroEntity c = myHero[i];
                if (c.number < min)
                {
                    min = c.number;
                    followTarget = c;
                }
            }
        }

        public void SetFollowTarget()
        {
            FindNumberMinHero();
            for (int i = 0; i < myHero.Count; i++)
            {
                CombatHeroEntity c = myHero[i];
                if (c != followTarget)
                {
                    c.isFollowState = true;
                    c.CombatAIBasic.ChangeState(CombatHeroStateType.followIdle);
                }
            }
        }

        private void CombatUseSkillEventData(IEventData iEventData)
        {
            CombatUseSkillEventData combatUseSkillEventData = iEventData as CombatUseSkillEventData;
            if (combatUseSkillEventData.useSkill.SelfSkillConfig.SkillType == 1)
            {
                for (int i = 0; i < myHero.Count; i++)
                {
                    CombatHeroEntity c = myHero[i];
                    if (c.isFollowState)
                    {
                        c.isFollowState = false;
                        c.CombatAIBasic.ChangeState(CombatHeroStateType.idle);
                    }
                }
            }
        }

        public void RemoveHero(CombatHeroEntity hero)
        {
            if (hero.IsEnemy)
            {
                enemyHero.Remove(hero);
            }
            else
            {
                myHero.Remove(hero);
            }
        }

        public void AddHeroHitPoint(bool isEnemy, ILifetCycleHitPoint hitPoint)
        {
            if (isEnemy)
            {
                enemyHeroHitPoint.Add(hitPoint);
            }
            else
            {
                myHeroHitPoint.Add(hitPoint);
            }
        }

        public void RemoveHeroHitPoint(bool isEnemy, ILifetCycleHitPoint hitPoint)
        {
            if (isEnemy)
            {
                enemyHeroHitPoint.Remove(hitPoint);
            }
            else
            {
                myHeroHitPoint.Remove(hitPoint);
            }
        }

        public void Dispose()
        {
            myHero.Dispose();
            enemyHero.Dispose();
            CombatEventManager.Instance.RemoveEventListener(CombatEventType.UseSkill, CombatUseSkillEventData);
        }

        public Vector3 GetFollowPos(CombatHeroEntity combatHeroEntity)
        {
            int index = combatHeroEntity.number - followTarget.number;
         return   followTarget.combatHeroGameObject.transform.TransformPoint((followMovePos[index]));
            // return followMovePos[index] + .dotPos;
        }

        public CombatHeroEntity[] GetHero(bool isEnemy)
        {
            if (isEnemy)
            {
                return enemyHero.ToArray();
            }
            else
            {
                return myHero.ToArray();
            }
        }

        public ILifetCycleHitPoint[] GetHeroHitPoint(bool isEnemy)
        {
            if (isEnemy)
            {
                return enemyHeroHitPoint.ToArray();
            }
            else
            {
                return myHeroHitPoint.ToArray();
            }
        }
    }
}