using UnityEngine;
using TMPro;
using System.Collections;
using System.Collections.Generic;
using Unheimlich.Features.Hallucination;
using Unheimlich.Features.Shared;

namespace Unheimlich.Features.Dialogue.UI
{
    /// <summary>
    /// Non-interactive floating word/phrase for world-space storytelling.
    ///
    /// Changes from previous version:
    ///   - Registers/unregisters itself with HallucinationLabelRegistry on enable/disable
    ///     so the HallucinationManager can drive baseline behaviour without FindObjectsOfType.
    ///   - Exposes SetShakeParams() and SetGhostTrail() for runtime overrides.
    ///   - ApplyBaseline() / ApplyOverride() drive the two-layer system.
    ///   - One-shot trigger distance is now explicit and independent from the visual near-fade.
    ///   - One-shot fade-out runs independently from the distance-based alpha so it is never overwritten.
    /// </summary>
    public class FloatingLabel : MonoBehaviour
    {
        // ─── Inspector ─────────────────────────────────────────────────────────

        [Header("Text")]
        [Tooltip("Leave empty to keep text set directly on the TextMeshPro component.")]
        [SerializeField] [TextArea] private string _overrideText;
        [SerializeField] private TextMeshPro _textComponent;

        [Header("Visibility")]
        [SerializeField] private float _maxVisibleDistance = 10f;
        [SerializeField] private float _fadeRange = 1.5f;

        [Header("Min Distance")]
        [SerializeField] private float _minDistance = 0.5f;
        [SerializeField] private float _nearFadeRange = 0.8f;

        [Header("Adaptive Scale")]
        [SerializeField] private bool _enableAdaptiveScale = true;
        [SerializeField] private float _referenceDistance = 3f;
        [SerializeField] private float _minScaleFactor = 0.2f;
        [SerializeField] private float _maxScaleFactor = 3f;

        [Header("Organic Shake — Baseline")]
        [Tooltip("Prefab defaults. HallucinationManager lerps these at runtime based on sanity.")]
        [SerializeField] private bool  _enableOrganicShake  = false;
        [SerializeField] private float _shakeRadius         = 0.05f;
        [SerializeField] private float _shakeSpeed          = 1.5f;
        [SerializeField] private float _shakeSmoothness     = 2f;

        [Header("Ghost Trail — Baseline")]
        [Tooltip("Prefab defaults. HallucinationManager lerps these at runtime based on sanity.")]
        [SerializeField] private bool  _enableGhostTrail  = false;
        [SerializeField] [Range(0f, 1f)] private float _ghostAlpha = 0.3f;
        [SerializeField] private float _ghostDelay        = 0.15f;
        [SerializeField] private float _ghostDepthOffset  = 0.02f;

        [Header("Camera Attraction (Optional)")]
        [SerializeField] private bool  _enableCameraAttraction = false;
        [SerializeField] [Range(1f, 45f)] private float _attractionAngle = 10f;
        [SerializeField] private float _attractionMaxOffset  = 0.3f;
        [SerializeField] private float _attractionSmoothness = 4f;

        [Header("One-Shot (Optional)")]
        [Tooltip("Enable one-shot behaviour: the label permanently disappears after the player gets close enough.")]
        [SerializeField] private bool  _enableOneShot          = false;
        [Tooltip("If true, the one-shot resets when the player walks far away (outside far-fade zone) without having triggered it.")]
        [SerializeField] private bool  _isRetriggerableFar     = false;
        [Tooltip("Distance at which the one-shot triggers, completely independent from the visual near-fade.")]
        [SerializeField] private float _oneShotTriggerDistance = 0.5f;
        [Tooltip("Duration of the fade-out once the one-shot is triggered.")]
        [SerializeField] private float _fadeOutDuration        = 0.5f;

        [Header("Reappear Fade")]
        [SerializeField] private float _fadeInDuration = 0.5f;

        [Header("Performance")]
        [SerializeField] private float _cullCheckInterval = 0.4f;

        // ─── Runtime state ─────────────────────────────────────────────────────

        private Camera  _camera;
        private Vector3 _localHomePosition;
        private Vector3 _homePosition;
        private Vector3 _baseScale;

        // Culling & fade-in
        private bool  _isActive    = true;
        private float _cullTimer;
        private float _fadeInAlpha = 1f;

        // Shake — live values driven by baseline or override
        private bool    _isShaking;
        private Vector3 _shakeOffset;
        private Vector3 _shakeTarget;
        private float   _shakeTimer;
        private float   _liveShakeRadius;
        private float   _liveShakeSpeed;
        private float   _liveShakeSmoothness;

        // Ghost trail — live values
        private bool           _liveGhostEnabled;
        private float          _liveGhostAlpha;
        private TextMeshPro    _ghostText;
        private Queue<Vector3> _positionHistory = new();
        private float          _historyTimer;
        private const float    HISTORY_SAMPLE_RATE = 0.016f;

        // Camera attraction
        private Vector3 _attractionOffset;

        // One-shot
        private bool  _hasBeenSeen;
        private bool  _permanentlyHidden;
        private float _closestDistanceReached = float.MaxValue;

        // One-shot fade-out — runs independently from the distance alpha
        private bool  _isFadingOut      = false;
        private float _fadeOutTimer     = 0f;
        private float _fadeOutStartAlpha = 1f;

        // Override coroutine
        private Coroutine _overrideCoroutine;

        // Baseline snapshot (so revert after override is accurate)
        private float _baselineShakeRadius;
        private float _baselineShakeSpeed;
        private float _baselineShakeSmoothness;
        private bool  _baselineGhostEnabled;
        private float _baselineGhostAlpha;

        // ─── Unity ─────────────────────────────────────────────────────────────

        private void Awake()
        {
            _camera = Camera.main;
            if (_textComponent == null)
                _textComponent = GetComponent<TextMeshPro>();

            // Initialise live values from inspector defaults
            _liveShakeRadius     = _shakeRadius;
            _liveShakeSpeed      = _shakeSpeed;
            _liveShakeSmoothness = _shakeSmoothness;
            _liveGhostEnabled    = _enableGhostTrail;
            _liveGhostAlpha      = _ghostAlpha;
        }

        private void Start()
        {
            _localHomePosition = transform.localPosition;
            _baseScale         = transform.localScale;

            if (_textComponent != null && !string.IsNullOrEmpty(_overrideText))
                _textComponent.text = _overrideText;

            SaveBaselineSnapshot();
            SetupGhostTrail();

            if (_enableOrganicShake)
                StartShakeInternal();
        }

        private void OnEnable()  => HallucinationLabelRegistry.Register(this);
        private void OnDisable() => HallucinationLabelRegistry.Unregister(this);

        private void Update()
        {
            if (_permanentlyHidden) return;

            if (_camera == null) { _camera = Camera.main; return; }

            // ── Distance cull ──────────────────────────────────────────────────
            _cullTimer += Time.deltaTime;
            if (_cullTimer >= _cullCheckInterval)
            {
                _cullTimer = 0f;
                bool shouldBeActive = Vector3.Distance(_camera.transform.position, transform.position)
                                      <= _maxVisibleDistance + _fadeRange;
                if (shouldBeActive != _isActive)
                {
                    _isActive              = shouldBeActive;
                    _textComponent.enabled = _isActive;
                    if (_ghostText != null) _ghostText.enabled = _isActive && _liveGhostEnabled;
                    if (_isActive) _fadeInAlpha = 0f;
                }
            }

            if (!_isActive) return;

            UpdatePosition();

            float dist = Vector3.Distance(_camera.transform.position, transform.position);

            // ── One-shot ───────────────────────────────────────────────────────
            if (_enableOneShot)
            {
                // Track the closest the player has ever been since the label was seen
                if (_hasBeenSeen && dist < _closestDistanceReached)
                    _closestDistanceReached = dist;

                // Mark as seen as soon as the player enters the visible range
                if (!_hasBeenSeen && dist <= _maxVisibleDistance)
                {
                    _hasBeenSeen            = true;
                    _closestDistanceReached = dist;
                }

                // Fade-out is running — drive alpha independently, skip normal alpha pipeline
                if (_isFadingOut)
                {
                    _fadeOutTimer += Time.deltaTime;
                    float t = 1f - Mathf.Clamp01(_fadeOutTimer / _fadeOutDuration);
                    float a = _fadeOutStartAlpha * t;
                    SetTextAlpha(_textComponent, a);
                    if (_ghostText != null) SetTextAlpha(_ghostText, a * _liveGhostAlpha);

                    if (_fadeOutTimer >= _fadeOutDuration)
                    {
                        _permanentlyHidden     = true;
                        _isFadingOut           = false;
                        _textComponent.enabled = false;
                        if (_ghostText != null) _ghostText.enabled = false;
                    }
                    return;
                }

                if (_hasBeenSeen)
                {
                    // Trigger: player reached the explicit trigger distance at some point
                    bool hasTriggered = _closestDistanceReached <= _oneShotTriggerDistance;

                    // Reset: player walked far away without ever triggering
                    bool isFarNow = dist > _maxVisibleDistance - _fadeRange;

                    if (hasTriggered)
                    {
                        _isFadingOut            = true;
                        _fadeOutTimer           = 0f;
                        _fadeOutStartAlpha      = ComputeAlpha(dist) * _fadeInAlpha;
                        _closestDistanceReached = float.MaxValue;
                        return;
                    }

                    if (_isRetriggerableFar && isFarNow)
                    {
                        _hasBeenSeen            = false;
                        _closestDistanceReached = float.MaxValue;
                    }
                }
            }

            // ── Normal alpha pipeline ──────────────────────────────────────────
            float alpha = ComputeAlpha(dist) * _fadeInAlpha;

            UpdateCameraAttraction(alpha);
            ApplyAlpha(alpha);
            UpdateAdaptiveScale();
            if (_isShaking) UpdateShake();
            UpdateGhostTrail();
        }

        // ─── Public API — two-layer system ─────────────────────────────────────

        /// <summary>
        /// Pushes sanity-driven baseline values. Ignored while an override is active.
        /// Called every frame by HallucinationManager for labels within range.
        /// </summary>
        public void ApplyBaseline(float shakeRadius, float shakeSpeed, float shakeSmoothness,
                                   bool ghostEnabled, float ghostAlpha)
        {
            if (_overrideCoroutine != null) return;

            SetShakeParams(shakeRadius, shakeSpeed, shakeSmoothness);
            SetGhostTrail(ghostEnabled, ghostAlpha);

            // Keep snapshot fresh so revert after override is correct
            _baselineShakeRadius     = shakeRadius;
            _baselineShakeSpeed      = shakeSpeed;
            _baselineShakeSmoothness = shakeSmoothness;
            _baselineGhostEnabled    = ghostEnabled;
            _baselineGhostAlpha      = ghostAlpha;
        }

        /// <summary>
        /// Applies a timed override then reverts to the last baseline snapshot.
        /// Called by HallucinationEvent at trigger time.
        /// </summary>
        public void ApplyOverride(float shakeRadius, float shakeSpeed, float shakeSmoothness,
                                   bool ghostEnabled, float ghostAlpha,
                                   float duration)
        {
            if (_overrideCoroutine != null) StopCoroutine(_overrideCoroutine);
            _overrideCoroutine = StartCoroutine(OverrideRoutine(
                shakeRadius, shakeSpeed, shakeSmoothness,
                ghostEnabled, ghostAlpha, duration));
        }

        private IEnumerator OverrideRoutine(float shakeRadius, float shakeSpeed, float shakeSmoothness,
                                             bool ghostEnabled, float ghostAlpha, float duration)
        {
            SetShakeParams(shakeRadius, shakeSpeed, shakeSmoothness);
            SetGhostTrail(ghostEnabled, ghostAlpha);

            yield return new WaitForSeconds(duration);

            SetShakeParams(_baselineShakeRadius, _baselineShakeSpeed, _baselineShakeSmoothness);
            SetGhostTrail(_baselineGhostEnabled, _baselineGhostAlpha);
            _overrideCoroutine = null;
        }

        // ─── Low-level setters (public for editor tooling / direct calls) ───────

        public void SetShakeParams(float radius, float speed, float smoothness)
        {
            _liveShakeRadius     = radius;
            _liveShakeSpeed      = speed;
            _liveShakeSmoothness = smoothness;

            if (radius > 0f && !_isShaking) StartShakeInternal();
            else if (radius <= 0f)          _isShaking = false;
        }

        public void SetGhostTrail(bool enabled, float alpha)
        {
            _liveGhostEnabled = enabled;
            _liveGhostAlpha   = alpha;
            if (_ghostText != null) _ghostText.enabled = _isActive && enabled;
        }

        // ─── Existing API ──────────────────────────────────────────────────────

        public void SetText(string text)
        {
            _overrideText = text;
            if (_textComponent != null) _textComponent.text = text;
            if (_ghostText     != null) _ghostText.text     = text;
        }

        public void SetHomePosition(Vector3 worldPos)
        {
            _homePosition      = worldPos;
            transform.position = worldPos;
        }

        public void ResetOneShot()
        {
            _hasBeenSeen            = false;
            _permanentlyHidden      = false;
            _isFadingOut            = false;
            _fadeOutTimer           = 0f;
            _fadeOutStartAlpha      = 1f;
            _closestDistanceReached = float.MaxValue;
            if (_textComponent != null) _textComponent.enabled = true;
            if (_ghostText     != null) _ghostText.enabled     = _liveGhostEnabled;
            _fadeInAlpha = 0f;
        }

        // ─── Internals ─────────────────────────────────────────────────────────

        private void SaveBaselineSnapshot()
        {
            _baselineShakeRadius     = _shakeRadius;
            _baselineShakeSpeed      = _shakeSpeed;
            _baselineShakeSmoothness = _shakeSmoothness;
            _baselineGhostEnabled    = _enableGhostTrail;
            _baselineGhostAlpha      = _ghostAlpha;
        }

        private void UpdatePosition()
        {
            if (transform.parent != null)
                _homePosition = transform.parent.TransformPoint(_localHomePosition);

            Vector3 toHome = _homePosition - _camera.transform.position;
            float   dist   = toHome.magnitude;

            Vector3 basePos = (dist < _minDistance && dist > 0.001f)
                ? _camera.transform.position + toHome.normalized * _minDistance
                : _homePosition + _shakeOffset;

            transform.position = basePos + _attractionOffset;
        }

        private void ApplyAlpha(float alpha)
        {
            if (_textComponent == null) return;

            if (_fadeInAlpha < 1f)
                _fadeInAlpha = Mathf.MoveTowards(_fadeInAlpha, 1f,
                    Time.deltaTime / Mathf.Max(_fadeInDuration, 0.001f));

            SetTextAlpha(_textComponent, alpha);
            if (_ghostText != null && _liveGhostEnabled)
                SetTextAlpha(_ghostText, alpha * _liveGhostAlpha);
        }

        private float ComputeAlpha(float dist)
        {
            if (dist >= _maxVisibleDistance) return 0f;

            float farFadeStart = _maxVisibleDistance - _fadeRange;
            if (dist > farFadeStart && _fadeRange > 0f)
                return 1f - (dist - farFadeStart) / _fadeRange;

            float nearFadeEnd = _minDistance + _nearFadeRange;
            if (dist < nearFadeEnd && _nearFadeRange > 0f)
                return Mathf.Clamp01((dist - _minDistance) / _nearFadeRange);

            return 1f;
        }

        private static void SetTextAlpha(TextMeshPro text, float alpha)
        {
            Color c = text.color;
            c.a = alpha;
            text.color = c;
        }

        private void UpdateAdaptiveScale()
        {
            if (!_enableAdaptiveScale) return;
            float dist        = Vector3.Distance(_camera.transform.position, transform.position);
            float scaleFactor = Mathf.Clamp(dist / Mathf.Max(_referenceDistance, 0.001f),
                                             _minScaleFactor, _maxScaleFactor);
            transform.localScale = _baseScale * scaleFactor;
            if (_ghostText != null) _ghostText.transform.localScale = transform.localScale;
        }

        private void UpdateCameraAttraction(float currentAlpha)
        {
            if (!_enableCameraAttraction) { _attractionOffset = Vector3.zero; return; }

            Vector3 toLabel = _homePosition - _camera.transform.position;
            float   dist    = toLabel.magnitude;
            if (dist < 0.001f) { _attractionOffset = Vector3.zero; return; }

            float angleDeg = Vector3.Angle(_camera.transform.forward, toLabel.normalized);
            float t        = Mathf.Clamp01(1f - angleDeg / Mathf.Max(_attractionAngle, 0.001f));
            float strength = t * t * currentAlpha;

            Vector3 labelOnCenterRay = _camera.transform.position + _camera.transform.forward * dist;
            Vector3 targetOffset     = (labelOnCenterRay - _homePosition) * strength;
            if (targetOffset.magnitude > _attractionMaxOffset)
                targetOffset = targetOffset.normalized * _attractionMaxOffset;

            _attractionOffset = Vector3.Lerp(_attractionOffset, targetOffset,
                                              Time.deltaTime * _attractionSmoothness);
        }

        private void StartShakeInternal()
        {
            _isShaking   = true;
            _shakeTimer  = 0f;
            _shakeTarget = RandomShakeTarget();
        }

        private Vector3 RandomShakeTarget()
        {
            float scaledRadius = _liveShakeRadius * transform.localScale.x;
            Vector2 circle = Random.insideUnitCircle * scaledRadius;
            return new Vector3(circle.x, circle.y, 0f);
        }

        private void UpdateShake()
        {
            _shakeTimer += Time.deltaTime * _liveShakeSpeed;
            if (_shakeTimer >= 1f) { _shakeTimer = 0f; _shakeTarget = RandomShakeTarget(); }
            _shakeOffset = Vector3.Lerp(_shakeOffset, _shakeTarget, Time.deltaTime * _liveShakeSmoothness);
        }

        private void SetupGhostTrail()
        {
            // Ghost GO is always created when the feature might be enabled at runtime
            if (_textComponent == null) return;

            GameObject ghostObj = new GameObject($"Ghost_{gameObject.name}");
            ghostObj.transform.SetParent(transform.parent, false);
            ghostObj.transform.position   = transform.position;
            ghostObj.transform.rotation   = transform.rotation;
            ghostObj.transform.localScale = transform.localScale;
            ghostObj.layer = gameObject.layer;

            _ghostText           = ghostObj.AddComponent<TextMeshPro>();
            _ghostText.font      = _textComponent.font;
            _ghostText.fontSize  = _textComponent.fontSize;
            _ghostText.alignment = _textComponent.alignment;
            _ghostText.text      = _textComponent.text;
            _ghostText.color     = new Color(_textComponent.color.r, _textComponent.color.g,
                                             _textComponent.color.b, _liveGhostAlpha);

            MeshRenderer mainRenderer  = _textComponent.GetComponent<MeshRenderer>();
            MeshRenderer ghostRenderer = _ghostText.GetComponent<MeshRenderer>();
            if (mainRenderer != null && ghostRenderer != null)
            {
                ghostRenderer.sortingLayerID = mainRenderer.sortingLayerID;
                ghostRenderer.sortingOrder   = mainRenderer.sortingOrder - 1;
            }

            ghostObj.AddComponent<FacePlayer>();

            // Start hidden — the manager or an override will enable it when needed
            _ghostText.enabled = _liveGhostEnabled;
        }

        private void UpdateGhostTrail()
        {
            if (!_liveGhostEnabled || _ghostText == null) return;

            _historyTimer += Time.deltaTime;
            if (_historyTimer >= HISTORY_SAMPLE_RATE)
            {
                _positionHistory.Enqueue(transform.position);
                _historyTimer = 0f;
                int maxSize = Mathf.CeilToInt(_ghostDelay / HISTORY_SAMPLE_RATE);
                while (_positionHistory.Count > maxSize) _positionHistory.Dequeue();
            }

            Vector3 ghostPos = _positionHistory.Count > 0 ? _positionHistory.Peek() : transform.position;
            _ghostText.transform.position = ghostPos + _camera.transform.forward * _ghostDepthOffset;
            _ghostText.text     = _textComponent.text;
            _ghostText.fontSize = _textComponent.fontSize;
        }

#if UNITY_EDITOR
        private void OnValidate()
        {
            if (_textComponent != null && !string.IsNullOrEmpty(_overrideText))
                _textComponent.text = _overrideText;
        }
#endif
    }
}