using System;
using System.Collections;
using UnityEngine;

public class AntManScaleController : MonoBehaviour
{
    private enum ScaleMode
    {
        Absolute,
        RelativeToInitial
    }

    [Header("Input")]
    [SerializeField] private bool readToggleInput = true;
    [SerializeField] private KeyCode toggleKey = KeyCode.Space;

    [Header("Objetivo de Escala")]
    [SerializeField] private Transform scaleTarget;
    [SerializeField] private bool keepPivotWorldPosition = true;
    [SerializeField] private Transform pivotReference;

    [Header("Escalas")]
    [SerializeField] private ScaleMode scaleMode = ScaleMode.RelativeToInitial;
    [SerializeField] private Vector3 smallScale = Vector3.one;
    [SerializeField] private Vector3 largeScale = new Vector3(20f, 20f, 20f);
    [SerializeField] [Min(0.001f)] private float smallScaleMultiplier = 0.2f;
    [SerializeField] [Min(0.001f)] private float largeScaleMultiplier = 1f;
    [SerializeField] private bool startLarge;

    [Header("Transicion")]
    [SerializeField] [Min(0.01f)] private float transitionDuration = 0.45f;
    [SerializeField] private AnimationCurve transitionCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);

    [Header("Debug")]
    [SerializeField] private bool showStateLogs;

    public event Action<Vector3, Vector3> TransitionStarted;
    public event Action<Vector3> TransitionCompleted;

    public bool IsTransitioning => _transitionRoutine != null;
    public bool IsLarge => _isLarge;
    public Transform ScaleTarget => scaleTarget;

    private bool _isLarge;
    private bool _hasQueuedToggle;
    private Coroutine _transitionRoutine;
    private Vector3 _initialScale;

    private void Awake()
    {
        if (scaleTarget == null)
        {
            scaleTarget = transform;
        }

        if (pivotReference == null)
        {
            pivotReference = scaleTarget;
        }

        _initialScale = scaleTarget.localScale;

        _isLarge = startLarge;
        ApplyScale(_isLarge ? GetLargeScale() : GetSmallScale());
    }

    private void Update()
    {
        if (!readToggleInput)
        {
            return;
        }

        if (Input.GetKeyDown(toggleKey))
        {
            RequestToggle();
        }
    }

    public void SetReadToggleInputState(bool state)
    {
        readToggleInput = state;
    }

    public Vector3 GetCurrentScale()
    {
        if (scaleTarget == null)
        {
            return transform.localScale;
        }

        return scaleTarget.localScale;
    }

    public void RequestToggle()
    {
        if (IsTransitioning)
        {
            _hasQueuedToggle = !_hasQueuedToggle;
            if (showStateLogs)
            {
                Debug.Log($"[AntManScaleController] Toggle en cola: {_hasQueuedToggle}", this);
            }
            return;
        }

        StartScaleTransition();
    }

    private void StartScaleTransition()
    {
        Vector3 from = scaleTarget.localScale;
        _isLarge = !_isLarge;
        Vector3 to = _isLarge ? GetLargeScale() : GetSmallScale();

        _transitionRoutine = StartCoroutine(TransitionRoutine(from, to));
    }

    private IEnumerator TransitionRoutine(Vector3 from, Vector3 to)
    {
        if (showStateLogs)
        {
            Debug.Log($"[AntManScaleController] Transicion {from} -> {to}", this);
        }

        TransitionStarted?.Invoke(from, to);

        float elapsed = 0f;
        while (elapsed < transitionDuration)
        {
            elapsed += Time.deltaTime;
            float t = Mathf.Clamp01(elapsed / transitionDuration);
            float eased = transitionCurve.Evaluate(t);
            ApplyScale(Vector3.LerpUnclamped(from, to, eased));
            yield return null;
        }

        ApplyScale(to);
        TransitionCompleted?.Invoke(to);

        if (showStateLogs)
        {
            Debug.Log($"[AntManScaleController] Escala final: {to}", this);
        }

        _transitionRoutine = null;

        if (_hasQueuedToggle)
        {
            _hasQueuedToggle = false;
            StartScaleTransition();
        }
    }

    private void ApplyScale(Vector3 newScale)
    {
        if (scaleTarget == null)
        {
            return;
        }

        if (!keepPivotWorldPosition || pivotReference == null)
        {
            scaleTarget.localScale = newScale;
            return;
        }

        Vector3 pivotPositionBefore = pivotReference.position;
        scaleTarget.localScale = newScale;
        Vector3 pivotPositionAfter = pivotReference.position;
        Vector3 delta = pivotPositionBefore - pivotPositionAfter;
        scaleTarget.position += delta;
    }

    private Vector3 GetSmallScale()
    {
        if (scaleMode == ScaleMode.RelativeToInitial)
        {
            return _initialScale * smallScaleMultiplier;
        }

        return smallScale;
    }

    private Vector3 GetLargeScale()
    {
        if (scaleMode == ScaleMode.RelativeToInitial)
        {
            return _initialScale * largeScaleMultiplier;
        }

        return largeScale;
    }
}