using System;
using System.Collections;
using System.Collections.Generic;
using Common.Utility.CombatEvent;
using Core.State;
using Fort23.Core;
using GameLogic.Combat.CombatTool;
using GameLogic.Combat.Hero;
using GameLogic.Combat.Hero.State;
using GameLogic.Combat.Hero.SubStatus;
using OfficeOpenXml.FormulaParsing.Excel.Functions.Logical;
using UnityEngine;
using UnityEngine.AI;

public class CombatAIBasic : IDisposable
{
    public StateControl stateControl;
   

    private BetterList<SubStatusBasic> _subStatusList = new BetterList<SubStatusBasic>();

    // public NavMeshObstacle NavMeshObstacle;
    protected CombatHeroEntity _combatHeroEntity;
    protected float _r = 5;
    public bool isAlert;

    public CombatHeroStateBasic CurrState
    {
        get { return stateControl.CurrIState as CombatHeroStateBasic; }
    }

    /// <summary>
    /// 当前聚焦的目标
    /// </summary>
    public IHero currFocusTarget
    {
        get { return _currFocusTarget; }
        set
        {
            CombatHeroTargetAlterEventData combatHeroTargetAlterEventData = CombatHeroTargetAlterEventData.Create();
            combatHeroTargetAlterEventData.combatHeroEntity = _combatHeroEntity;
            combatHeroTargetAlterEventData.targetCombatHeroEntity = value;
            combatHeroTargetAlterEventData.lasetCombatHeroEntity = _currFocusTarget;
            CombatEventManager.Instance.Dispatch(CombatEventType.TargetAlter, combatHeroTargetAlterEventData);
            _currFocusTarget = value;
        }
    }

    private IHero _currFocusTarget;

    private BetterList<GameObject> _areaList = new BetterList<GameObject>();
    private BetterList<GameObject> _HindAreaList = new BetterList<GameObject>();
    private float _t;

    public void Init(CombatHeroEntity combatHeroEntity)
    {
        CombatEventManager.Instance.AddEventListener(CombatEventType.AlertTrigger, AlertTrigger);
        _combatHeroEntity = combatHeroEntity;
        stateControl = new StateControl();
     

        ProInitState();
        ProInit();
    }

    public GameObject[] AreaList
    {
        get { return _areaList.ToArray(); }
    }

    protected virtual void ProInit()
    {
    }

    public void AddSubStatus(SubStatusBasic subStatusBasic)
    {
        if (!_subStatusList.Contains(subStatusBasic))
        {
            subStatusBasic.Init(_combatHeroEntity);
            _subStatusList.Add(subStatusBasic);
        }
    }

    public T GetSubStatus<T>() where T : SubStatusBasic
    {
        for (int i = 0; i < _subStatusList.Count; i++)
        {
            if (_subStatusList[i] is (T))
            {
                return _subStatusList[i] as T;
            }
        }

        return null;
    }

    public void RemoveSubStatus(SubStatusBasic subStatusBasic)
    {
        if (_subStatusList.Contains(subStatusBasic))
        {
            _subStatusList.Remove(subStatusBasic);
        }
    }

    protected void AlertTrigger(IEventData iEventData)
    {
        AlertTriggerEventData alertTriggerEventData = iEventData as AlertTriggerEventData;
        if (alertTriggerEventData.combatHeroEntity == _combatHeroEntity)
        {
            if (alertTriggerEventData.isTrigger && !_areaList.Contains(alertTriggerEventData.triggerObject))
            {
                _areaList.Add(alertTriggerEventData.triggerObject);
            }
            else if (!alertTriggerEventData.isTrigger)
            {
                _areaList.Remove(alertTriggerEventData.triggerObject);
                _HindAreaList.Remove(alertTriggerEventData.triggerObject);
            }
        }
    }

    protected virtual void ProInitState()
    {
        stateControl.AddState(CombatHeroStateType.idle, new CombatHeroIdleState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.move, new CombatHeroMoveState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.att, new CombatHeroAttState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.dile, new CombatHeroDieState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.rolling, new CombatHeroRollingState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.followMove, new CombatHeroFollowMoveState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.followIdle, new CombatHeroFollowIdleState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.NullState, new CombatHeroNullState(_combatHeroEntity));

        stateControl.AddState(CombatHeroStateType.Active, new CombatHeroActiveState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.XiuMian, new CombatHeroXiuMianState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.Resurrection, new CombatResurrectionState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.PickUp, new CombatHeroPickUpState(_combatHeroEntity));
        stateControl.AddState(CombatHeroStateType.Disappear, new CombatHeroDisappearState(_combatHeroEntity));
        
    }

    public void ChangeState(string name, IStateEnterData iStateEnterData = null, bool isQiangZhi = false)
    {
        stateControl.ChangeState(name, iStateEnterData, isQiangZhi);
    }

    public virtual void Update(float t)
    {
        if (CombatController.currActiveCombat.isStopAi)
        {
            if (stateControl.CurrStateName.Equals(CombatHeroStateType.move))
            {
                stateControl.ChangeState(CombatHeroStateType.idle);
            }

            return;
        }

        for (int i = 0; i < _areaList.Count; i++)
        {
            if (!_areaList[i].activeSelf)
            {
                _HindAreaList.Remove(_areaList[i]);
                _areaList.RemoveAt(i);

                i--;
            }
        }

        for (int i = 0; i < _subStatusList.Count; i++)
        {
            SubStatusBasic subStatusBasic = _subStatusList[i];
            string s = subStatusBasic.IsGetStateName();
            if (!string.IsNullOrEmpty(s))
            {
                stateControl.ChangeState(s);
            }

            _subStatusList[i].Update(t);
        }

        if (currFocusTarget == null || currFocusTarget.isDie ||
            (currFocusTarget is BannerHero && !_combatHeroEntity.IsEnemy) ||
            !_combatHeroEntity.IsAttDis(currFocusTarget.dotPos))
        {
            CombatHeroEntity[] allHero =
                CombatController.currActiveCombat.CombatHeroController.GetHero(!_combatHeroEntity.IsEnemy);
            IHero minDistanceHero = FindMinDixtance(allHero);
            currFocusTarget = minDistanceHero;
            if (!_combatHeroEntity.IsEnemy && currFocusTarget == null)
            {
                currFocusTarget = CombatController.currActiveCombat.CombatTypeBasic.currBannerHero;
            }
        }


        stateControl.Update(t);
        if (currFocusTarget != null && CurrState != null && CurrState.IsUpdateLockTarget() &&
            !_combatHeroEntity.isDie && !isAlert)
        {
            Vector3 nextPos = 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.5f);
            }
        }

        AreaUpdate();
        ProUpdate();
    }

    private void AreaUpdate()
    {
        GameObject[] b = AreaList;
        if (b == null)
        {
            return;
        }

        BetterList<GameObject> currArea = new BetterList<GameObject>();
        for (int i = 0; i < b.Length; i++)
        {
            if (!_HindAreaList.Contains(AreaList[i]))
            {
                currArea.Add(AreaList[i]);
                _HindAreaList.Add(AreaList[i]);
            }
        }

        if (currArea != null && currArea.Count > 0)
        {
            float dodge = _combatHeroEntity.CurrCombatHeroInfo.dodge;
            int odds = CombatCalculateTool.Instance.GetOdd();
            if (odds < dodge)
            {
                CombatHeroRollingState.RollingStateData rollingStateData =
                    CObjectPool.Instance.Fetch<CombatHeroRollingState.RollingStateData>();
                Vector3 pos = Vector3.zero;
                for (int i = 0; i < b.Length; i++)
                {
                    pos += b[i].transform.position;
                }

                pos /= b.Length;
                Vector3 dir = pos - _combatHeroEntity.combatHeroGameObject.position;
                rollingStateData.dir = new Vector3(dir.x, _combatHeroEntity.dotPos.y, dir.z).normalized;
                _combatHeroEntity.CombatAIBasic.ChangeState(CombatHeroStateType.rolling, rollingStateData);
            }
        }
    }

    protected virtual void ProUpdate()
    {
    }

    protected IHero FindMinDixtance(CombatHeroEntity[] allHero)
    {
        IHero minDistanceHero = null;
        if (allHero == null)
        {
            return null;
        }

        float minDistance = float.MaxValue;
        for (int i = 0; i < allHero.Length; i++)
        {
            CombatHeroEntity hero = allHero[i];
            if (hero.GetMainHotPoin<CombatHeroHitPoint>() == null)
            {
                continue;
            }

            float distance = Vector3.SqrMagnitude(hero.combatHeroGameObject.position -
                                                  _combatHeroEntity.combatHeroGameObject.position);
            if (distance < minDistance)
            {
                // if (!_combatHeroEntity.IsEnemy || distance < _combatHeroEntity.CurrCombatHeroInfo.maxDisTo + 100)
                {
                    minDistance = distance;
                    minDistanceHero = hero;
                }
            }
        }

        return minDistanceHero;
    }

    public void Dispose()
    {
        ProDispose();
        _combatHeroEntity = null;
        stateControl.Dispose();
        stateControl = null;
    }

    protected virtual void ProDispose()
    {
        CombatEventManager.Instance.RemoveEventListener(CombatEventType.AlertTrigger, AlertTrigger);
    }
}