using System;
using UnityEngine;
public class WuChangGhostController : MonoBehaviour
{
    public GhostState state { get; private set; }
    private int _index;
    private WuChangGhostAuraController _airBase;
    // 简单制作，不开模式模块，全部模式参数丢在这里
    private Transform _target;
    private Vector3 _targetOffset;
    private float _impactTime;
    private float _returnSpeed;
    private TrailRenderer[] _trailRenderers;
    
    private void Awake()
    {
        _trailRenderers = transform.GetComponentsInChildren<TrailRenderer>(true);
    }

    private void OnEnable()
    {
        state = GhostState.Docked;
        for (var i = 0; i < _trailRenderers.Length; i++)
            _trailRenderers[i].Clear();
    }

    public void Init(WuChangGhostAuraController airBase, int index, float returnSpeed)
    {
        _airBase = airBase;
        _index = index;
        _returnSpeed = returnSpeed;
    }

    public void AttackTarget(Transform target, Vector3 offset, float impactTime)
    {
        _target = target;
        _targetOffset = offset;
        _impactTime = Time.unscaledTime + impactTime;
        state = GhostState.Attack;
    }
    
    private void LateUpdate()
    {
        switch (state)
        {
            case GhostState.Attack:
            {
                if (_target == null)
                    state = GhostState.ReturnBase;
                else
                {
                    var targetPos = _target.position + _targetOffset;
                    var nextTime = Time.unscaledTime + Time.unscaledDeltaTime;
                    if (nextTime > _impactTime)
                    {
                        state = GhostState.ReturnBase;
                        transform.position = targetPos;
                    }
                    else
                    {
                        var ratio = Time.unscaledDeltaTime / (_impactTime - Time.unscaledTime);
                        transform.position = Vector3.Lerp(transform.position, targetPos, ratio);
                    }
                }
            }
                break;
            case GhostState.ReturnBase:
            {
                var hangerPos = _airBase.GetHangerPosition(_index);
                var delta = Time.unscaledDeltaTime * _returnSpeed;
                if ((transform.position - hangerPos).sqrMagnitude < delta.ToSquare())
                {
                    state = GhostState.Docked;
                    transform.position = hangerPos;
                }
                else
                    transform.position = Vector3.MoveTowards(transform.position, hangerPos, delta);
            }
                break;
            case GhostState.Docked:
            {
                transform.position = _airBase.GetHangerPosition(_index);
            }
                break;
            default:
                throw new ArgumentOutOfRangeException();
        }
    }

    public enum GhostState
    {
        Docked,
        Attack,
        ReturnBase,
    }
}