using System.Collections;
using System.Collections.Generic;
using UnityEngine;
#if UNITY_EDITOR
using UnityEditor;
#endif

// 单独一层动画
public class AnimatorLayerInfo
{
    public UnitAnimation.ELayer layer;

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

    public string name { get { return m_Animator.GetLayerName(layerIndex); } }

    private Animator m_Animator;

    // 当前动作的animation data，如果是blendtree选第一个动作
    private AnimationData m_AnimationData;
    public AnimationData animationData
    {
        get
        {
            if (clipInfo == null || clipInfo.Length == 0)
                return null;
            var clip = clipInfo[0]; //选第一个
            string folder = m_UnitAnimation.owner.folder;
            string name = clip.clip.name;
            if (m_AnimationData != null && m_AnimationData.animationName == name)
                return m_AnimationData;
            string path = folder + "AnimationData/" + name + ".asset" ; // 要注意这里使用名字区别的，因为最终每个角色的动画都会在一个目录下面
#if UNITY_EDITOR
            m_AnimationData  = AssetDatabase.LoadAssetAtPath<AnimationData>(path);
#endif
            return m_AnimationData;
        }
    }

	// 当前动作所有animation data，包括blendtree使用的所有动画
	//private List<AnimationData> m_AnimationDatas;
	//public List<AnimationData> animationDatas
	//{
	//    get
	//    {
	//        return null;
	//    }
	//}

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

    private int preStateHash = -1;

    // 当前正在播放和融合的片段信息
    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;// stateInfo.length会等于infinity，因为设置了animator.speed = 0 
    //    }
    //}
    
    // 并非准确的播放时间，只是逻辑时间，因为动画会加速减速
    public float playbackTimeInSeconds
    {
        get
        {
            return stateInfo.normalizedTime * clipInfo[0].clip.length; 
        }
    }

    // 这个是真实世界的时间
    private float m_PlaybackRealTime;
    public float playbackRealTimeInSeconds
    {
        get
        {
            return m_PlaybackRealTime;
        }
    }

    // 播放进度百分比
    public float playbackNomralizedTime
    {
        get
        {
            return stateInfo.normalizedTime;
        }
    }

	public float playbackSpeed
	{
		get
		{
			return m_Animator.GetFloat("PlaybackSpeed" + layerIndex);
		}
		set
		{
			float v = Mathf.Clamp(value, 0, 10);
			m_Animator.SetFloat("PlaybackSpeed" + layerIndex, v);
		}
	}

	public float weight
    {
        get
        {
            return m_Animator.GetLayerWeight(layerIndex);
        }
    }

    public int nextStateHash
    {
        get
        {
            //if (!isInTransition)
            //    return 0;
            AnimatorStateInfo nextState = m_Animator.GetNextAnimatorStateInfo(layerIndex);
            int hash = nextState.shortNameHash; // 如果不在过渡中，hash是0
            return hash;
        }
    }

    public bool isInTransition
    {
        get
        {
            return m_Animator.IsInTransition(layerIndex);
        }
    }

	public bool applySpeedCurve { get; set; }

	UnitAnimation m_UnitAnimation;

    Coroutine m_CalcPlaybackTimeCoroutine;

	TimelineEventProxy m_TimelineEventProxy;

	public AnimatorLayerInfo(UnitAnimation unitAnimation, Animator animator, UnitAnimation.ELayer layer)
    {
        this.m_UnitAnimation = unitAnimation;
        this.m_Animator = animator;
        this.layer = layer;
		m_CalcPlaybackTimeCoroutine = unitAnimation.StartCoroutine(CalcPlaybackRealTimeCoroutine());
		m_TimelineEventProxy = new TimelineEventProxy(unitAnimation.owner.transform, unitAnimation.owner);
		applySpeedCurve = true;
	}

	IEnumerator CalcPlaybackRealTimeCoroutine()
    {
        while (true)
        {
            if(preStateHash != stateHash)
            {
                m_PlaybackRealTime = 0;
            }
            m_PlaybackRealTime += Time.deltaTime;
            preStateHash = stateHash;
            yield return null; 
        }
    }

	public void OnUpdate()
	{
		// 执行事件
		m_TimelineEventProxy.ExecuteAnimationEvents(animationData, playbackTimeInSeconds * TimelineEventProxy.FPS);

		// 播放速度控制
		if(applySpeedCurve && animationData.speedCurve != null)
		{
			playbackSpeed = animationData.speedCurve.Evaluate(playbackNomralizedTime);
		}

	}

}

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

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

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

	private UnitActionData m_ActionData;

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

	public bool isInTransition
    {
        get
        {
            return m_Animator.IsInTransition(0);
        }
    }

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

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

        m_Animator.speed = 0;

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

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

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

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

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

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

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

    public void AnimIdle()
    {
		if(layers[0].stateInfo.shortNameHash != Animator.StringToHash("Idle"))
		{
			m_Animator.SetTrigger(ETrigger.ToIdle.ToString());
		}
	}

    public void AnimMove()
    {
		if (layers[0].stateInfo.shortNameHash != Animator.StringToHash("Move"))
		{
			m_Animator.SetTrigger(ETrigger.ToMove.ToString());
		}
	}

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

    void SetTrigger(ETrigger trigger)
    {
        m_Animator.SetTrigger(trigger.ToString());
    }

	public void AnimJump()
	{
		SetTrigger(ETrigger.ToJump);
	}

	public void AnimAirAttack()
	{
		SetTrigger(ETrigger.ToAirAttack);
	}

}