using System;
using System.Collections.Generic;
using System.Text;

using TMPro;

using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;

using Colosseum.Player;
using Colosseum.Skills;

#if UNITY_EDITOR
using UnityEditor;
#endif

namespace Colosseum.UI
{
    /// <summary>
    /// 젬 보관함과 스킬별 장착/탈착 UI를 관리합니다.
    /// </summary>
    public class SkillGemInventoryUI : MonoBehaviour
    {
        private const string DefaultGemSearchFolder = "Assets/_Game/Data/SkillGems";

        [Serializable]
        private class SkillGemStorageEntry
        {
            [SerializeField] private SkillGemData gem;
            [Min(0)] [SerializeField] private int quantity = 1;

            public SkillGemData Gem
            {
                get => gem;
                set => gem = value;
            }

            public int Quantity
            {
                get => quantity;
                set => quantity = Mathf.Max(0, value);
            }
        }

        [Header("Toggle")]
        [Tooltip("젬 UI를 여닫는 키")]
        [SerializeField] private Key toggleKey = Key.G;
        [Tooltip("토글 버튼에 표시할 텍스트")]
        [SerializeField] private string toggleButtonLabel = "젬";
        [Tooltip("토글 버튼의 캔버스 기준 위치")]
        [SerializeField] private Vector2 toggleButtonAnchoredPosition = new Vector2(-48f, 164f);

        [Header("Storage")]
        [Tooltip("젬 보관 수량")]
        [SerializeField] private List<SkillGemStorageEntry> ownedGemEntries = new();

        [Header("Debug")]
        [Tooltip("플레이 모드 시작 시 패널을 자동으로 엽니다.")]
        [SerializeField] private bool openOnStartInPlayMode = false;

        #if UNITY_EDITOR
        [Header("Editor Auto Collect")]
        [Tooltip("에디터에서 젬 자산을 자동으로 수집합니다.")]
        [SerializeField] private bool autoCollectOwnedGemsInEditor = true;
        [Tooltip("자동 수집할 젬 자산 폴더")]
        [SerializeField] private string gemSearchFolder = DefaultGemSearchFolder;
        [Tooltip("자동 수집 시 신규 젬 기본 수량")]
        [Min(0)] [SerializeField] private int autoCollectedGemQuantity = 1;
        #endif

        [Header("Style")]
        [SerializeField] private Color panelBackgroundColor = new Color(0.08f, 0.08f, 0.11f, 0.96f);
        [SerializeField] private Color sectionBackgroundColor = new Color(0.14f, 0.14f, 0.18f, 0.95f);
        [SerializeField] private Color buttonNormalColor = new Color(0.19f, 0.19f, 0.24f, 0.96f);
        [SerializeField] private Color buttonSelectedColor = new Color(0.48f, 0.32f, 0.16f, 0.96f);
        [SerializeField] private Color buttonDisabledColor = new Color(0.12f, 0.12f, 0.15f, 0.65f);
        [SerializeField] private Color statusNormalColor = new Color(0.86f, 0.85f, 0.78f, 1f);
        [SerializeField] private Color statusErrorColor = new Color(1f, 0.52f, 0.45f, 1f);

        private static readonly string[] SlotDisplayNames =
        {
            "좌클릭",
            "우클릭",
            "기술 1",
            "기술 2",
            "기술 3",
            "기술 4",
            "긴급 회피",
        };

        private PlayerSkillInput playerSkillInput;
        private PlayerMovement playerMovement;
        private Canvas parentCanvas;
        private RectTransform canvasRectTransform;
        private TMP_FontAsset sharedFont;

        private GameObject overlayRoot;
        private RectTransform panelRectTransform;

        private RectTransform skillListContent;
        private RectTransform socketListContent;
        private RectTransform gemListContent;

        private TextMeshProUGUI storageSummaryText;
        private TextMeshProUGUI skillSummaryText;
        private TextMeshProUGUI gemDetailText;
        private TextMeshProUGUI statusText;
        private Button equipButton;
        private Button unequipButton;
        private TextMeshProUGUI equipButtonLabel;
        private TextMeshProUGUI unequipButtonLabel;

        private bool isPanelVisible;
        private bool uiInitialized;
        private int selectedSkillSlotIndex;
        private int selectedSocketIndex;
        private SkillGemData selectedGem;
        private bool previousCursorVisible;
        private CursorLockMode previousCursorLockState;

        private void Awake()
        {
            EnsureUi();
            HidePanelImmediate();
        }

        private void Start()
        {
            EnsureUi();
            FindLocalPlayer();
            RefreshAll();

            if (Application.isPlaying && openOnStartInPlayMode)
            {
                SetPanelVisible(true);
            }
        }

        private void Update()
        {
            if (playerSkillInput == null)
            {
                FindLocalPlayer();
            }

            if (Keyboard.current == null)
                return;

            if (Keyboard.current[toggleKey].wasPressedThisFrame)
            {
                TogglePanelVisibility();
            }
            else if (isPanelVisible && Keyboard.current.escapeKey.wasPressedThisFrame)
            {
                SetPanelVisible(false);
            }
        }

        private void OnDestroy()
        {
            UnsubscribeFromPlayer();
            SetGameplayInputBlocked(false);
            RestoreCursorState();
        }

        #if UNITY_EDITOR
        private void OnValidate()
        {
            if (Application.isPlaying)
                return;

            AutoCollectOwnedGemsInEditor();
        }
        #endif

        private void FindLocalPlayer()
        {
            PlayerSkillInput[] players = FindObjectsByType<PlayerSkillInput>(FindObjectsSortMode.None);
            for (int i = 0; i < players.Length; i++)
            {
                if (!players[i].IsOwner)
                    continue;

                if (playerSkillInput == players[i])
                    return;

                SetTarget(players[i]);
                return;
            }
        }

        private void SetTarget(PlayerSkillInput target)
        {
            UnsubscribeFromPlayer();
            playerSkillInput = target;
            playerMovement = playerSkillInput != null ? playerSkillInput.GetComponent<PlayerMovement>() : null;

            if (playerSkillInput != null)
            {
                playerSkillInput.OnSkillSlotsChanged += HandleSkillSlotsChanged;
            }

            if (isPanelVisible)
            {
                SetGameplayInputBlocked(true);
            }

            RefreshAll();
        }

        private void UnsubscribeFromPlayer()
        {
            if (playerSkillInput != null)
            {
                playerSkillInput.OnSkillSlotsChanged -= HandleSkillSlotsChanged;
            }
        }

        private void HandleSkillSlotsChanged()
        {
            RefreshAll();
        }

        private void TogglePanelVisibility()
        {
            SetPanelVisible(!isPanelVisible);
        }

        private void SetPanelVisible(bool visible)
        {
            EnsureUi();
            isPanelVisible = visible;
            UpdatePanelSize();

            if (overlayRoot != null)
            {
                overlayRoot.SetActive(visible);
            }

            if (visible)
            {
                RememberCursorState();
                Cursor.visible = true;
                Cursor.lockState = CursorLockMode.None;
                SetGameplayInputBlocked(true);
                RefreshAll();
            }
            else
            {
                SetGameplayInputBlocked(false);
                RestoreCursorState();
            }
        }

        private void HidePanelImmediate()
        {
            isPanelVisible = false;
            if (overlayRoot != null)
            {
                overlayRoot.SetActive(false);
            }
        }

        private void RememberCursorState()
        {
            previousCursorVisible = Cursor.visible;
            previousCursorLockState = Cursor.lockState;
        }

        private void RestoreCursorState()
        {
            Cursor.visible = previousCursorVisible;
            Cursor.lockState = previousCursorLockState;
        }

        private void SetGameplayInputBlocked(bool blocked)
        {
            if (playerMovement != null)
            {
                playerMovement.SetGameplayInputEnabled(!blocked);
            }

            if (playerSkillInput != null)
            {
                playerSkillInput.SetGameplayInputEnabled(!blocked);
            }
        }

        private void EnsureUi()
        {
            if (uiInitialized)
                return;

            parentCanvas = GetComponentInParent<Canvas>();
            canvasRectTransform = parentCanvas != null ? parentCanvas.GetComponent<RectTransform>() : null;

            if (parentCanvas == null || canvasRectTransform == null)
            {
                Debug.LogWarning("[SkillGemInventoryUI] Canvas를 찾지 못했습니다.");
                return;
            }

            TextMeshProUGUI referenceText = GetComponentInChildren<TextMeshProUGUI>(true);
            sharedFont = referenceText != null ? referenceText.font : TMP_Settings.defaultFontAsset;
            CreateToggleButton();
            CreateOverlay();
            UpdatePanelSize();
            uiInitialized = true;
        }

        private void UpdatePanelSize()
        {
            if (panelRectTransform == null || canvasRectTransform == null)
                return;

            Rect canvasRect = canvasRectTransform.rect;
            float width = Mathf.Clamp(canvasRect.width - 120f, 920f, 1380f);
            float height = Mathf.Clamp(canvasRect.height - 120f, 620f, 820f);
            panelRectTransform.sizeDelta = new Vector2(width, height);
        }

        private void CreateToggleButton()
        {
            GameObject buttonObject = CreateUiObject("Button_GemInventory", canvasRectTransform);
            RectTransform buttonRect = buttonObject.AddComponent<RectTransform>();
            buttonRect.anchorMin = new Vector2(1f, 0f);
            buttonRect.anchorMax = new Vector2(1f, 0f);
            buttonRect.pivot = new Vector2(1f, 0f);
            buttonRect.anchoredPosition = toggleButtonAnchoredPosition;
            buttonRect.sizeDelta = new Vector2(72f, 34f);

            Image buttonImage = buttonObject.AddComponent<Image>();
            buttonImage.color = buttonNormalColor;
            Button toggleButton = buttonObject.AddComponent<Button>();
            toggleButton.targetGraphic = buttonImage;
            toggleButton.onClick.AddListener(TogglePanelVisibility);

            TextMeshProUGUI label = CreateFillLabel(buttonRect, "Label", toggleButtonLabel, 18f, TextAlignmentOptions.Center);
            label.textWrappingMode = TextWrappingModes.NoWrap;
        }

        private void CreateOverlay()
        {
            overlayRoot = CreateUiObject("Overlay_GemInventory", canvasRectTransform);
            RectTransform overlayRect = overlayRoot.AddComponent<RectTransform>();
            StretchToParent(overlayRect);

            GameObject backdropObject = CreateUiObject("Backdrop", overlayRect);
            RectTransform backdropRect = backdropObject.AddComponent<RectTransform>();
            StretchToParent(backdropRect);
            Image backdropImage = backdropObject.AddComponent<Image>();
            backdropImage.color = new Color(0f, 0f, 0f, 0.38f);
            Button backdropButton = backdropObject.AddComponent<Button>();
            backdropButton.targetGraphic = backdropImage;
            backdropButton.onClick.AddListener(() => SetPanelVisible(false));

            GameObject panelObject = CreateUiObject("Panel", overlayRect);
            panelRectTransform = panelObject.AddComponent<RectTransform>();
            panelRectTransform.anchorMin = new Vector2(0.5f, 0.5f);
            panelRectTransform.anchorMax = new Vector2(0.5f, 0.5f);
            panelRectTransform.pivot = new Vector2(0.5f, 0.5f);
            panelRectTransform.anchoredPosition = Vector2.zero;
            panelRectTransform.sizeDelta = new Vector2(1160f, 680f);

            Image panelImage = panelObject.AddComponent<Image>();
            panelImage.color = panelBackgroundColor;

            VerticalLayoutGroup panelLayout = panelObject.AddComponent<VerticalLayoutGroup>();
            panelLayout.padding = new RectOffset(18, 18, 18, 18);
            panelLayout.spacing = 14f;
            panelLayout.childAlignment = TextAnchor.UpperLeft;
            panelLayout.childControlWidth = true;
            panelLayout.childControlHeight = true;
            panelLayout.childForceExpandWidth = true;
            panelLayout.childForceExpandHeight = false;

            ContentSizeFitter fitter = panelObject.AddComponent<ContentSizeFitter>();
            fitter.verticalFit = ContentSizeFitter.FitMode.Unconstrained;
            fitter.horizontalFit = ContentSizeFitter.FitMode.Unconstrained;

            CreateHeader(panelRectTransform);
            CreateBody(panelRectTransform);
            CreateFooter(panelRectTransform);
        }

        private void CreateHeader(RectTransform parent)
        {
            RectTransform header = CreateContainer(parent, "Header", 96f);
            HorizontalLayoutGroup layout = header.gameObject.AddComponent<HorizontalLayoutGroup>();
            layout.childAlignment = TextAnchor.MiddleLeft;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = false;
            layout.childForceExpandHeight = true;
            layout.spacing = 12f;

            RectTransform titleGroup = CreateUiObject("TitleGroup", header).AddComponent<RectTransform>();
            LayoutElement titleLayout = titleGroup.gameObject.AddComponent<LayoutElement>();
            titleLayout.flexibleWidth = 1f;
            VerticalLayoutGroup titleGroupLayout = titleGroup.gameObject.AddComponent<VerticalLayoutGroup>();
            titleGroupLayout.spacing = 4f;
            titleGroupLayout.childAlignment = TextAnchor.MiddleLeft;
            titleGroupLayout.childControlWidth = true;
            titleGroupLayout.childControlHeight = true;
            titleGroupLayout.childForceExpandWidth = true;
            titleGroupLayout.childForceExpandHeight = false;

            TextMeshProUGUI title = CreateAutoLabel(titleGroup, "Title", "젬 보관함", 30f, TextAlignmentOptions.Left);
            title.fontStyle = FontStyles.Bold;
            title.textWrappingMode = TextWrappingModes.NoWrap;
            LayoutElement titleTextLayout = title.gameObject.AddComponent<LayoutElement>();
            titleTextLayout.minHeight = 36f;

            TextMeshProUGUI subtitle = CreateAutoLabel(titleGroup, "Subtitle", "G 키 또는 버튼으로 열고 닫을 수 있습니다.", 18f, TextAlignmentOptions.Left);
            subtitle.color = new Color(0.82f, 0.8f, 0.72f, 0.92f);
            subtitle.textWrappingMode = TextWrappingModes.NoWrap;
            LayoutElement subtitleTextLayout = subtitle.gameObject.AddComponent<LayoutElement>();
            subtitleTextLayout.minHeight = 24f;

            Button closeButton = CreateButton(header, "Button_Close", "닫기", new Vector2(90f, 42f), () => SetPanelVisible(false), out _);
            LayoutElement closeButtonLayout = closeButton.gameObject.AddComponent<LayoutElement>();
            closeButtonLayout.minWidth = 90f;
            closeButtonLayout.preferredWidth = 90f;
            closeButton.image.color = new Color(0.32f, 0.18f, 0.18f, 0.95f);
        }

        private void CreateBody(RectTransform parent)
        {
            RectTransform body = CreateContainer(parent, "Body", 0f);
            LayoutElement bodyLayout = body.GetComponent<LayoutElement>();
            bodyLayout.flexibleHeight = 1f;
            bodyLayout.minHeight = 0f;

            HorizontalLayoutGroup layout = body.gameObject.AddComponent<HorizontalLayoutGroup>();
            layout.childAlignment = TextAnchor.UpperLeft;
            layout.spacing = 14f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = true;
            layout.childForceExpandHeight = true;

            CreateSkillSection(body);
            CreateSocketSection(body);
            CreateStorageSection(body);
        }

        private void CreateFooter(RectTransform parent)
        {
            RectTransform footer = CreateContainer(parent, "Footer", 64f);
            Image footerImage = footer.gameObject.AddComponent<Image>();
            footerImage.color = sectionBackgroundColor;

            HorizontalLayoutGroup layout = footer.gameObject.AddComponent<HorizontalLayoutGroup>();
            layout.padding = new RectOffset(14, 14, 12, 12);
            layout.spacing = 10f;
            layout.childControlWidth = true;
            layout.childControlHeight = true;
            layout.childForceExpandWidth = false;
            layout.childForceExpandHeight = true;
            layout.childAlignment = TextAnchor.MiddleLeft;

            statusText = CreateAutoLabel(footer, "Label_Status", "로컬 플레이어를 찾는 중입니다.", 19f, TextAlignmentOptions.MidlineLeft);
            LayoutElement statusLayout = statusText.gameObject.AddComponent<LayoutElement>();
            statusLayout.flexibleWidth = 1f;
            statusText.color = statusNormalColor;
        }

        private void CreateSkillSection(RectTransform parent)
        {
            RectTransform section = CreateSectionRoot(parent, "Section_Skills");
            LayoutElement sectionLayout = section.GetComponent<LayoutElement>();
            sectionLayout.preferredWidth = 300f;
            CreateSectionTitle(section, "스킬 슬롯");
            skillSummaryText = CreateInfoText(section, "Label_SkillSummary", 100f);
            RectTransform scroll = CreateScrollView(section, "Scroll_Skills", out skillListContent);
            LayoutElement scrollLayout = scroll.gameObject.AddComponent<LayoutElement>();
            scrollLayout.flexibleHeight = 1f;
            scrollLayout.minHeight = 180f;
        }

        private void CreateSocketSection(RectTransform parent)
        {
            RectTransform section = CreateSectionRoot(parent, "Section_Sockets");
            LayoutElement sectionLayout = section.GetComponent<LayoutElement>();
            sectionLayout.preferredWidth = 300f;
            CreateSectionTitle(section, "장착 소켓");

            RectTransform commandRow = CreateContainer(section, "Commands", 48f);
            HorizontalLayoutGroup commandLayout = commandRow.gameObject.AddComponent<HorizontalLayoutGroup>();
            commandLayout.spacing = 8f;
            commandLayout.childControlWidth = true;
            commandLayout.childControlHeight = true;
            commandLayout.childForceExpandWidth = true;
            commandLayout.childForceExpandHeight = true;

            equipButton = CreateButton(commandRow, "Button_Equip", "선택한 젬 장착", Vector2.zero, TryEquipSelectedGem, out equipButtonLabel);
            LayoutElement equipLayout = equipButton.gameObject.AddComponent<LayoutElement>();
            equipLayout.flexibleWidth = 1f;

            unequipButton = CreateButton(commandRow, "Button_Unequip", "선택한 젬 탈착", Vector2.zero, TryUnequipSelectedGem, out unequipButtonLabel);
            LayoutElement unequipLayout = unequipButton.gameObject.AddComponent<LayoutElement>();
            unequipLayout.flexibleWidth = 1f;

            RectTransform scroll = CreateScrollView(section, "Scroll_Sockets", out socketListContent);
            LayoutElement scrollLayout = scroll.gameObject.AddComponent<LayoutElement>();
            scrollLayout.flexibleHeight = 1f;
            scrollLayout.minHeight = 240f;
        }

        private void CreateStorageSection(RectTransform parent)
        {
            RectTransform section = CreateSectionRoot(parent, "Section_Storage");
            LayoutElement sectionLayout = section.GetComponent<LayoutElement>();
            sectionLayout.preferredWidth = 380f;
            CreateSectionTitle(section, "젬 보관함");
            storageSummaryText = CreateInfoText(section, "Label_StorageSummary", 72f);

            RectTransform scroll = CreateScrollView(section, "Scroll_Gems", out gemListContent);
            LayoutElement scrollLayout = scroll.gameObject.AddComponent<LayoutElement>();
            scrollLayout.flexibleHeight = 1f;
            scrollLayout.minHeight = 150f;

            gemDetailText = CreateInfoText(section, "Label_GemDetail", 120f);
        }

        private RectTransform CreateSectionRoot(RectTransform parent, string name)
        {
            RectTransform section = CreateContainer(parent, name, 0f);
            LayoutElement layout = section.GetComponent<LayoutElement>();
            layout.flexibleWidth = 1f;
            layout.flexibleHeight = 1f;
            layout.minWidth = 0f;

            Image image = section.gameObject.AddComponent<Image>();
            image.color = sectionBackgroundColor;

            VerticalLayoutGroup verticalLayout = section.gameObject.AddComponent<VerticalLayoutGroup>();
            verticalLayout.padding = new RectOffset(14, 14, 14, 14);
            verticalLayout.spacing = 10f;
            verticalLayout.childAlignment = TextAnchor.UpperLeft;
            verticalLayout.childControlWidth = true;
            verticalLayout.childControlHeight = true;
            verticalLayout.childForceExpandWidth = true;
            verticalLayout.childForceExpandHeight = false;
            return section;
        }

        private TextMeshProUGUI CreateSectionTitle(RectTransform parent, string text)
        {
            TextMeshProUGUI label = CreateAutoLabel(parent, "Title", text, 24f, TextAlignmentOptions.Left);
            label.fontStyle = FontStyles.Bold;
            LayoutElement layout = label.gameObject.AddComponent<LayoutElement>();
            layout.minHeight = 34f;
            return label;
        }

        private TextMeshProUGUI CreateInfoText(RectTransform parent, string name, float minHeight)
        {
            RectTransform container = CreateContainer(parent, $"{name}_Container", minHeight);
            Image image = container.gameObject.AddComponent<Image>();
            image.color = new Color(0f, 0f, 0f, 0.16f);
            LayoutElement layout = container.GetComponent<LayoutElement>();
            layout.minHeight = minHeight;
            VerticalLayoutGroup containerLayout = container.gameObject.AddComponent<VerticalLayoutGroup>();
            containerLayout.padding = new RectOffset(12, 12, 10, 10);
            containerLayout.childAlignment = TextAnchor.UpperLeft;
            containerLayout.childControlWidth = true;
            containerLayout.childControlHeight = true;
            containerLayout.childForceExpandWidth = true;
            containerLayout.childForceExpandHeight = false;

            ContentSizeFitter containerFitter = container.gameObject.AddComponent<ContentSizeFitter>();
            containerFitter.horizontalFit = ContentSizeFitter.FitMode.Unconstrained;
            containerFitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;

            TextMeshProUGUI label = CreateAutoLabel(container, name, string.Empty, 18f, TextAlignmentOptions.TopLeft);
            label.textWrappingMode = TextWrappingModes.Normal;
            label.overflowMode = TextOverflowModes.Ellipsis;
            return label;
        }

        private RectTransform CreateScrollView(RectTransform parent, string name, out RectTransform content)
        {
            GameObject rootObject = CreateUiObject(name, parent);
            RectTransform rootRect = rootObject.AddComponent<RectTransform>();

            Image rootImage = rootObject.AddComponent<Image>();
            rootImage.color = new Color(0f, 0f, 0f, 0.12f);

            ScrollRect scrollRect = rootObject.AddComponent<ScrollRect>();
            scrollRect.horizontal = false;
            scrollRect.vertical = true;
            scrollRect.scrollSensitivity = 24f;

            GameObject viewportObject = CreateUiObject("Viewport", rootRect);
            RectTransform viewportRect = viewportObject.AddComponent<RectTransform>();
            StretchToParent(viewportRect);
            Image viewportImage = viewportObject.AddComponent<Image>();
            viewportImage.color = new Color(1f, 1f, 1f, 0.01f);
            Mask viewportMask = viewportObject.AddComponent<Mask>();
            viewportMask.showMaskGraphic = false;

            GameObject contentObject = CreateUiObject("Content", viewportRect);
            content = contentObject.AddComponent<RectTransform>();
            content.anchorMin = new Vector2(0f, 1f);
            content.anchorMax = new Vector2(1f, 1f);
            content.pivot = new Vector2(0.5f, 1f);
            content.anchoredPosition = Vector2.zero;
            content.sizeDelta = Vector2.zero;

            VerticalLayoutGroup contentLayout = contentObject.AddComponent<VerticalLayoutGroup>();
            contentLayout.padding = new RectOffset(8, 8, 8, 8);
            contentLayout.spacing = 6f;
            contentLayout.childAlignment = TextAnchor.UpperLeft;
            contentLayout.childControlWidth = true;
            contentLayout.childControlHeight = true;
            contentLayout.childForceExpandWidth = true;
            contentLayout.childForceExpandHeight = false;

            ContentSizeFitter contentFitter = contentObject.AddComponent<ContentSizeFitter>();
            contentFitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
            contentFitter.horizontalFit = ContentSizeFitter.FitMode.Unconstrained;

            scrollRect.viewport = viewportRect;
            scrollRect.content = content;
            return rootRect;
        }

        private RectTransform CreateContainer(RectTransform parent, string name, float minHeight)
        {
            GameObject containerObject = CreateUiObject(name, parent);
            RectTransform rectTransform = containerObject.AddComponent<RectTransform>();
            LayoutElement layout = containerObject.AddComponent<LayoutElement>();
            layout.minHeight = minHeight;
            return rectTransform;
        }

        private Button CreateButton(RectTransform parent, string name, string labelText, Vector2 size, Action onClick, out TextMeshProUGUI label)
        {
            GameObject buttonObject = CreateUiObject(name, parent);
            RectTransform rectTransform = buttonObject.AddComponent<RectTransform>();
            if (size.sqrMagnitude > 0f)
            {
                rectTransform.sizeDelta = size;
            }

            Image image = buttonObject.AddComponent<Image>();
            image.color = buttonNormalColor;

            Button button = buttonObject.AddComponent<Button>();
            button.targetGraphic = image;
            button.onClick.AddListener(() => onClick?.Invoke());

            label = CreateFillLabel(rectTransform, "Label", labelText, 18f, TextAlignmentOptions.Center);
            label.textWrappingMode = TextWrappingModes.Normal;
            label.margin = new Vector4(12f, 6f, 12f, 6f);
            return button;
        }

        private TextMeshProUGUI CreateAutoLabel(RectTransform parent, string name, string text, float fontSize, TextAlignmentOptions alignment)
        {
            GameObject labelObject = CreateUiObject(name, parent);
            RectTransform rectTransform = labelObject.AddComponent<RectTransform>();
            rectTransform.anchorMin = new Vector2(0f, 1f);
            rectTransform.anchorMax = new Vector2(1f, 1f);
            rectTransform.pivot = new Vector2(0.5f, 1f);
            rectTransform.sizeDelta = Vector2.zero;

            TextMeshProUGUI label = labelObject.AddComponent<TextMeshProUGUI>();
            label.font = sharedFont;
            label.fontSize = fontSize;
            label.color = new Color(0.94f, 0.92f, 0.86f, 1f);
            label.text = text;
            label.alignment = alignment;
            label.textWrappingMode = TextWrappingModes.Normal;
            ContentSizeFitter fitter = labelObject.AddComponent<ContentSizeFitter>();
            fitter.horizontalFit = ContentSizeFitter.FitMode.Unconstrained;
            fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
            return label;
        }

        private TextMeshProUGUI CreateFillLabel(RectTransform parent, string name, string text, float fontSize, TextAlignmentOptions alignment)
        {
            TextMeshProUGUI label = CreateAutoLabel(parent, name, text, fontSize, alignment);
            StretchToParent(label.rectTransform);
            return label;
        }

        private static GameObject CreateUiObject(string name, RectTransform parent)
        {
            GameObject gameObject = new GameObject(name);
            gameObject.transform.SetParent(parent, false);
            return gameObject;
        }

        private static void StretchToParent(RectTransform rectTransform)
        {
            rectTransform.anchorMin = Vector2.zero;
            rectTransform.anchorMax = Vector2.one;
            rectTransform.pivot = new Vector2(0.5f, 0.5f);
            rectTransform.offsetMin = Vector2.zero;
            rectTransform.offsetMax = Vector2.zero;
        }

        private void RefreshAll()
        {
            if (!uiInitialized)
                return;

            UpdatePanelSize();
            NormalizeSelection();
            RefreshSkillSummary();
            RefreshStorageSummary();
            RebuildSkillButtons();
            RebuildSocketButtons();
            RebuildGemButtons();
            RefreshGemDetail();
            RefreshCommandButtons();
        }

        private void NormalizeSelection()
        {
            if (playerSkillInput == null)
            {
                selectedSkillSlotIndex = 0;
                selectedSocketIndex = 0;
                return;
            }

            int slotCount = playerSkillInput.SkillLoadoutEntries != null ? playerSkillInput.SkillLoadoutEntries.Length : 0;
            if (slotCount <= 0)
            {
                selectedSkillSlotIndex = 0;
                selectedSocketIndex = 0;
                return;
            }

            selectedSkillSlotIndex = Mathf.Clamp(selectedSkillSlotIndex, 0, slotCount - 1);

            SkillLoadoutEntry selectedEntry = playerSkillInput.GetSkillLoadout(selectedSkillSlotIndex);
            int socketCount = selectedEntry?.SocketedGems != null ? selectedEntry.SocketedGems.Count : 0;
            if (socketCount <= 0)
            {
                selectedSocketIndex = 0;
            }
            else
            {
                selectedSocketIndex = Mathf.Clamp(selectedSocketIndex, 0, socketCount - 1);
            }

            if (selectedGem != null && FindStorageEntry(selectedGem) == null)
            {
                selectedGem = null;
            }
        }

        private void RefreshSkillSummary()
        {
            if (skillSummaryText == null)
                return;

            if (playerSkillInput == null)
            {
                skillSummaryText.text = "로컬 플레이어를 찾는 중입니다.\n플레이어가 생성되면 스킬과 젬 소켓을 표시합니다.";
                return;
            }

            SkillLoadoutEntry entry = playerSkillInput.GetSkillLoadout(selectedSkillSlotIndex);
            SkillData skill = entry?.BaseSkill;

            if (skill == null)
            {
                skillSummaryText.text = $"{GetSlotDisplayName(selectedSkillSlotIndex)}\n비어 있는 슬롯입니다.";
                return;
            }

            StringBuilder builder = new StringBuilder();
            builder.AppendLine(GetSlotDisplayName(selectedSkillSlotIndex));
            builder.AppendLine($"기반 기술: {skill.SkillName}");
            builder.AppendLine($"분류: {SkillClassificationUtility.GetSkillClassificationLabel(skill)}");
            builder.AppendLine($"젬 슬롯: {skill.MaxGemSlotCount}칸");
            builder.AppendLine($"마나: {entry.GetResolvedManaCost():0.##} | 쿨타임: {entry.GetResolvedCooldown():0.##}초");
            builder.Append($"장착 현황: {BuildSocketSummary(entry)}");
            skillSummaryText.text = builder.ToString();
        }

        private void RefreshStorageSummary()
        {
            if (storageSummaryText == null)
                return;

            int gemTypeCount = 0;
            int totalOwnedCount = 0;
            int totalEquippedCount = 0;

            for (int i = 0; i < ownedGemEntries.Count; i++)
            {
                SkillGemStorageEntry entry = ownedGemEntries[i];
                if (entry == null || entry.Gem == null)
                    continue;

                gemTypeCount++;
                totalOwnedCount += entry.Quantity;
                totalEquippedCount += GetEquippedCount(entry.Gem);
            }

            storageSummaryText.text =
                $"보유 종류: {gemTypeCount}\n" +
                $"총 보유 수량: {totalOwnedCount}\n" +
                $"현재 장착 수량: {totalEquippedCount}";
        }

        private void RebuildSkillButtons()
        {
            if (skillListContent == null)
                return;

            ClearChildren(skillListContent);

            if (playerSkillInput == null)
            {
                CreateListMessage(skillListContent, "플레이어 스킬 정보를 기다리는 중입니다.");
                return;
            }

            int slotCount = playerSkillInput.SkillLoadoutEntries != null ? playerSkillInput.SkillLoadoutEntries.Length : 0;
            for (int i = 0; i < slotCount; i++)
            {
                int capturedIndex = i;
                SkillLoadoutEntry entry = playerSkillInput.GetSkillLoadout(i);
                SkillData skill = entry?.BaseSkill;

                string label =
                    $"{GetSlotDisplayName(i)}\n" +
                    $"{(skill != null ? skill.SkillName : "비어 있음")}\n" +
                    $"장착: {BuildSocketSummary(entry)}";

                Button button = CreateListButton(skillListContent, $"Button_Skill_{i}", label, () =>
                {
                    selectedSkillSlotIndex = capturedIndex;
                    selectedSocketIndex = 0;
                    RefreshAll();
                });

                ApplyButtonState(button, i == selectedSkillSlotIndex, true);
            }
        }

        private void RebuildSocketButtons()
        {
            if (socketListContent == null)
                return;

            ClearChildren(socketListContent);

            if (playerSkillInput == null)
            {
                CreateListMessage(socketListContent, "플레이어가 준비되면 소켓을 표시합니다.");
                return;
            }

            SkillLoadoutEntry entry = playerSkillInput.GetSkillLoadout(selectedSkillSlotIndex);
            SkillData skill = entry?.BaseSkill;
            if (skill == null)
            {
                CreateListMessage(socketListContent, "비어 있는 슬롯입니다.");
                return;
            }

            if (skill.MaxGemSlotCount <= 0)
            {
                CreateListMessage(socketListContent, "이 기술은 젬 슬롯이 없습니다.");
                return;
            }

            for (int i = 0; i < skill.MaxGemSlotCount; i++)
            {
                int capturedIndex = i;
                SkillGemData equippedGem = entry.GetGem(i);
                string label =
                    $"소켓 {i + 1}\n" +
                    $"{(equippedGem != null ? equippedGem.GemName : "비어 있음")}";

                Button button = CreateListButton(socketListContent, $"Button_Socket_{i}", label, () =>
                {
                    selectedSocketIndex = capturedIndex;
                    RefreshAll();
                });

                ApplyButtonState(button, i == selectedSocketIndex, true);
            }
        }

        private void RebuildGemButtons()
        {
            if (gemListContent == null)
                return;

            ClearChildren(gemListContent);

            int createdCount = 0;
            for (int i = 0; i < ownedGemEntries.Count; i++)
            {
                SkillGemStorageEntry entry = ownedGemEntries[i];
                if (entry == null || entry.Gem == null)
                    continue;

                int equippedCount = GetEquippedCount(entry.Gem);
                int remainingCount = Mathf.Max(0, entry.Quantity - equippedCount);
                SkillGemData gem = entry.Gem;
                string label =
                    $"{gem.GemName}\n" +
                    $"효과: {SkillClassificationUtility.GetGemCategoryLabel(gem.Category)} | " +
                    $"장착: {GetGemAllowedSummary(gem)}\n" +
                    $"남은 수량 {remainingCount}/{entry.Quantity}";

                Button button = CreateListButton(gemListContent, $"Button_Gem_{i}", label, () =>
                {
                    selectedGem = gem;
                    RefreshAll();
                });

                ApplyButtonState(button, selectedGem == gem, entry.Quantity > 0);
                createdCount++;
            }

            if (createdCount <= 0)
            {
                CreateListMessage(gemListContent, "보유한 젬이 없습니다.");
            }
        }

        private void RefreshGemDetail()
        {
            if (gemDetailText == null)
                return;

            if (selectedGem == null)
            {
                gemDetailText.text = "보관함에서 젬을 선택하면 설명과 수치 정보를 표시합니다.";
                return;
            }

            SkillGemStorageEntry storageEntry = FindStorageEntry(selectedGem);
            int totalQuantity = storageEntry != null ? storageEntry.Quantity : 0;
            int equippedCount = GetEquippedCount(selectedGem);
            int remainingCount = Mathf.Max(0, totalQuantity - equippedCount);

            StringBuilder builder = new StringBuilder();
            builder.AppendLine(selectedGem.GemName);
            builder.AppendLine($"효과 분류: {SkillClassificationUtility.GetGemCategoryLabel(selectedGem.Category)}");
            builder.AppendLine($"장착 가능: {GetGemAllowedSummary(selectedGem)}");
            builder.AppendLine($"보관: {remainingCount}/{totalQuantity}");

            if (!string.IsNullOrWhiteSpace(selectedGem.Description))
            {
                builder.AppendLine();
                builder.AppendLine(selectedGem.Description);
            }

            builder.AppendLine();
            builder.AppendLine(BuildGemStatSummary(selectedGem));

            string incompatibleSummary = BuildIncompatibleSummary(selectedGem);
            if (!string.IsNullOrEmpty(incompatibleSummary))
            {
                builder.AppendLine();
                builder.AppendLine(incompatibleSummary);
            }

            gemDetailText.text = builder.ToString().TrimEnd();
        }

        private void RefreshCommandButtons()
        {
            if (equipButton == null || unequipButton == null)
                return;

            string equipReason = GetEquipBlockedReason();
            bool canEquip = string.IsNullOrEmpty(equipReason);
            ApplyButtonState(equipButton, false, canEquip);
            ApplyButtonState(unequipButton, false, CanUnequipSelectedSocket());

            if (equipButtonLabel != null)
            {
                equipButtonLabel.text = canEquip ? "선택한 젬 장착" : "장착 불가";
            }

            if (unequipButtonLabel != null)
            {
                unequipButtonLabel.text = CanUnequipSelectedSocket() ? "선택한 젬 탈착" : "탈착할 젬 없음";
            }

            if (playerSkillInput == null)
            {
                SetStatusMessage("로컬 플레이어를 찾는 중입니다.", false);
            }
            else if (isPanelVisible)
            {
                SetStatusMessage(canEquip ? BuildSelectionHint() : equipReason, !canEquip);
            }
        }

        private string BuildSelectionHint()
        {
            SkillLoadoutEntry entry = playerSkillInput != null ? playerSkillInput.GetSkillLoadout(selectedSkillSlotIndex) : null;
            SkillData skill = entry?.BaseSkill;

            if (skill == null)
                return "젬을 장착할 기술 슬롯을 선택하세요.";

            if (selectedGem == null)
                return "보관함에서 장착할 젬을 선택하세요.";

            return $"'{selectedGem.GemName}'을(를) {GetSlotDisplayName(selectedSkillSlotIndex)} 소켓 {selectedSocketIndex + 1}에 장착할 수 있습니다.";
        }

        private void TryEquipSelectedGem()
        {
            string blockedReason = GetEquipBlockedReason();
            if (!string.IsNullOrEmpty(blockedReason))
            {
                SetStatusMessage(blockedReason, true);
                RefreshAll();
                return;
            }

            playerSkillInput.SetSkillGem(selectedSkillSlotIndex, selectedSocketIndex, selectedGem);
            SetStatusMessage($"'{selectedGem.GemName}' 장착 완료", false);
            RefreshAll();
        }

        private void TryUnequipSelectedGem()
        {
            if (playerSkillInput == null)
            {
                SetStatusMessage("로컬 플레이어를 찾지 못했습니다.", true);
                return;
            }

            SkillLoadoutEntry entry = playerSkillInput.GetSkillLoadout(selectedSkillSlotIndex);
            SkillGemData equippedGem = entry?.GetGem(selectedSocketIndex);
            if (equippedGem == null)
            {
                SetStatusMessage("선택한 소켓에 장착된 젬이 없습니다.", true);
                RefreshAll();
                return;
            }

            playerSkillInput.SetSkillGem(selectedSkillSlotIndex, selectedSocketIndex, null);
            SetStatusMessage($"'{equippedGem.GemName}' 탈착 완료", false);
            RefreshAll();
        }

        private bool CanUnequipSelectedSocket()
        {
            if (playerSkillInput == null)
                return false;

            SkillLoadoutEntry entry = playerSkillInput.GetSkillLoadout(selectedSkillSlotIndex);
            return entry?.GetGem(selectedSocketIndex) != null;
        }

        private string GetEquipBlockedReason()
        {
            if (playerSkillInput == null)
                return "로컬 플레이어를 찾는 중입니다.";

            SkillLoadoutEntry entry = playerSkillInput.GetSkillLoadout(selectedSkillSlotIndex);
            SkillData skill = entry?.BaseSkill;
            if (skill == null)
                return "비어 있는 슬롯에는 젬을 장착할 수 없습니다.";

            if (skill.MaxGemSlotCount <= 0)
                return "이 기술은 젬 슬롯이 없습니다.";

            if (selectedSocketIndex < 0 || selectedSocketIndex >= skill.MaxGemSlotCount)
                return "유효한 소켓을 선택하세요.";

            if (selectedGem == null)
                return "보관함에서 장착할 젬을 선택하세요.";

            SkillGemStorageEntry storageEntry = FindStorageEntry(selectedGem);
            if (storageEntry == null || storageEntry.Quantity <= 0)
                return "선택한 젬이 보관함에 없습니다.";

            SkillGemData currentGem = entry.GetGem(selectedSocketIndex);
            if (currentGem == selectedGem)
                return "이미 같은 젬이 장착되어 있습니다.";

            int remainingCount = storageEntry.Quantity - GetEquippedCount(selectedGem);
            if (remainingCount <= 0)
                return "보유한 수량을 모두 장착했습니다.";

            SkillLoadoutEntry validationCopy = entry.CreateCopy();
            if (!validationCopy.TrySetGem(selectedSocketIndex, selectedGem, out string reason))
                return reason;

            return string.Empty;
        }

        private SkillGemStorageEntry FindStorageEntry(SkillGemData gem)
        {
            if (gem == null)
                return null;

            for (int i = 0; i < ownedGemEntries.Count; i++)
            {
                SkillGemStorageEntry entry = ownedGemEntries[i];
                if (entry != null && entry.Gem == gem)
                    return entry;
            }

            return null;
        }

        private int GetEquippedCount(SkillGemData gem)
        {
            if (gem == null || playerSkillInput == null || playerSkillInput.SkillLoadoutEntries == null)
                return 0;

            int count = 0;
            for (int slotIndex = 0; slotIndex < playerSkillInput.SkillLoadoutEntries.Length; slotIndex++)
            {
                SkillLoadoutEntry entry = playerSkillInput.GetSkillLoadout(slotIndex);
                if (entry?.SocketedGems == null)
                    continue;

                for (int socketIndex = 0; socketIndex < entry.SocketedGems.Count; socketIndex++)
                {
                    if (entry.GetGem(socketIndex) == gem)
                    {
                        count++;
                    }
                }
            }

            return count;
        }

        private static string BuildSocketSummary(SkillLoadoutEntry entry)
        {
            if (entry == null || entry.SocketedGems == null || entry.SocketedGems.Count == 0)
                return "없음";

            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < entry.SocketedGems.Count; i++)
            {
                SkillGemData gem = entry.GetGem(i);
                if (i > 0)
                    builder.Append(", ");

                builder.Append(gem != null ? gem.GemName : "비어 있음");
            }

            return builder.ToString();
        }

        private static string BuildGemStatSummary(SkillGemData gem)
        {
            List<string> lines = new List<string>();

            if (!Mathf.Approximately(gem.ManaCostMultiplier, 1f))
                lines.Add($"마나 비용 x{gem.ManaCostMultiplier:0.##}");
            if (!Mathf.Approximately(gem.CooldownMultiplier, 1f))
                lines.Add($"쿨타임 x{gem.CooldownMultiplier:0.##}");
            if (!Mathf.Approximately(gem.CastSpeedMultiplier, 1f))
                lines.Add($"시전 속도 x{gem.CastSpeedMultiplier:0.##}");
            if (!Mathf.Approximately(gem.DamageMultiplier, 1f))
                lines.Add($"피해량 x{gem.DamageMultiplier:0.##}");
            if (!Mathf.Approximately(gem.HealMultiplier, 1f))
                lines.Add($"회복량 x{gem.HealMultiplier:0.##}");
            if (!Mathf.Approximately(gem.ShieldMultiplier, 1f))
                lines.Add($"보호막량 x{gem.ShieldMultiplier:0.##}");
            if (!Mathf.Approximately(gem.ThreatMultiplier, 1f))
                lines.Add($"위협량 x{gem.ThreatMultiplier:0.##}");
            if (gem.AdditionalRepeatCount > 0)
                lines.Add($"추가 반복 +{gem.AdditionalRepeatCount}");

            return lines.Count <= 0 ? "추가 수치 보정 없음" : string.Join("\n", lines);
        }

        private static string BuildIncompatibleSummary(SkillGemData gem)
        {
            List<string> entries = new List<string>();

            if (gem.IncompatibleCategories != null && gem.IncompatibleCategories.Count > 0)
            {
                StringBuilder categoryBuilder = new StringBuilder();
                categoryBuilder.Append("함께 장착 불가 분류: ");

                for (int i = 0; i < gem.IncompatibleCategories.Count; i++)
                {
                    if (i > 0)
                categoryBuilder.Append(", ");

                    categoryBuilder.Append(SkillClassificationUtility.GetGemCategoryLabel(gem.IncompatibleCategories[i]));
                }

                entries.Add(categoryBuilder.ToString());
            }

            if (gem.IncompatibleGems != null && gem.IncompatibleGems.Count > 0)
            {
                StringBuilder gemBuilder = new StringBuilder();
                gemBuilder.Append("함께 장착 불가 젬: ");
                bool hasGem = false;

                for (int i = 0; i < gem.IncompatibleGems.Count; i++)
                {
                    if (gem.IncompatibleGems[i] == null)
                        continue;

                    if (hasGem)
                        gemBuilder.Append(", ");

                    gemBuilder.Append(gem.IncompatibleGems[i].GemName);
                    hasGem = true;
                }

                if (hasGem)
                {
                    entries.Add(gemBuilder.ToString());
                }
            }

            return entries.Count > 0 ? string.Join("\n", entries) : string.Empty;
        }

        private static string GetSlotDisplayName(int slotIndex)
        {
            if (slotIndex >= 0 && slotIndex < SlotDisplayNames.Length)
                return SlotDisplayNames[slotIndex];

            return $"기술 {slotIndex + 1}";
        }

        private static string GetGemAllowedSummary(SkillGemData gem)
        {
            if (gem == null)
                return "전체";

            return
                $"{SkillClassificationUtility.GetAllowedRoleSummary(gem.AllowedSkillRoles)}/" +
                $"{SkillClassificationUtility.GetAllowedActivationSummary(gem.AllowedSkillActivationTypes)}";
        }

        private void ApplyButtonState(Button button, bool selected, bool interactable)
        {
            if (button == null)
                return;

            button.interactable = interactable;
            Image image = button.image;
            if (image == null)
                return;

            image.color = !interactable
                ? buttonDisabledColor
                : selected ? buttonSelectedColor : buttonNormalColor;
        }

        private Button CreateListButton(RectTransform parent, string name, string label, Action onClick)
        {
            Button button = CreateButton(parent, name, label, Vector2.zero, onClick, out TextMeshProUGUI textLabel);
            textLabel.alignment = TextAlignmentOptions.Left;
            textLabel.margin = new Vector4(12f, 10f, 12f, 10f);
            LayoutElement layout = button.gameObject.AddComponent<LayoutElement>();
            layout.minHeight = 74f;
            return button;
        }

        private void CreateListMessage(RectTransform parent, string message)
        {
            TextMeshProUGUI label = CreateAutoLabel(parent, "Label_Message", message, 18f, TextAlignmentOptions.TopLeft);
            LayoutElement layout = label.gameObject.AddComponent<LayoutElement>();
            layout.minHeight = 56f;
        }

        private static void ClearChildren(RectTransform parent)
        {
            for (int i = parent.childCount - 1; i >= 0; i--)
            {
                Destroy(parent.GetChild(i).gameObject);
            }
        }

        private void SetStatusMessage(string message, bool isError)
        {
            if (statusText == null)
                return;

            statusText.text = message;
            statusText.color = isError ? statusErrorColor : statusNormalColor;
        }

        #if UNITY_EDITOR
        private void AutoCollectOwnedGemsInEditor()
        {
            if (!autoCollectOwnedGemsInEditor)
                return;

            string searchFolder = string.IsNullOrWhiteSpace(gemSearchFolder) ? DefaultGemSearchFolder : gemSearchFolder.Trim();
            if (!AssetDatabase.IsValidFolder(searchFolder))
                return;

            Dictionary<SkillGemData, int> existingQuantities = new Dictionary<SkillGemData, int>();
            for (int i = 0; i < ownedGemEntries.Count; i++)
            {
                SkillGemStorageEntry entry = ownedGemEntries[i];
                if (entry == null || entry.Gem == null)
                    continue;

                if (!existingQuantities.ContainsKey(entry.Gem))
                {
                    existingQuantities.Add(entry.Gem, entry.Quantity);
                }
            }

            string[] guids = AssetDatabase.FindAssets("t:SkillGemData", new[] { searchFolder });
            Array.Sort(guids, (left, right) =>
            {
                string leftPath = AssetDatabase.GUIDToAssetPath(left);
                string rightPath = AssetDatabase.GUIDToAssetPath(right);
                return string.Compare(leftPath, rightPath, StringComparison.Ordinal);
            });

            ownedGemEntries.Clear();
            for (int i = 0; i < guids.Length; i++)
            {
                string assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
                SkillGemData gem = AssetDatabase.LoadAssetAtPath<SkillGemData>(assetPath);
                if (gem == null)
                    continue;

                SkillGemStorageEntry entry = new SkillGemStorageEntry
                {
                    Gem = gem,
                    Quantity = existingQuantities.TryGetValue(gem, out int quantity) ? quantity : autoCollectedGemQuantity,
                };

                ownedGemEntries.Add(entry);
            }
        }
        #endif
    }
}