#define ANIM_CROSS_FADE
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class PCAnimation : UnitAnimation
{

#if !ANIM_CROSS_FADE
    // 切换动画
    public enum ETrigger
    {
        ToIdle,
        ToMove,
        ToJump,
        ToAttack,
        ToAirAttack,
        ToLanding,
    }
#endif

	public enum ELayer
    {
        Basic = 0,
        Attack,
        SwordAttack,
        GunAttack,
        UpperBody,
        LowerBody,
        Count,
    }


    // 动作名，和animator里的state对应
    public enum EAnimState
    {
        // layer 0 
        Idle = 0,
        Move,
        Jump,
        Hit,
        Attack,
        Rise,
        Stinger,
        Turn,
        Landing,

        Attack0,
        Attack1,
        Attack2,
        Attack3,

        AttackToAir,

        AirAttack0,
        AirAttack1,
        AirAttack2,
        AirAttack3,
		AirAttack4,

		AirDash,

		LandingGround,
	}

    public override AnimatorLayerInfo baseLayer
    {
        get { return layers[(int)ELayer.Basic]; }
    }

    private UnitActionData m_ActionData;

    public bool applyRootMotion { get; set; }
    public bool applyRootCurve { get; set; } // 程序生成的root motion

	public bool updateAnimationAuto { get; private set; } // 自动更新动画

	private AnimatorOverrideController controller
	{
		get
		{
			Debug.Assert(owner.unitAnimation.animator.runtimeAnimatorController is AnimatorOverrideController);
			return owner.unitAnimation.animator.runtimeAnimatorController as AnimatorOverrideController;
		}
	}

    public override void Initialize()
    {
        base.Initialize();

        m_Animator = this.m_Owner.unitObj.GetComponent<Animator>();

        m_Animator.speed = 0;

        m_LayerInfo = new AnimatorLayerInfo[2];
        m_LayerInfo[0] = new AnimatorLayerInfo(this, m_Animator, (int)ELayer.Basic);
        //m_LayerInfo[1] = new AnimatorLayerInfo(this, m_Animator, ELayer.Attack);

        if (m_Animator == null)
        {
            LogHelper.LogError("没有挂Animator组件");
        }

        applyRootMotion = true;

		updateAnimationAuto = true;
	}

    public override void OnUpdate()
    {
        base.OnUpdate();

        UpdateLayer();
        UpdateAnimation();
        UpdateRootMotion();
        UpdateRootCurve();
    }

    void UpdateLayer()
    {
        m_LayerInfo[0].OnUpdate();
        return;
        for (int i = 0; i < m_LayerInfo.Length; ++i)
        {
            m_LayerInfo[i].OnUpdate();
        }
    }

    void UpdateAnimation()
    {
		if(updateAnimationAuto)
		{
			m_Animator.speed = 1;
			m_Animator.Update(Time.deltaTime);
			m_Animator.speed = 0;
		}
	}

    void UpdateRootMotion()
    {
		if (!applyRootMotion)
			return;

        m_Owner.unitRootMotion.UpdateRootMotion();
    }

    void UpdateRootCurve()
    {
		if (!applyRootCurve)
			return;
    }

	AnimationData GetAnimationDataOfState(string name)
	{
		string animName = controller[name].name;
		string path = owner.folder + "AnimationData/" + animName + ".asset";
		AnimationData data = ResourceManager.Instance.LoadAsset<AnimationData>(path);
		return data;
	}

	////////////////////////////////////////////////////////////////////////////////////////////////////////

	public void AnimIdle()
    {
        CrossFade(EAnimState.Idle, 0.2f, 0);
    }

    public void AnimMove()
    {
        CrossFade(EAnimState.Move, 0.01f, 0);
    }

    public void AnimJump()
    {
        CrossFade(EAnimState.Jump, 0.01f);
    }

    public void AnimAirAttack(int id)
    {
        m_Owner.unitCollider.OnAnimationChange();
		EAnimState state = EAnimState.AirAttack0;
		if (id == 1) state = EAnimState.AirAttack1;
		else if (id == 2) state = EAnimState.AirAttack2;
		else if (id == 3) state = EAnimState.AirAttack3;
		else if (id == 4) state = EAnimState.AirAttack4;

		AnimationData data = GetAnimationDataOfState(state.ToString());
		Debug.Assert(data != null);
		float offset = data.GetProperty(EAnimationProperty.ComboTimeOffset, 0);
		float duration = data.GetProperty(EAnimationProperty.TransitionInDuration, 0.1f);
		CrossFade(state, duration, offset);
	}

    public void AnimAttackToAir(float offset)
    {
        m_Owner.unitCollider.OnAnimationChange();
        Play(EAnimState.AttackToAir, offset);
    }

    public void AnimAttack(int id)
	{
        m_Owner.unitCollider.OnAnimationChange();
		switch (id)
		{
			case 0:
				CrossFade(EAnimState.Attack0, 0.02f);
				break;
			case 1:
				CrossFade(EAnimState.Attack1, 0.02f);
				break;
			case 2:
				CrossFade(EAnimState.Attack2, 0.02f);
				break;
			case 3:
				CrossFade(EAnimState.Attack3, 0.02f);
				break;
		}
	}

	public void AnimAirDash()
    {
        if (layers[0].stateInfo.IsName("AirDash"))
        {
            this.Play(EAnimState.AirDash, 0, 0);
        }
        else
        {
            CrossFade(EAnimState.AirDash, 0.05f);
        }
    }

    public void AnimLanding()
    {
        CrossFade(EAnimState.Landing, 0.05f);
    }

    public void AnimLandingGround()
    {
        CrossFade(EAnimState.LandingGround, 0.00f);
    }

    private void Play(EAnimState animState, float normalizedTime = float.NegativeInfinity, int layerIndex = 0)
    {
        base.Play(animState.ToString(), layerIndex, normalizedTime);
	}

	private void CrossFade(EAnimState animState, float normalizedTransitionDuration, float normalizedTimeOffset = float.NegativeInfinity, float normalizedTransitionTime = 0.0f, int layerIndex = 0)
	{
        base.CrossFade(animState.ToString(), normalizedTransitionDuration, layerIndex, normalizedTimeOffset, normalizedTransitionTime);
	}

}