using Animancer;
using BrewMonster;
using UnityEngine;
using UnityEngine.UI;

namespace BrewMonster.Scripts.UI.Inventory
{
    public enum PreviewDistanceScaleMode
    {
        AspectRatio,
        ViewportHeight
    }

    /// <summary>
    /// Clones the current host-player visual model into a dedicated preview rig for the inventory UI.
    /// </summary>
    [DisallowMultipleComponent]
    public class InventoryCharacterPreview : MonoBehaviour
    {
        [Header("Player Binding")]
        [SerializeField] private CECHostPlayer hostPlayer;
        [Tooltip("Auto locate the active host player if none is assigned.")]
        [SerializeField] private bool autoBindHostPlayer = true;
        [Tooltip("Optional manual override for the visual root. Leave empty to auto detect the PlayerVisual/host root.")]
        [SerializeField] private Transform sourceModelRoot;
        [Tooltip("Clone the entire CECHostPlayer hierarchy instead of just the PlayerVisual child.")]
        [SerializeField] private bool cloneWholeHostHierarchy = true;
        [Tooltip("Remove gameplay scripts/colliders from the preview clone when duplicating the full hierarchy.")]
        [SerializeField] private bool stripRuntimeComponents = true;

        [Header("Preview Rig")]
        [SerializeField] private Transform previewRoot;
        [SerializeField] private Vector3 previewLocalPosition = Vector3.zero;
        [SerializeField] private Vector3 previewLocalEuler;
        [SerializeField] private Vector3 previewLocalScale = Vector3.one;

        [Header("Camera Output")]
        [SerializeField] private RawImage previewFrame;
        [SerializeField] private RenderTexture previewRenderTexture;
        [SerializeField] private bool autoFocusCamera = true;
        [SerializeField] private Vector3 cameraFocusOffset = new Vector3(0f, 0f, 0f);

        [Header("Camera Framing")]
        [SerializeField] private float previewCameraDistance = 3.3f;
        [SerializeField] private Vector3 previewCameraOffset = new Vector3(0.15f, 0.8f, 0f);
        [SerializeField] private bool overrideFieldOfView = true;
        [SerializeField][Range(10f, 60f)] private float previewFieldOfView = 33f;

        [SerializeField] private bool autoFrameByBounds = true;
        [SerializeField][Range(1f, 2f)] private float autoFramePadding = 1.15f;
        [SerializeField] private float minAutoCameraDistance = 1.25f;
        [SerializeField] private float maxAutoCameraDistance = 8f;

        [Header("Device Framing")]
        [Tooltip("Design-time screen width (1920x1080 baseline); previewCameraDistance/offset tuned for this.")]
        [SerializeField] private float referenceScreenWidth = 1920f;
        [Tooltip("Design-time screen height (1920x1080 baseline); previewCameraDistance/offset tuned for this.")]
        [SerializeField] private float referenceScreenHeight = 1080f;
        [Tooltip("Use previewFrame pixel size when available; otherwise Screen.width/height.")]
        [SerializeField] private bool useRawImageViewport = true;
        [SerializeField] private PreviewDistanceScaleMode distanceScaleMode = PreviewDistanceScaleMode.AspectRatio;
        [Tooltip("Scale previewCameraOffset.y by viewport height vs 1080p reference (1.0 at 1920x1080).")]
        [SerializeField] private bool scaleCameraOffsetYByViewport = true;

        private bool _cameraStateCached;
        private Vector3 _cachedCameraPosition;
        private Quaternion _cachedCameraRotation;
        private float _cachedCameraFov;

        //[Header("Behaviour")]
        //[Tooltip("Disable PlayerVisual/Animancer components on the clone so it stays in a frozen idle pose.")]
        //[SerializeField] private bool freezeAnimation = true;

        private GameObject _previewInstance;
        private bool _refreshQueued;
        private int _lastOriginModelChildCount;
        private Transform _lastOriginModelRoot;
        private Camera _previewCamera;
        private PlayerModelPreview _playerModelPreview;
        private RenderTexture _cachedTargetTexture;

        private void Awake()
        {

            if (previewRoot == null)
            {
                previewRoot = transform;
            }

            TryBindPreviewSystem();
            TryBindHostPlayer();
            EnsureCameraBindings();
        }

        private void OnEnable()
        {
            TryBindPreviewSystem();
            EnsureCameraBindings();
            QueueRefresh();
        }

        private void OnDisable()
        {
            RestoreCameraTargetTexture();
            RestoreSharedCameraState();
            ReleasePreviewReference();
        }

        private void LateUpdate()
        {
            TryBindPreviewSystem();
            TryBindHostPlayer();

            // Check if origin model structure has changed (equipment models are child objects)
            // This detects equipment changes in realtime since all equipment is attached as children
            Transform currentOriginRoot = ResolveSourceModelRoot();
            if (currentOriginRoot == null)
            {
                if (_previewInstance == null)
                {
                    QueueRefresh();
                }
                if(_refreshQueued)
                {
                    _refreshQueued = false;
                    BuildPreviewModel();
                }
                return;
            }

            int currentChildCount = CountAllChildren(currentOriginRoot);

            if (_lastOriginModelRoot != currentOriginRoot || _lastOriginModelChildCount != currentChildCount)
            {
                _lastOriginModelRoot = currentOriginRoot;
                _lastOriginModelChildCount = currentChildCount;
                QueueRefresh();
            }

            if (_refreshQueued)
            {
                _refreshQueued = false;
                BuildPreviewModel();
            }

            if(_previewInstance != null)
            {
                EnsureCameraFocus(_previewInstance.transform);
            }
        }

        /// <summary>Allows manual binding from external UI scripts.</summary>
        public void BindPlayer(CECHostPlayer player)
        {
            if (player == null || player == hostPlayer)
            {
                return;
            }

            hostPlayer = player;
            QueueRefresh();
        }

        /// <summary>Forces an immediate rebuild of the preview model.</summary>
        public void ForceRefreshNow()
        {
            _refreshQueued = false;
            BuildPreviewModel();
        }

        /// <summary>Marks the clone dirty so it gets recreated next LateUpdate.</summary>
        public void QueueRefresh()
        {
            _refreshQueued = true;
        }

        private void TryBindPreviewSystem()
        {
            if (_playerModelPreview == null)
            {
                _playerModelPreview = PlayerModelPreview.Instance;
            }

            if (_playerModelPreview == null)
            {
                return;
            }

            if (_previewCamera == null)
            {
                _previewCamera = _playerModelPreview.GetComponent<Camera>();
            }
        }

        private void TryBindHostPlayer()
        {
            if (!autoBindHostPlayer || hostPlayer != null)
            {
                return;
            }

            hostPlayer = FindFirstObjectByType<CECHostPlayer>();
            if (hostPlayer != null)
            {
                QueueRefresh();
            }
        }

        private void EnsureCameraBindings()
        {
            if (_previewCamera == null)
            {
                TryBindPreviewSystem();
            }

            if (_previewCamera == null || previewFrame == null)
            {
                return;
            }

            if (_cachedTargetTexture == null)
            {
                _cachedTargetTexture = _previewCamera.targetTexture;
            }

            if (previewRenderTexture != null)
            {
                _previewCamera.targetTexture = previewRenderTexture;
            }

            if(previewFrame != null)
                previewFrame.texture = _previewCamera.targetTexture;
        }

        private void RestoreCameraTargetTexture()
        {
            if (_previewCamera == null)
            {
                return;
            }

            if (_cachedTargetTexture != null)
            {
                _previewCamera.targetTexture = _cachedTargetTexture;
            }
        }

        private void BuildPreviewModel()
        {
            if (previewRoot == null)
            {
                return;
            }

            Transform sourceRoot = ResolveSourceModelRoot();
            if (sourceRoot == null)
            {
                _previewInstance = null;
                _lastOriginModelRoot = null;
                _lastOriginModelChildCount = 0;

                QueueRefresh();
                return;
            }

            if (_previewInstance != null && _previewInstance != sourceRoot.gameObject)
            {
                DestroyPreviewInstance();
            }

            if (!sourceRoot.gameObject.activeSelf)
            {
                sourceRoot.gameObject.SetActive(true);
            }

            // Use resolved source root, not sourceModelRoot field directly.
            _previewInstance = sourceRoot.gameObject;
            Transform instanceTransform = _previewInstance.transform;

            if (instanceTransform.parent != previewRoot)
            {
                instanceTransform.SetParent(previewRoot, false);
            }

            instanceTransform.localPosition = previewLocalPosition + Vector3.up;
            instanceTransform.localRotation = Quaternion.Euler(previewLocalEuler);
            instanceTransform.localScale = previewLocalScale;

            ApplyLayerRecursive(instanceTransform, previewRoot.gameObject.layer);
            EnsureCameraFocus(instanceTransform);
            EnsureCameraBindings();
        }

        private void DestroyPreviewInstance()
        {
            if (_previewInstance != null)
            {
                Destroy(_previewInstance);
                _previewInstance = null;
            }
        }


        private Transform ResolveSourceModelRoot()
        {
            if (sourceModelRoot != null)
            {
                return sourceModelRoot;
            }

            if (_playerModelPreview == null)
            {
                return null;
            }

            // Prefer active model.
            for (int i = 0; i < _playerModelPreview.playerModels.Count; i++)
            {
                GameObject model = _playerModelPreview.playerModels[i];
                if (model != null && model.activeSelf)
                {
                    return model.transform;
                }
            }

            // Fallback to first available model.
            for (int i = 0; i < _playerModelPreview.playerModels.Count; i++)
            {
                GameObject model = _playerModelPreview.playerModels[i];
                if (model != null)
                {
                    return model.transform;
                }
            }

            return null;
        }

        private void ReleasePreviewReference()
        {
            _previewInstance = null;
        }

        //private void DestroyPreviewInstance()
        //{
        //    if (_previewInstance != null)
        //    {
        //        Destroy(_previewInstance);
        //        _previewInstance = null;
        //    }
        //}

        //private static void DisableComponentInChildren<T>(GameObject root) where T : Behaviour
        //{
        //    if (root == null)
        //    {
        //        return;
        //    }

        //    var components = root.GetComponentsInChildren<T>(true);
        //    for (int i = 0; i < components.Length; i++)
        //    {
        //        var component = components[i];
        //        if (component == null)
        //            continue;

        //        component.enabled = false;

        //        if (component is PlayerVisual)
        //        {
        //            Destroy(component);
        //        }
        //    }
        //}

        private void ApplyLayerRecursive(Transform root, int layer)
        {
            if (root == null)
            {
                return;
            }

            root.gameObject.layer = layer;
            for (int i = 0; i < root.childCount; i++)
            {
                ApplyLayerRecursive(root.GetChild(i), layer);
            }
        }

        private void EnsureCameraFocus(Transform modelRoot)
        {
            if (_previewCamera == null)
            {
                return;
            }

            if (!_cameraStateCached)
            {
                _cachedCameraPosition = _previewCamera.transform.position;
                _cachedCameraRotation = _previewCamera.transform.rotation;
                _cachedCameraFov = _previewCamera.fieldOfView;
                _cameraStateCached = true;
            }

            // Apply FOV override independently from auto focus.
            if (overrideFieldOfView)
            {
                _previewCamera.fieldOfView = previewFieldOfView;
            }

            if (!autoFocusCamera || modelRoot == null)
            {
                return;
            }

            Vector3 effectiveOffset = ComputeEffectiveCameraOffset();
            Vector3 focusPoint = modelRoot.TransformPoint(cameraFocusOffset) + effectiveOffset;

            Vector3 viewDirection = modelRoot.forward;
            viewDirection.y = 0f;
            if (viewDirection.sqrMagnitude < 0.0001f)
            {
                viewDirection = Vector3.back;
            }

            viewDirection.Normalize();

            float effectiveDistance = ComputeEffectiveCameraDistance(modelRoot, focusPoint, viewDirection);
            _previewCamera.transform.position = focusPoint + viewDirection * effectiveDistance;
            _previewCamera.transform.LookAt(focusPoint);
        }

        private bool TryGetViewportSize(out float width, out float height)
        {
            if (useRawImageViewport && previewFrame != null)
            {
                RectTransform rt = previewFrame.rectTransform;
                Canvas canvas = previewFrame.canvas;
                float scale = canvas != null ? canvas.scaleFactor : 1f;
                width = rt.rect.width * scale;
                height = rt.rect.height * scale;

                if (width > 1f && height > 1f)
                {
                    return true;
                }
            }

            width = Screen.width;
            height = Screen.height;
            return width > 0f && height > 0f;
        }

        private float ComputeAspectScaledDistance()
        {
            float distance = previewCameraDistance * ComputeViewportFramingScale();
            return Mathf.Clamp(distance, minAutoCameraDistance, maxAutoCameraDistance);
        }

        private float ComputeViewportFramingScale()
        {
            if (!TryGetViewportSize(out float viewportWidth, out float viewportHeight))
            {
                return 1f;
            }

            float refWidth = Mathf.Max(1f, referenceScreenWidth);
            float refHeight = Mathf.Max(1f, referenceScreenHeight);

            switch (distanceScaleMode)
            {
                case PreviewDistanceScaleMode.ViewportHeight:
                    return viewportHeight / refHeight;
                default:
                    float refAspect = refWidth / refHeight;
                    float viewAspect = viewportWidth / viewportHeight;
                    return viewAspect / refAspect;
            }
        }

        private float ComputeViewportHeightScale()
        {
            if (!TryGetViewportSize(out _, out float viewportHeight))
            {
                return 1f;
            }

            float refHeight = Mathf.Max(1f, referenceScreenHeight);
            return viewportHeight / refHeight;
        }

        private Vector3 ComputeEffectiveCameraOffset()
        {
            if (!scaleCameraOffsetYByViewport)
            {
                return previewCameraOffset;
            }

            // Tuned at 1920x1080: scale is 1.0 so previewCameraOffset.y is unchanged on reference resolution.
            float offsetYScale = ComputeViewportHeightScale();
            return new Vector3(
                previewCameraOffset.x,
                previewCameraOffset.y * offsetYScale,
                previewCameraOffset.z);
        }

        private float ComputeBoundsFitDistance(Transform modelRoot, Vector3 focusPoint, Vector3 viewDirection)
        {
            if (modelRoot == null)
            {
                return previewCameraDistance;
            }

            var renderers = modelRoot.GetComponentsInChildren<Renderer>(true);
            if (renderers == null || renderers.Length == 0)
            {
                return previewCameraDistance;
            }

            Bounds bounds = renderers[0].bounds;
            for (int i = 1; i < renderers.Length; i++)
            {
                if (renderers[i] != null)
                {
                    bounds.Encapsulate(renderers[i].bounds);
                }
            }

            if (bounds.size.sqrMagnitude < 0.0001f)
            {
                return previewCameraDistance;
            }

            if (!TryGetViewportSize(out float viewportWidth, out float viewportHeight))
            {
                return previewCameraDistance;
            }

            Vector3 cameraForward = -viewDirection;
            Vector3 cameraRight = Vector3.Cross(cameraForward, Vector3.up);
            if (cameraRight.sqrMagnitude < 0.0001f)
            {
                cameraRight = Vector3.Cross(cameraForward, Vector3.forward);
            }
            cameraRight.Normalize();
            Vector3 cameraUp = Vector3.Cross(cameraRight, cameraForward).normalized;

            Vector3 boundsMin = bounds.min;
            Vector3 boundsMax = bounds.max;
            float maxHorizontal = 0f;
            float maxVertical = 0f;

            for (int x = 0; x <= 1; x++)
            {
                for (int y = 0; y <= 1; y++)
                {
                    for (int z = 0; z <= 1; z++)
                    {
                        Vector3 corner = new Vector3(
                            x == 0 ? boundsMin.x : boundsMax.x,
                            y == 0 ? boundsMin.y : boundsMax.y,
                            z == 0 ? boundsMin.z : boundsMax.z);
                        Vector3 offset = corner - focusPoint;
                        maxHorizontal = Mathf.Max(maxHorizontal, Mathf.Abs(Vector3.Dot(offset, cameraRight)));
                        maxVertical = Mathf.Max(maxVertical, Mathf.Abs(Vector3.Dot(offset, cameraUp)));
                    }
                }
            }

            float viewAspect = viewportWidth / viewportHeight;
            float verticalFovRad = previewFieldOfView * Mathf.Deg2Rad;
            float halfVerticalTan = Mathf.Tan(verticalFovRad * 0.5f);
            if (halfVerticalTan < 0.0001f)
            {
                return previewCameraDistance;
            }

            float halfHorizontalTan = halfVerticalTan * viewAspect;
            float distanceForHeight = maxVertical / halfVerticalTan;
            float distanceForWidth = maxHorizontal / Mathf.Max(halfHorizontalTan, 0.0001f);
            float boundsDistance = Mathf.Max(distanceForHeight, distanceForWidth);

            return boundsDistance * autoFramePadding;
        }

        private float ComputeEffectiveCameraDistance(Transform modelRoot, Vector3 focusPoint, Vector3 viewDirection)
        {
            float aspectScaledDistance = ComputeAspectScaledDistance();
            float effectiveDistance = aspectScaledDistance;

            if (autoFrameByBounds)
            {
                float boundsDistance = ComputeBoundsFitDistance(modelRoot, focusPoint, viewDirection);
                effectiveDistance = Mathf.Max(aspectScaledDistance, boundsDistance);
            }

            return Mathf.Clamp(effectiveDistance, minAutoCameraDistance, maxAutoCameraDistance);
        }

        //private void StripRuntimeScripts(GameObject cloneRoot)
        //{
        //    if (cloneRoot == null)
        //    {
        //        return;
        //    }

        //    var monoBehaviours = cloneRoot.GetComponentsInChildren<MonoBehaviour>(true);
        //    for (int i = 0; i < monoBehaviours.Length; i++)
        //    {
        //        var behaviour = monoBehaviours[i];
        //        if (behaviour == null)
        //            continue;

        //        Destroy(behaviour);
        //    }

        //    var colliders = cloneRoot.GetComponentsInChildren<Collider>(true);
        //    for (int i = 0; i < colliders.Length; i++)
        //    {
        //        var collider = colliders[i];
        //        if (collider == null)
        //            continue;

        //        Destroy(collider);
        //    }

        //    var rigidbodies = cloneRoot.GetComponentsInChildren<Rigidbody>(true);
        //    for (int i = 0; i < rigidbodies.Length; i++)
        //    {
        //        var body = rigidbodies[i];
        //        if (body == null)
        //            continue;

        //        Destroy(body);
        //    }
        //}

        private void RestoreSharedCameraState()
        {
            if (!_cameraStateCached || _previewCamera == null)
            {
                return;
            }

            _previewCamera.transform.position = _cachedCameraPosition;
            _previewCamera.transform.rotation = _cachedCameraRotation;
            _previewCamera.fieldOfView = _cachedCameraFov;
            _cameraStateCached = false;
        }

        //private void FreezeAnimators(GameObject cloneRoot)
        //{
        //    if (cloneRoot == null)
        //    {
        //        return;
        //    }

        //    var animators = cloneRoot.GetComponentsInChildren<Animator>(true);
        //    for (int i = 0; i < animators.Length; i++)
        //    {
        //        var animator = animators[i];
        //        if (animator == null)
        //            continue;

        //        animator.speed = 0f;
        //    }
        //}

        /// <summary>
        /// Counts all children recursively in the transform hierarchy.
        /// Used to detect when equipment (child objects) are added or removed from the origin model.
        /// </summary>
        private int CountAllChildren(Transform root)
        {
            if (root == null)
                return 0;

            int count = root.childCount;
            for (int i = 0; i < root.childCount; i++)
            {
                count += CountAllChildren(root.GetChild(i));
            }
            return count;
        }
    }
}