using System;
using System.Reflection;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

// 角色状态机
[DisallowMultipleComponent]
public class PCState : UnitState
{
    public enum EUnitState
    {
        Nien,

        Idle,
        Move,
        Spawn,
        Die,
        Dead,
        // 
        Attack,
        AirAttack,
        AttackToAir,
        AirDash,
        // 		  
        HitAir,
        HitAirHit,
        Knockdown,
        //		  
        HitGuard,
        //		  
        Walk,
        // 		  
        Rise,
        // 		  
        Jump,
        // 转身   
        Turn,
        Landing,   // 从空中降落
    }

    [SerializeField] private EUnitState m_State;
    public EUnitState CurrentState { get { return m_State; } }

    public override void Initialize()
    {
        base.Initialize();
		owner.onTimelineEvent += OnTimeLineEvent;
	}

	public override void Release()
	{
		owner.onTimelineEvent -= OnTimeLineEvent;
		base.Release();
	}

	PCAnimation pcAnimation { get { return m_Owner.pcAnimation; } }

    #region state param
    public struct IdleParam { }

    public struct MoveParam
    {
        public bool isRight;
        public string key;
    }

    public struct SkillParam
    {
        public float offset; 
    }

    public struct AirDashParam
    {

    }

    public struct JumpParam
    { }

    public struct TurnParam
    {
        EUnitState nextState;
    }

    public struct LandingParam { }

    #endregion  
    public void ChangeState<T>(EUnitState nextState, T param = default, bool bForce = false)
    {
        if (!IsChange(nextState, bForce))
            return;

        LogHelper.Log("UnitState: " + m_State.ToString() + " -> " + nextState.ToString());

        StopAllCoroutines();

        EUnitState prevState = m_State;
        string methodFunc = "On" + m_State.ToString() + "Exit";
        MethodInfo exitMethod = GetType().GetMethod(methodFunc, BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[] { typeof(EUnitState) }, null);
        if (exitMethod != null)
        {
            exitMethod.Invoke(this, new object[] { nextState });
        }
        else
        {
            LogHelper.LogError("缺少 " + methodFunc);
        }
        m_State = nextState;

        StartCoroutine(m_State.ToString(), param);
    }

    bool IsChange(EUnitState newState, bool bForce)
    {
        if (newState != m_State || bForce)
            return true;
        return false;
    }

    IEnumerator Nein() { yield break; }
    void OnNienExit(EUnitState nextState) { }

    public void TurnAround(bool bRight)
    {
        m_Owner.transform.rotation = Quaternion.Euler(0, bRight ? 0 : 180, 0);
    }

    public void TurnLeft()
    {
        TurnAround(false);
    }

    public void TurnRight()
    {
        TurnAround(true);
    }

    #region Idle

    IEnumerator Idle(IdleParam param)
    {
        //if (m_Owner.isInAir) // 浮空切换到landing
        //{
        //    ChangeState(EUnitState.Landing, new LandingParam());
        //}
        //else // idle
        //{
            m_Owner.SetYPosition(0);
            m_Owner.pcAnimation.AnimIdle();
            while (true)
            {
				if (Input.GetKeyDown("j"))
				{
					ChangeState(EUnitState.Attack, new SkillParam());
				}
                if(Input.GetKeyDown("u"))
                {
                    ChangeState(EUnitState.AttackToAir, new SkillParam());
                }
                if (Input.GetKeyDown("space"))
                {
                    ChangeState(EUnitState.Jump, new JumpParam());
                }
                if (Input.GetKey("d"))
                {
                    MoveParam move = new MoveParam();
                    move.isRight = true;
                    move.key = "d";
                    ChangeState(EUnitState.Move, move);
                }
                if (Input.GetKey("a"))
                {
                    MoveParam move = new MoveParam();
                    move.isRight = false;
                    move.key = "a";
                    ChangeState(EUnitState.Move, move);
                }
                yield return null;
            }
        //}
    }

    void OnIdleExit(EUnitState nextState)
    {
    }
    #endregion

    #region Move 
    IEnumerator Move(MoveParam param)
    {
        if (m_Owner.isTowardRight && !param.isRight
        || !m_Owner.isTowardRight && param.isRight)
        {
            //m_Owner.pcAnimation.Play(UnitAnimation.EAnimState.Turn);
            //yield return new WaitForActionReachEnd(m_Owner.pcAnimation);
            //if (param.isRight)
            //	m_Owner.transform.rotation = Quaternion.Euler(0, 0, 0);
            //else
            //	m_Owner.transform.rotation = Quaternion.Euler(0, 180, 0);
            m_Owner.transform.rotation = Quaternion.Euler(0, param.isRight ? 0 : 180, 0);
        }
        //if (Input.GetKey(param.key))
        m_Owner.pcAnimation.AnimMove();
        while (Input.GetKey(param.key))
        {
            yield return null;
        }
        ChangeState(EUnitState.Idle, new IdleParam());
    }

    void OnMoveExit(EUnitState nextState)
    {
        m_Owner.pcAnimation.animator.ResetTrigger("ToMove");
    }

	#endregion

	#region Attack

	IEnumerator Attack(SkillParam param)
	{
		const int total = 4;
		int id = 0;
		m_Owner.pcAnimation.AnimAttack(id++);
		yield return null;
		while (true)
		{
			bool canCombo = m_Owner.pcAnimation.baseLayer.IsToggleOpen(EAnimationToogle.Combo);
            if (canCombo)
            {
                //if (InputManager.Instance.TryCommand(0.5f, KeyCode.W, KeyCode.J))
                if (Input.GetKeyDown("u"))
                {
                    SkillParam skill = new SkillParam();
                    skill.offset = 0.12f;
                    ChangeState(EUnitState.AttackToAir, skill);
                }
            }

            if (canCombo && id < total)
			{
				if (Input.GetKeyDown("j"))
				{
					if (Input.GetKey("a"))
					{
						TurnAround(false);
					}
					if (Input.GetKey("d"))
					{
						TurnAround(true);
					}
					m_Owner.pcAnimation.AnimAttack(id++);
                    yield return null;
					yield return new WaitForTransitionDone(m_Owner.pcAnimation);
				}
			}

			bool reachEnd = m_Owner.pcAnimation.baseLayer.playbackNormalizedTime == 1;
			if (reachEnd)
			{
				ChangeState(EUnitState.Idle, new IdleParam());
			}

			yield return null;
		}
	}

    void OnAttackExit(EUnitState next)
    {
    }

    #endregion

    #region AttackToAir

    IEnumerator AttackToAir(SkillParam param)
    {
        m_Owner.pcAnimation.AnimAttackToAir(param.offset);
        yield return null;
        while (true)
        {
            bool canCombo = m_Owner.pcAnimation.baseLayer.IsToggleOpen(EAnimationToogle.Combo);
            if(canCombo)
            {
                if(Input.GetKeyDown("j"))
                {
                    ChangeState(EUnitState.AirAttack, new SkillParam());
                }
            }

            bool reachEnd = m_Owner.pcAnimation.baseLayer.playbackNormalizedTime == 1;
            if (reachEnd)
            {
                ChangeState(EUnitState.Landing, new LandingParam());
            }
            yield return null;
        }
    }

    void OnAttackToAirExit()
    {
    }

    #endregion 

    #region AirAttack 

    IEnumerator AirAttack(SkillParam param)
    {
        int id = 0;
        m_Owner.pcAnimation.AnimAirAttack(id);
        yield return null; // 等待animator更新
        while (true)
        {
            bool canCombo = m_Owner.pcAnimation.baseLayer.IsToggleOpen(EAnimationToogle.Combo);
            if (canCombo)
            {
                if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
                {
                    TurnLeft();
                    ChangeState(EUnitState.AirDash, new AirDashParam());
                }
                if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
                {
                    TurnRight();
                    ChangeState(EUnitState.AirDash, new AirDashParam());
                }

                if (Input.GetKeyDown("j"))
                {
                    if (Input.GetKey("a"))
                    {
                        TurnAround(false);
                    }
                    if (Input.GetKey("d"))
                    {
                        TurnAround(true);
                    }
                    ++id;
                    m_Owner.pcAnimation.AnimAirAttack(id);
                    yield return null; // 等待animator更新
                    yield return new WaitForTransitionDone(m_Owner.pcAnimation);
                }
            }

            bool reachEnd = m_Owner.pcAnimation.baseLayer.playbackNormalizedTime == 1;
            if (reachEnd)
            {
                ChangeState(EUnitState.Landing, new LandingParam());
            }

            yield return null;
        }
    }

    void OnAirAttackExit(EUnitState next)
    {

    }

    #endregion

    #region AirDash  

    IEnumerator AirDash(AirDashParam param)
    {
        m_Owner.pcAnimation.AnimAirDash();
        yield return null;
        while (true)
        {
            bool reachEnd = m_Owner.pcAnimation.baseLayer.playbackNormalizedTime == 1;
            if (reachEnd)
            {
                ChangeState(EUnitState.Landing, new LandingParam());
            }

            bool canCombo = m_Owner.pcAnimation.baseLayer.IsToggleOpen(EAnimationToogle.Combo);
            if (canCombo)
            {
                if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
                {
                    TurnLeft();
                    m_Owner.pcAnimation.AnimAirDash();
                }
                if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
                {
                    TurnRight();
                    m_Owner.pcAnimation.AnimAirDash();
                }

                if (Input.GetKeyDown("j"))
                {
                    if (Input.GetKey("a"))
                    {
                        TurnAround(false);
                    }
                    if (Input.GetKey("d"))
                    {
                        TurnAround(true);
                    }
                    ChangeState(EUnitState.AirAttack, new SkillParam());
                }
            }

            yield return null;
        }
    }

    void OnAirDashExit(EUnitState next)
    {
    }

    #endregion

    #region Jump 

    IEnumerator Jump(JumpParam param)
    {
        pcAnimation.AnimJump();
        yield return null;
        yield return new WaitForTransitionDone(pcAnimation);
        while (true)
        {
            if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
            {
                TurnLeft();
                ChangeState(EUnitState.AirDash, new AirDashParam());
            }
            if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
            {
                TurnRight();
                ChangeState(EUnitState.AirDash, new AirDashParam());
            }
            if (pcAnimation.baseLayer.playbackNormalizedTime >= 1)
                ChangeState(EUnitState.Idle, new IdleParam());
            bool canAttack = m_Owner.pcAnimation.baseLayer.IsToggleOpen(EAnimationToogle.Combo);
            if (Input.GetKeyDown("j") && canAttack)
            {
                ChangeState(EUnitState.AirAttack, new SkillParam());
            }
            yield return null;
        }
    }

    void OnJumpExit(EUnitState next)
    {
    }

    #endregion

    #region Landing

    IEnumerator Landing(LandingParam param)
    {
        m_Owner.pcAnimation.AnimLanding();
        yield return null;
        yield return new WaitForTransitionDone(m_Owner.pcAnimation);
        float vy = 2;
        float g = 9.8f;
        bool landingGround = false;
        float vz = 5;
        while (true)
        {
            Vector3 pos = m_Owner.transform.position;
            vy += g * Time.deltaTime;
            pos.y -= vy * Time.deltaTime;
            pos.y = Mathf.Max(0, pos.y);
            if (Input.GetKey("a"))
            {
                TurnAround(false);
                pos.x -= vz * Time.deltaTime;
            }
            if (Input.GetKey("d"))
            {
                TurnAround(true);
                pos.x += vz * Time.deltaTime;
            }
            m_Owner.transform.position = pos;
            if (pos.y > 0 && pos.y <= 1 && !landingGround)
            {
                landingGround = true;
                m_Owner.pcAnimation.AnimLandingGround();
            }
            if (pos.y <= 0)
            {
                pos.y = 0;
                m_Owner.transform.position = pos;
                ChangeState(EUnitState.Idle, new IdleParam());
            }

            if (InputManager.Instance.TryCommand(0.5f, KeyCode.A, KeyCode.A))
            {
                TurnLeft();
                ChangeState(EUnitState.AirDash, new AirDashParam());
            }
            if (InputManager.Instance.TryCommand(0.5f, KeyCode.D, KeyCode.D))
            {
                TurnRight();
                ChangeState(EUnitState.AirDash, new AirDashParam());
            }

            yield return null;
        }
    }

    void OnLandingExit(EUnitState next)
    {
    }

	#endregion

	#region timeline event handle

	void OnTimeLineEvent(AnimationEventBase animEvent)
	{

	}

	#endregion 

}