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

public class AnimatorLayerInfo
{
    public UnitAnimation.ELayer layer;

    public int layerIndex { get { return (int)layer; } }

    private Animator m_Animator;

    public AnimationData animationData;
    private AnimationData m_AnimationData;

    // 当前在播放的动作
    // 如果处于transition中，动作不变，切换完成后才会到下一个动作
    public AnimatorStateInfo stateInfo
    {
        get
        {
            return m_Animator.GetCurrentAnimatorStateInfo(layerIndex);
        }
    }

    // 当前正在播放和融合的片段信息
    public AnimatorClipInfo[] clipInfo
    {
        get
        {
            return m_Animator.GetCurrentAnimatorClipInfo(layerIndex);
        }
    }

    public int stateHash
    {
        get
        {
            return stateInfo.shortNameHash;
        }
    }

    public float playbackTimeInSeconds
    {
        get
        {
            return stateInfo.normalizedTime * stateInfo.length;
        }
    }

    public float playbackNomralizedTime
    {
        get
        {
            return stateInfo.normalizedTime;
        }
    }

    public int pendingStateHash;

    public AnimatorLayerInfo(Animator animator, UnitAnimation.ELayer layer)
    {
        this.m_Animator = animator;
        this.layer = layer;
    }

}

// 控制动画播放、执行动作timeline(包括执行事件和碰撞盒)
// 每个layer同时只会有一个动画在播放，在执行transition时，current animation依然是
// 这个动作，只有完全过渡完成后才会切到下一个动作
// 当前是什么动作以ainmator的GetCurrentAnimatorStateInfo为准
[DisallowMultipleComponent]
public class UnitAnimation : UnitComponent
{
    public enum ELayer
    {
        Basic = 0,
        Attack,

        Count,
    }

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

    // 切换动画
    public enum ETrigger
    {
        ToIdle,
        ToMove,
        ToAttack,
    }

	public Animator animator { get { return m_Animator; } }
	private Animator m_Animator;

    private UnitTimeline m_Timeline;

	private UnitActionData m_ActionData;

    public AnimatorLayerInfo[] layers { get { return m_LayerInfo; } }
    private AnimatorLayerInfo[] m_LayerInfo = new AnimatorLayerInfo[(int)ELayer.Count];

    public bool isInTransition
    {
        get
        {
            return m_Animator.IsInTransition(0);
        }
    }
	//public EAnimState curState { get { return m_CurState; } }
	//private EAnimState m_CurState;

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

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

        m_Animator.speed = 0;

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

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

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

        UpdateAnimation();
        UpdateRootMotion();
    }

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

    void UpdateRootMotion()
    {
        m_Owner.unitRootMotion.UpdateRootMotion();
    }

    public void AnimIdle()
    {
        m_Animator.SetTrigger(ETrigger.ToIdle.ToString());
    }

    public void AnimMove()
    {
        m_Animator.SetTrigger(ETrigger.ToMove.ToString());
    }

    public void AnimAttack()
    {
        m_Animator.SetTrigger(ETrigger.ToAttack.ToString());
    }

}