using UnityEngine;

public class LevitationObject : MonoBehaviour
{
    [System.Serializable]
    public class References
    {
        public Rigidbody Rigidbody;
    }

    [System.Serializable]
    public class Settings
    {
        [Range(-1, 99)] public int Seed = -1;
        public Vector3 Offset = new Vector3(0, 3, 0);
        public Vector3 DivergeanceMin = new Vector3(-1, -2, -1);
        public Vector3 DivergeanceMax = new Vector3(1, 2, 1);
        public Vector3 Amplitude = new Vector3(.1f, .5f, .1f);
    }

    [System.Serializable]
    public class State
    {
        [Range(0, 1)] public float Levitating;
    }

    [SerializeField] private References _references;
    [SerializeField] private Settings _settings;
    [SerializeField] private State _state;

    private Vector3 _randomAxis;
    private Vector3 _originPos;
    private Quaternion _originRot;

    void OnDrawGizmosSelected()
    //void OnDrawGizmos()
    {
        Gizmos.color = Color.cyan;

        Vector3 originPos = Application.isPlaying ? _originPos : transform.position;
        Vector3 targetCenter = GetTargetCenter();

        Gizmos.DrawLine(transform.position, originPos + targetCenter);
        Gizmos.DrawWireSphere(originPos + targetCenter, .05f);
    }

    void OnValidate()
    {
        if (!_references.Rigidbody)
            _references.Rigidbody = GetComponent<Rigidbody>();

        if (_settings.Seed == -1)
            _settings.Seed = Random.Range(0, 100);
    }

    void Awake()
    {
        _randomAxis = new Vector3(Mathf.Cos(_settings.Seed * 3.41f), Mathf.Cos(_settings.Seed * 9.23f), Mathf.Sin(_settings.Seed * 5.22f)).normalized;
        _originPos = transform.position;
        _originRot = transform.rotation;
    }

    void Update()
    {
        if (!LevitationManager.Instance)
            return;

        _references.Rigidbody.isKinematic = true;
        _references.Rigidbody.useGravity = false;

        float t = Time.timeSinceLevelLoad * LevitationManager.Instance.Spped;
        t += _settings.Seed * 7.63f;

        float cosT0 = Mathf.Cos(t * .3f);
        float cosT1 = Mathf.Cos(t);
        float sinT0 = Mathf.Sin(t * .3f);

        Vector3 offset = GetTargetCenter();
        offset.x += _settings.Amplitude.x * cosT0;
        offset.y += _settings.Amplitude.y * cosT1;
        offset.z += _settings.Amplitude.z * sinT0;

        Vector3 targetPos = _originPos + offset;
        targetPos = Vector3.Slerp(_originPos, targetPos, LevitationManager.Instance.Levitation);
        targetPos = Vector3.Lerp(transform.position, targetPos, t / Mathf.Max(Vector3.Distance(transform.position, targetPos), 1) * .0002f);

        Quaternion targetRot = Quaternion.AngleAxis(t * 10, _randomAxis);
        targetRot = Quaternion.Lerp(_originRot, targetRot, LevitationManager.Instance.Levitation);

        _references.Rigidbody.Move(targetPos, targetRot);
    }

    Vector3 GetTargetCenter()
    {
        Vector3 divergeance = Vector3.Lerp(_settings.DivergeanceMin, _settings.DivergeanceMax, (_settings.Seed * 6.72f) % 1);

        return _settings.Offset + divergeance;
    }
}