// URP 내장 TrackballUIDrawer(internal)의 복사본.
// Hidden/Universal Render Pipeline/Editor/Trackball 셰이더를 재사용합니다.

using System;
using UnityEngine;
using UnityEditor;
using UnityEditor.Rendering;

namespace YAMO
{
    sealed class YAMOTrackballUIDrawer
    {
        static readonly int s_ThumbHash = "yamoColorWheelThumb".GetHashCode();
        static GUIStyle  s_WheelThumb;
        static Vector2   s_WheelThumbSize;
        static Material  s_Material;

        Func<Vector4, Vector3> m_ComputeFunc;
        bool    m_ResetState;
        Vector2 m_CursorPos;

        const string k_ShaderName = "Hidden/Universal Render Pipeline/Editor/Trackball";

        public void OnGUI(SerializedProperty property, SerializedProperty overrideState,
                          GUIContent title, Func<Vector4, Vector3> computeFunc)
        {
            if (!CheckMaterialAndShader()) return;
            if (property.propertyType != SerializedPropertyType.Vector4)
            {
                EditorGUILayout.HelpBox("TrackballUIDrawer requires Vector4 property.", MessageType.Warning);
                return;
            }

            m_ComputeFunc = computeFunc;
            var value = property.vector4Value;

            using (new EditorGUILayout.VerticalScope())
            {
                bool isOverridden = overrideState?.boolValue ?? true;
                using (new EditorGUI.DisabledScope(!isOverridden))
                    DrawWheel(ref value, isOverridden);

                DrawLabelAndOverride(title, overrideState);
            }

            if (m_ResetState)
            {
                value = new Vector4(1f, 1f, 1f, 0f);
                m_ResetState = false;
            }

            property.vector4Value = value;
        }

        void DrawWheel(ref Vector4 value, bool overrideState)
        {
            var   wheelRect = GUILayoutUtility.GetAspectRect(1f);
            float size      = wheelRect.width;
            float hsize     = size / 2f;
            float radius    = 0.38f * size;

            Color.RGBToHSV(value, out float h, out float s, out float _);
            float offset = value.w;

            var   thumbPos = Vector2.zero;
            float theta    = h * (Mathf.PI * 2f);
            thumbPos.x = Mathf.Cos(theta + (Mathf.PI / 2f));
            thumbPos.y = Mathf.Sin(theta - (Mathf.PI / 2f));
            thumbPos  *= s * radius;

            if (Event.current.type == EventType.Repaint)
            {
                if (s_WheelThumb == null)
                {
                    s_WheelThumb = new GUIStyle("ColorPicker2DThumb");
                    s_WheelThumbSize = new Vector2(
                        !Mathf.Approximately(s_WheelThumb.fixedWidth,  0f) ? s_WheelThumb.fixedWidth  : s_WheelThumb.padding.horizontal,
                        !Mathf.Approximately(s_WheelThumb.fixedHeight, 0f) ? s_WheelThumb.fixedHeight : s_WheelThumb.padding.vertical);
                }

                float scale  = EditorGUIUtility.pixelsPerPoint;
                var   oldRT  = RenderTexture.active;
                var   rt     = RenderTexture.GetTemporary(
                    (int)(size * scale), (int)(size * scale), 0,
                    RenderTextureFormat.ARGB32, RenderTextureReadWrite.sRGB);

                s_Material.SetFloat("_Offset",        offset);
                s_Material.SetFloat("_DisabledState",  overrideState && GUI.enabled ? 1f : 0.5f);
                s_Material.SetVector("_Resolution",    new Vector2(size * scale, size * scale / 2f));
                Graphics.Blit(null, rt, s_Material, EditorGUIUtility.isProSkin ? 0 : 1);
                RenderTexture.active = oldRT;

                GUI.DrawTexture(wheelRect, rt);
                RenderTexture.ReleaseTemporary(rt);

                var thumbSizeH = s_WheelThumbSize / 2f;
                s_WheelThumb.Draw(
                    new Rect(wheelRect.x + hsize + thumbPos.x - thumbSizeH.x,
                             wheelRect.y + hsize + thumbPos.y - thumbSizeH.y,
                             s_WheelThumbSize.x, s_WheelThumbSize.y),
                    false, false, false, false);
            }

            // 마우스 입력
            var bounds = wheelRect;
            bounds.x    += hsize - radius;
            bounds.y    += hsize - radius;
            bounds.width = bounds.height = radius * 2f;

            var hsv = GetInput(bounds, new Vector3(h, s, 1f), thumbPos, radius);
            value   = Color.HSVToRGB(hsv.x, hsv.y, 1f);
            value.w = offset;

            // W 슬라이더 (밝기 오프셋)
            var sliderRect = GUILayoutUtility.GetRect(1f, 17f);
            float padding  = sliderRect.width * 0.05f;
            sliderRect.xMin += padding;
            sliderRect.xMax -= padding;
            value.w = GUI.HorizontalSlider(sliderRect, value.w, -1f, 1f);

            // R/G/B 수치 표시
            if (m_ComputeFunc != null)
            {
                var display = m_ComputeFunc(value);
                using (new EditorGUI.DisabledGroupScope(true))
                {
                    var vr = GUILayoutUtility.GetRect(1f, 17f);
                    vr.width /= 3f;
                    GUI.Label(vr, display.x.ToString("F2"), EditorStyles.centeredGreyMiniLabel);
                    vr.x += vr.width;
                    GUI.Label(vr, display.y.ToString("F2"), EditorStyles.centeredGreyMiniLabel);
                    vr.x += vr.width;
                    GUI.Label(vr, display.z.ToString("F2"), EditorStyles.centeredGreyMiniLabel);
                }
            }
        }

        void DrawLabelAndOverride(GUIContent title, SerializedProperty overrideState)
        {
            var  areaRect  = GUILayoutUtility.GetRect(1f, 17f);
            var  labelSize = EditorStyles.miniLabel.CalcSize(title);
            var  labelRect = new Rect(
                areaRect.x + areaRect.width / 2f - labelSize.x / 2f,
                areaRect.y, labelSize.x, labelSize.y);
            GUI.Label(labelRect, title, EditorStyles.miniLabel);

            if (overrideState != null)
            {
                var overrideRect = new Rect(labelRect.x - 17f, labelRect.y + 3f, 17f, 17f);
                overrideState.boolValue = GUI.Toggle(
                    overrideRect, overrideState.boolValue,
                    EditorGUIUtility.TrTextContent("", "Override this setting for this volume."),
                    CoreEditorStyles.smallTickbox);
            }
        }

        Vector3 GetInput(Rect bounds, Vector3 hsv, Vector2 thumbPos, float radius)
        {
            var  e       = Event.current;
            int  id      = GUIUtility.GetControlID(s_ThumbHash, FocusType.Passive, bounds);
            var  mousePos = e.mousePosition;

            if (e.type == EventType.MouseDown && GUIUtility.hotControl == 0 && bounds.Contains(mousePos))
            {
                if (e.button == 0)
                {
                    var   center = new Vector2(bounds.x + radius, bounds.y + radius);
                    float dist   = Vector2.Distance(center, mousePos);
                    if (dist <= radius)
                    {
                        e.Use();
                        m_CursorPos = new Vector2(thumbPos.x + radius, thumbPos.y + radius);
                        GUIUtility.hotControl = id;
                        GUI.changed = true;
                    }
                }
                else if (e.button == 1)
                {
                    e.Use();
                    GUI.changed  = true;
                    m_ResetState = true;
                }
            }
            else if (e.type == EventType.MouseDrag && e.button == 0 && GUIUtility.hotControl == id)
            {
                e.Use();
                GUI.changed  = true;
                m_CursorPos += e.delta * 0.2f;
                GetWheelHueSaturation(m_CursorPos.x, m_CursorPos.y, radius, out hsv.x, out hsv.y);
            }
            else if (e.rawType == EventType.MouseUp && e.button == 0 && GUIUtility.hotControl == id)
            {
                e.Use();
                GUIUtility.hotControl = 0;
            }

            return hsv;
        }

        void GetWheelHueSaturation(float x, float y, float radius,
                                    out float hue, out float saturation)
        {
            float dx = (x - radius) / radius;
            float dy = (y - radius) / radius;
            float d  = Mathf.Sqrt(dx * dx + dy * dy);
            hue = Mathf.Atan2(dx, -dy);
            hue = 1f - ((hue > 0) ? hue : (Mathf.PI * 2f) + hue) / (Mathf.PI * 2f);
            saturation = Mathf.Clamp01(d);
        }

        bool CheckMaterialAndShader()
        {
            if (s_Material != null) return true;
            var shader = Shader.Find(k_ShaderName);
            if (shader == null)
            {
                Debug.LogError($"[YAMOTrackballUIDrawer] 셰이더를 찾을 수 없습니다: {k_ShaderName}");
                return false;
            }
            s_Material = new Material(shader);
            return true;
        }
    }
}