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

public struct AttackStateConfig
{
	public Vector3 velocity; // velocity setup
	public int motion;
	public Animator animator;
	public PhysicsBody body;
    public float crossFade; 
}

// 单独的一个招式
public class AttackState : StateBase
{
    AttackStateConfig m_Config = new AttackStateConfig();

    private List<Trigger> m_Triggers = new List<Trigger>();

    private List<Trigger> m_PhysicsTriggers = new List<Trigger>();

	/// <summary>
	/// 这个招式配置的hit
	/// </summary>
	private List<Hit> m_Hits = new List<Hit>();
   
    /// <summary>
    /// 从动画结束开始计时
    /// </summary>
    float m_TimeCount;
    public float ExpireTime
    {
        get
        {
            return m_TimeCount;
        }
    }

    /// <summary>
    /// 这个招式的hit个数
    /// </summary>
    public int HitCount
    {
        get
        {
            return m_Hits != null ? m_Hits.Count : 0;
        }
    }


	public AttackState(Animator animator, int animation, PhysicsBody body = null, float crossFade = 0f)
	{
		m_Config.animator = animator;
		m_Config.motion = animation;
		m_Config.velocity = Vector3.zero;
		m_Config.body = body;
        m_Config.crossFade = crossFade;
	}

	public AttackState(AttackStateConfig config)
	{
		m_Config = config;
	}

	public override void OnInit()
	{
	}

	public override void OnDefend()
	{
		throw new System.NotImplementedException();
	}

	public override void OnEnter()
	{
		m_TimeCount = 0;

		m_Config.animator.CrossFade(m_Config.motion, m_Config.crossFade);

		if(m_Config.body != null)
		{
			m_Config.body.LocalVelocity = m_Config.velocity;
		}

        foreach(var hit in m_Hits)
        {
            hit.WipeRecords();
        }

        foreach(var trigger in m_Triggers)
        {
            trigger.Reset();
        }
	}

	public override void OnExit()
	{
		m_TimeCount = 0;
	}

	public override void OnHit(HitInfo info)
	{
	}

	public override void OnHurt(HurtInfo info)
	{
	}

	public override void OnTranslate(StateBase to)
	{
	}

	public override void OnUpdate()
	{
		AnimatorStateInfo info =  m_Config.animator.GetCurrentAnimatorStateInfo(0);
		if(info.shortNameHash == m_Config.motion && info.normalizedTime >= 0.99f)
		{
			m_TimeCount += Time.deltaTime;
		}
		foreach (var stateTrigger in m_Triggers)
		{
			if (stateTrigger.Update() && stateTrigger.Swallow)
				break;
		}
	}

	// 在物理模拟之后
	public override void OnPhysicsUpdate()
	{
		foreach (var trigger in m_PhysicsTriggers)
		{
			if (trigger.Update() && trigger.Swallow)
				break;
		}
	}

	public void AddTrigger(Trigger trigger)
	{
		if (trigger == null || m_Triggers.Contains(trigger))
			return;
		m_Triggers.Add(trigger);
	}

	public void AddPhysicsTrigger(Trigger trigger)
	{
		if (trigger == null || m_PhysicsTriggers.Contains(trigger))
			return;
		m_PhysicsTriggers.Add(trigger);
	}

    public void AddHitDefination(HitDefination defination)
    {
        Hit info = new Hit();
        info.defination = defination;
        m_Hits.Add(info);
    }

    // 获得当前时间点产生的hit
    public Hit GetHit()
    {
        AnimatorStateInfo info = m_Config.animator.GetCurrentAnimatorStateInfo(0);
        float normalizeTime = info.normalizedTime;
        for (int i = 0; i< m_Hits.Count; ++i)
        {
            Hit hit = m_Hits[i];
            float start = hit.defination.start;
            float end = hit.defination.end;
            if(normalizeTime >= start && normalizeTime <= end)
            {
                return hit;
            }
        }
        return null;
    }

}