using BrewMonster;
using BrewMonster.Common;
using BrewMonster.Network;
using BrewMonster.Scripts;
using BrewMonster.Scripts.UI;
using BrewMonster.Scripts.Task.UI;
using BrewMonster.UI;
using CSNetwork.GPDataType;
using ModelRenderer.Scripts.GameData;
using PerfectWorld.Scripts.Managers;
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;
using BrewMonster.Scripts.UI.Inventory;
using CSNetwork.Protocols.RPCData;

namespace BrewMonster.Scripts.Managers
{
    public class EC_InventoryUI : AUIDialog
    {
       
        [Header("Pack Buttons (assign in Inspector)")]
        [Tooltip("Main slot grid: shows IVTRTYPE_PACK (0) on Item tab and IVTRTYPE_TASKPACK (2) on Task tab.")]
        [SerializeField] private List<Button> inventoryPackButtons = new List<Button>();
        [SerializeField] private List<Button> equipmentPackButtons = new List<Button>(); // byPackage: 1
        [SerializeField] private List<Button> fashionPackButtons = new List<Button>();   // byPackage: 3

        [Header("Inventory tabs — Item vs Task (original PW)")]
        [SerializeField] private Button tabItemButton;
        [SerializeField] private Button tabTaskButton;

        [Header("Detail Panel (assign in Inspector)")]
        [SerializeField] private ItemInfo detailPanelRoot;
        [SerializeField] private Vector2 detailPanelOffset = new Vector2(20f, 0f);
        [SerializeField] private bool hideDetailOnStart = true;
        [SerializeField] private EC_UIUtility.TextOutlet descriptionText;
        [SerializeField] private Button equipButton;
        [SerializeField] private Button dropButton;

        [Header("Stack Split UI (assign in Inspector)")]
        [SerializeField] private GameObject splitPanelRoot;
        [SerializeField] private TMPro.TMP_InputField splitAmountText;
        [SerializeField] private Button splitConfirmButton;
        [SerializeField] private Button splitCloseButton;
        [SerializeField] private Button splitOpenButton;
        [SerializeField] private Button splitIncreaseButton;
        [SerializeField] private Button splitDecreaseButton;
        [SerializeField] private Button splitMaxButton;

        [Header("Stack combine — merge into another stack (C++ inventory drag-merge, assign in Inspector)")]
        [SerializeField] private Button combineStackButton;

        private int _splitAmount = 1;
        private int _splitMaxAmount = 1;

        [Header("Inventory Settings")]
        [SerializeField] private bool autoRefresh = true;
        [SerializeField] private float refreshInterval = 1.0f;
        [SerializeField] private bool showEquipmentDetails = true;

        [Header("Money UI (assign any text fields to mirror money amount)")]
        [SerializeField] private List<UnityEngine.UI.Text> moneyTextsLegacy = new List<UnityEngine.UI.Text>();
        [SerializeField] private List<TMPro.TextMeshProUGUI> moneyTextsTMP = new List<TMPro.TextMeshProUGUI>();

        [Header("Character UI (assign in Inspector)")]
        [SerializeField] private UnityEngine.UI.Text characterNameTextLegacy;
        [SerializeField] private TMPro.TextMeshProUGUI characterNameTextTMP;
        [SerializeField] private UnityEngine.UI.Text characterLevelTextLegacy;
        [SerializeField] private TMPro.TextMeshProUGUI characterLevelTextTMP;

        private float lastRefreshTime;

        // Pending currency cache for when UI is not yet active
        private static bool s_hasPendingMoney;
        private static ulong s_pendingMoneyAmount;
        private static ulong s_pendingMoneyMaxAmount;

        // Flags to prevent log spam for extended description warnings
        // 防止扩展描述警告日志刷屏的标志
        private static bool m_HasLoggedExtDescNull = false;
        private static bool m_HasLoggedExtDescNotInit = false;
        private static bool m_HasLoggedExtDescError = false;

        private InventoryModel model;
        private InventoryView view;

        //// Drag-and-drop state
        //private int draggedItemSourceSlot = -1;
        //private byte draggedItemSourcePackage = 0;
        //[SerializeField] private Image currentDragImage;
        //private bool isDragging = false;

        // === Text Formatting Methods ===

        /// <summary>
        /// Format text for TextMeshPro components with rich text support
        /// </summary>
        /// <param name="text">Raw text with formatting codes</param>
        /// <returns>Formatted text for TextMeshPro</returns>
        private static string FormatForTextMeshPro(string text)
        {
            return EC_Utility.FormatForTextMeshPro(text);
        }

        // Current selected item for equip/unequip operations
        private byte currentSelectedPackage;
        private int currentSelectedSlot;
        private EC_IvtrItem currentSelectedItem;
        private EC_IvtrItem currentSelectedEquipment;

        private const byte PKG_INVENTORY = InventoryConst.IVTRTYPE_PACK;
        private const byte PKG_EQUIPMENT = InventoryConst.IVTRTYPE_EQUIPPACK;
        private const byte PKG_TASK = InventoryConst.IVTRTYPE_TASKPACK;
        private const byte PKG_FASHION = 3; // Trash / fashion box slot in legacy client (GetInventory may not resolve; see host)

        public enum InventoryBagTab
        {
            Item,
            Task,
        }

        private InventoryBagTab _bagTab = InventoryBagTab.Item;

        private void Awake()
        {
            model = new InventoryModel();
            view = new InventoryView();
            WireBagTabButtons();
            WireSplitUI();
            WireCombineUI();

            //if (currentDragImage == null)
            //{
            //    var canvas = GetComponentInParent<Canvas>();
            //    if (canvas == null)
            //    {
            //        canvas = FindAnyObjectByType<Canvas>();
            //    }
            //    var go = new GameObject("DragImage", typeof(RectTransform), typeof(CanvasRenderer), typeof(Image));
            //    go.transform.SetParent(canvas.transform, false);
            //    currentDragImage = go.GetComponent<Image>();
            //    currentDragImage.raycastTarget = false;
            //    currentDragImage.gameObject.SetActive(false);
            //}
        }

        private void Start()
        {
            SetBagTab(InventoryBagTab.Item);
            if (hideDetailOnStart)
            {
                ShowDetailPanel(false);
            }
            ShowSplitPanel(false);
            // Apply any pending currency values captured before the UI became active
            ApplyPendingCurrency();
        }

        private void OnEnable()
        {
            // Ensure cached values are pushed when the UI is enabled
            ApplyPendingCurrency();
            UpdateCharacterInfo();
            ShowDetailPanel(false);
            ShowSplitPanel(false);
            RefreshAll();
            RefreshCharacterModelPreview();
        }

        private void WireSplitUI()
        {
            if (splitOpenButton != null)
            {
                splitOpenButton.onClick.RemoveAllListeners();
                splitOpenButton.onClick.AddListener(OpenSplitPanelForSelection);
            }
            if (splitConfirmButton != null)
            {
                splitConfirmButton.onClick.RemoveAllListeners();
                splitConfirmButton.onClick.AddListener(ConfirmSplit);
            }
            if (splitCloseButton != null)
            {
                splitCloseButton.onClick.RemoveAllListeners();
                splitCloseButton.onClick.AddListener(() => ShowSplitPanel(false));
            }

            if (splitIncreaseButton != null)
            {
                splitIncreaseButton.onClick.RemoveAllListeners();
                splitIncreaseButton.onClick.AddListener(() => SetSplitAmount(_splitAmount + 1));
            }

            if (splitDecreaseButton != null)
            {
                splitDecreaseButton.onClick.RemoveAllListeners();
                splitDecreaseButton.onClick.AddListener(() => SetSplitAmount(_splitAmount - 1));
            }

            if (splitMaxButton != null)
            {
                splitMaxButton.onClick.RemoveAllListeners();
                splitMaxButton.onClick.AddListener(() => SetSplitAmount(_splitMaxAmount));
            }

            if (splitAmountText != null)
            {
                splitAmountText.onValueChanged.RemoveAllListeners();
                splitAmountText.onValueChanged.AddListener(OnSplitAmountInputChanged);
            }
        }

        private void WireCombineUI()
        {
            if (combineStackButton != null)
            {
                combineStackButton.onClick.RemoveAllListeners();
                combineStackButton.onClick.AddListener(() => CombineSelectedStack());
            }
        }

        private void ShowSplitPanel(bool show)
        {
            if (splitPanelRoot != null)
                splitPanelRoot.SetActive(show);
            if (IsSplitCloseButtonOnModal() && splitCloseButton != null)
                splitCloseButton.gameObject.SetActive(show);
        }

        /// <summary>
        /// Call this from your UI (or bind it to a button) to open the split panel for current selection.
        /// </summary>
        public void OpenSplitPanelForSelection()
        {
            if (currentSelectedItem == null || currentSelectedPackage != PKG_INVENTORY)
            {
                Debug.LogWarning("[InventoryUI] OpenSplitPanelForSelection: select an inventory stack first");
                return;
            }

            int total = currentSelectedItem.m_iCount;
            if (total <= 1)
            {
                Debug.LogWarning("[InventoryUI] OpenSplitPanelForSelection: item count <= 1");
                return;
            }

            _splitMaxAmount = Math.Max(1, total - 1);
            _splitAmount = Mathf.Clamp(_splitAmount, 1, _splitMaxAmount);
            UpdateSplitAmountUI();
            ShowSplitPanel(true);
        }

        private void SetSplitAmount(int amount)
        {
            _splitAmount = Mathf.Clamp(amount, 1, Math.Max(1, _splitMaxAmount));
            UpdateSplitAmountUI();
        }

        private void UpdateSplitAmountUI()
        {
            if (splitAmountText != null)
                splitAmountText.SetTextWithoutNotify(_splitAmount.ToString());

            if (splitIncreaseButton != null)
                splitIncreaseButton.interactable = _splitAmount < _splitMaxAmount;
            if (splitDecreaseButton != null)
                splitDecreaseButton.interactable = _splitAmount > 1;
            if (splitMaxButton != null)
                splitMaxButton.interactable = _splitAmount < _splitMaxAmount;
        }

        private void OnSplitAmountInputChanged(string raw)
        {
            if (!int.TryParse(raw, out int v))
                return;

            v = Mathf.Clamp(v, 1, Math.Max(1, _splitMaxAmount));
            if (v == _splitAmount)
                return;

            _splitAmount = v;
            UpdateSplitAmountUI();
        }

        private void ConfirmSplit()
        {
            int amount = _splitAmount;
            if (amount <= 0) return;
            if (SeparateSelectedStack(amount))
            {
                ShowSplitPanel(false);
            }
        }

        private void WireBagTabButtons()
        {
            if (tabItemButton != null)
            {
                tabItemButton.onClick.RemoveAllListeners();
                tabItemButton.onClick.AddListener(() => SetBagTab(InventoryBagTab.Item));
            }
            if (tabTaskButton != null)
            {
                tabTaskButton.onClick.RemoveAllListeners();
                tabTaskButton.onClick.AddListener(() => SetBagTab(InventoryBagTab.Task));
            }
        }

        /// <summary>Switches main bag view between normal items (tab 1) and task / quest bag (tab 2), like legacy PW.</summary>
        public void SetBagTab(InventoryBagTab tab)
        {
            _bagTab = tab;
            ShowDetailPanel(false);
            RefreshAll();
        }

        private void Update()
        {
            if (autoRefresh && Time.time - lastRefreshTime >= refreshInterval)
            {
                RefreshAll();
            }

            UpdateCooldownOverlays();
            HandleDetailPanelDismissInput();
        }

        /// <summary>
        /// Update all cooldown overlays
        /// 更新所有冷却遮罩
        /// </summary>
        public void UpdateCooldownOverlays()
        {
            // Main grid shows either normal pack or task pack depending on tab
            // 更新背包冷却
            byte mainPack = _bagTab == InventoryBagTab.Item ? PKG_INVENTORY : PKG_TASK;
            UpdatePackageCooldowns(inventoryPackButtons, mainPack);
        }

        /// <summary>
        /// Update cooldown overlays for a specific package
        /// 更新特定包裹的冷却遮罩
        /// </summary>
        private void UpdatePackageCooldowns(List<Button> buttons, byte package)
        {
            if (buttons == null)
            {
                return;
            }

            var items = model.GetInventoryData(package);
            if (items == null)
            {
                return;
            }

            for (int slot = 0; slot < buttons.Count; slot++)
            {
                var button = buttons[slot];
                if (button == null)
                    continue;

                // Get item at this slot
                // 获取此槽位的物品
                EC_IvtrItem itemData = null;
                bool hasItem = items.TryGetValue(slot, out itemData) && itemData != null;

                if (hasItem)
                {
                    // Use InventoryView's method to update cooldown
                    // 使用 InventoryView 的方法更新冷却
                    view.UpdateCooldownOverlay(button, itemData);
                }
                else
                {
                    //// Hide overlay for empty slots
                    //// 空槽位隐藏遮罩
                    //view.HideCooldownOverlay(button);
                }
            }
        }

        public void RefreshAll()
        {
            lastRefreshTime = Time.time;

            var invItems = model.GetInventoryData(PKG_INVENTORY);
            var eqpItems = model.GetInventoryData(PKG_EQUIPMENT);
            var fshItems = model.GetInventoryData(PKG_FASHION);
            var taskItems = model.GetInventoryData(PKG_TASK);

            if (_bagTab == InventoryBagTab.Item)
            {
                view.RenderPackage(inventoryPackButtons, invItems, PKG_INVENTORY, OnInventoryButtonClicked, GetDisplayTextForItem);
            }
            else
            {
                view.RenderPackage(inventoryPackButtons, taskItems, PKG_TASK, OnInventoryButtonClicked, GetDisplayTextForItem);
            }
            view.RenderPackage(equipmentPackButtons, eqpItems, PKG_EQUIPMENT, OnInventoryButtonClicked, GetDisplayTextForItem);
            view.RenderPackage(fashionPackButtons, fshItems, PKG_FASHION, OnInventoryButtonClicked, GetDisplayTextForItem);
            UpdateCharacterInfo();
        }

        /// <summary>
        /// Update all configured money text components with the current amount.
        /// Call this when GET_OWN_MONEY arrives.
        /// </summary>
        public void UpdateMoney(ulong amount, ulong maxAmount)
        {
            s_pendingMoneyAmount = amount;
            s_pendingMoneyMaxAmount = maxAmount;
            s_hasPendingMoney = true;
            string text = amount.ToString();
            if (moneyTextsLegacy != null)
            {
                for (int i = 0; i < moneyTextsLegacy.Count; i++)
                {
                    var t = moneyTextsLegacy[i];
                    if (t != null) t.text = text;
                }
            }
            if (moneyTextsTMP != null)
            {
                for (int i = 0; i < moneyTextsTMP.Count; i++)
                {
                    var t = moneyTextsTMP[i];
                    if (t != null) t.text = text;
                    Debug.Log($"[InventoryUI] Updated money text to {t.text} in TextMeshPro component {t?.name}");
                }
            }
        }

        private void UpdateCharacterInfo()
        {
            var host = CECGameRun.Instance?.GetHostPlayer();
            string characterName = string.Empty;
            string characterLevel = string.Empty;

            if (host != null)
            {
                characterName = host.GetName() ?? string.Empty;
                characterLevel = host.GetBasicProps().iLevel.ToString();
            }

            if (characterNameTextLegacy != null)
                characterNameTextLegacy.text = characterName;
            if (characterNameTextTMP != null)
                characterNameTextTMP.text = characterName;
            if (characterLevelTextLegacy != null)
                characterLevelTextLegacy.text = characterLevel;
            if (characterLevelTextTMP != null)
                characterLevelTextTMP.text = characterLevel;
        }

        // Public static entry points to cache values when UI is unavailable
        public static void CacheMoney(ulong amount, ulong maxAmount)
        {
            s_pendingMoneyAmount = amount;
            s_pendingMoneyMaxAmount = maxAmount;
            s_hasPendingMoney = true;
            // If an instance exists (even inactive), push immediately so the value is ready
            var all = Resources.FindObjectsOfTypeAll<EC_InventoryUI>();
            if (all != null)
            {
                for (int i = 0; i < all.Length; i++)
                {
                    var ui = all[i];
                    if (ui != null && ui.gameObject.scene.IsValid())
                    {
                        ui.ApplyPendingCurrency();
                        break;
                    }
                }
            }
        }

        private void ApplyPendingCurrency()
        {
            if (s_hasPendingMoney)
            {
                UpdateMoney(s_pendingMoneyAmount, s_pendingMoneyMaxAmount);
            }
        }

        private void OnInventoryButtonClicked(byte package, int slot)
        {
            UnityGameSession.RequestCheckSecurityPassWd("");
            var data = model.GetInventoryData(package);
            if (data != null && data.TryGetValue(slot, out var itemData))
            {
                // Store current selection for equip/unequip operations
                currentSelectedPackage = package;
                currentSelectedSlot = slot;
                currentSelectedItem = itemData;

                // Create equipment object if this is equipment
                currentSelectedEquipment = CreateEquipmentFromItemData(itemData);

                // Position detail panel near the clicked item button

                FillDetailPanel(package, itemData);
                PositionDetailPanelNearButton(package, slot);
            }
            else
            {
                ShowDetailPanel(false);
            }
        }

        /// <summary>
        /// Create EC_IvtrEquip object from InventoryItemData
        /// </summary>
        private EC_IvtrItem CreateEquipmentFromItemData(EC_IvtrItem itemData)
        {
            if (itemData == null)
                return null;

            var equipment = EC_IvtrItem.CreateItem(itemData.m_tid, itemData.m_expire_date, itemData.m_iCount);
            // Parse item info if available (use Content field)
            if (itemData.Content != null && itemData.Content.Length > 0)
            {
                equipment.SetItemInfo(itemData.Content, itemData.Content.Length);
            }
            return equipment;
        }

        private string GetDisplayTextForItem(int slot, EC_IvtrItem itemData)
        {
            if (itemData == null || itemData.m_iCount <= 0)
            {
                return string.Empty;
            }
            string itemName = EC_IvtrItemUtils.Instance.ResolveItemName(itemData.m_tid);
            string displayText = string.IsNullOrEmpty(itemName) ? $"Item {itemData.m_tid}" : itemName;
            if (itemData.m_iCount > 1)
            {
                displayText += $" x{itemData.m_iCount}";
            }
            return displayText;
        }

        public void ToggleAutoRefresh()
        {
            autoRefresh = !autoRefresh;
        }

        public void SetRefreshInterval(float interval)
        {
            refreshInterval = Mathf.Max(0.1f, interval);
        }

        public void ToggleEquipmentDetails()
        {
            showEquipmentDetails = !showEquipmentDetails;
            if (currentSelectedItem != null)
            {
                FillDetailPanel(currentSelectedPackage, currentSelectedItem);
            }
        }

        public void OnEquipButtonClicked()
        {
            if (currentSelectedItem == null)
            {
                Debug.LogWarning("[InventoryUI] No item selected for operation");
                return;
            }

            if (currentSelectedPackage == PKG_INVENTORY || currentSelectedPackage == PKG_TASK)
            {
                // Check if item is equipment
                if (currentSelectedItem.IsEquipment())
                {
                    // Equipping from inventory
                    EquipItem();
                }
                else
                {
                    // Use item from inventory
                    UseItem();
                }
            }
            else if (currentSelectedPackage == PKG_EQUIPMENT)
            {
                // Unequipping from equipment
                UnequipItem();
            }
            else
            {
                Debug.LogWarning($"[InventoryUI] Operation not supported for package {currentSelectedPackage}");
            }
            detailPanelRoot.gameObject.SetActive(false);
        }

        /// <summary>
        /// Use the currently selected item from inventory
        /// </summary>
        private void UseItem()
        {
            if (currentSelectedItem == null)
            {
                Debug.LogWarning("[InventoryUI] No item selected for use");
                return;
            }

            if (currentSelectedPackage != PKG_INVENTORY && currentSelectedPackage != PKG_TASK)
            {
                Debug.LogWarning("[InventoryUI] Can only use items from inventory or task package");
                return;
            }

            Debug.Log($"[UseItem] Attempting to use item {currentSelectedItem.m_tid} from slot {currentSelectedSlot}");

            // Get host player to call UseItemInPack
            var host = CECGameRun.Instance?.GetHostPlayer();
            if (host == null)
            {
                Debug.LogError("[InventoryUI] Cannot get host player");
                return;
            }

            // Call UseItemInPack with current package and slot
            bool success = host.UseItemInPack(currentSelectedPackage, currentSelectedSlot, true);

            if (success)
            {
                Debug.Log($"[UseItem] Successfully used item {currentSelectedItem.m_tid} from slot {currentSelectedSlot}");

                // Close detail panel after using item
                ShowDetailPanel(false);

                // Refresh inventory to reflect changes
                RefreshAll();

                Debug.Log($"[UseItem] Calling UpdateCooldownOverlays after item use");
                UpdateCooldownOverlays();
            }
            else
            {
                Debug.LogWarning($"[UseItem] Failed to use item {currentSelectedItem.m_tid} from slot {currentSelectedSlot}");
            }
        }

        public void OnDropButtonClicked()
        {
            if (currentSelectedItem == null)
            {
                Debug.LogWarning("[InventoryUI] No item selected for drop operation");
                return;
            }

            if (currentSelectedPackage == PKG_INVENTORY)
            {
                // Dropping from inventory
                DropInventoryItem();
            }
            else if (currentSelectedPackage == PKG_EQUIPMENT)
            {
                // Dropping from equipment
                DropEquipItem();
            }
            else
            {
                Debug.LogWarning($"[InventoryUI] Drop not supported for package {currentSelectedPackage}");
            }
            detailPanelRoot.gameObject.SetActive(false);
        }

        private void EquipItem()
        {
            if (currentSelectedItem == null) return;

            // For equipping, we need to find an empty equipment slot
            // Use the new method that checks for available slots (especially for finger items)
            byte equipLocation = EC_IvtrType.GetAvailableEquipLocationForItem(currentSelectedItem.m_tid);
            if (equipLocation >= (byte)IndexOfIteminEquipmentInventory.SIZE_EQUIPIVTR)
            {
                Debug.LogWarning($"[InventoryUI] Could not determine equip location for item {currentSelectedItem.m_tid}");
                return;
            }

            // Call RequestEquipItemAsync with inventory slot and equip location
            UnityGameSession.RequestEquipItemAsync((byte)currentSelectedSlot, equipLocation, () =>
            {
                Debug.Log($"[InventoryUI] Equip request sent for item {currentSelectedItem.m_tid} from slot {currentSelectedSlot} to equip location {equipLocation}");
                // Refresh inventory after equip
                RefreshAll();
                RefreshCharacterModelPreview();
            });
        }

        private void UnequipItem()
        {
            if (currentSelectedItem == null) return;

            // Find empty slot in PACK_INVENTORY
            int emptySlot = FindEmptyInventorySlot();
            if (emptySlot == -1)
            {
                Debug.LogWarning("[InventoryUI] No empty slots available in inventory for unequipping");
                return;
            }

            // For unequipping, the equip location is the current equipment slot
            // We can use the slot number as the equip location
            byte equipLocation = (byte)currentSelectedSlot;

            // Call RequestEquipItemAsync with empty inventory slot and current equip location
            UnityGameSession.RequestEquipItemAsync((byte)emptySlot, equipLocation, () =>
            {
                Debug.Log($"[InventoryUI] Unequip request sent for item {currentSelectedItem.m_tid} from equip location {equipLocation} to inventory slot {emptySlot}");
                // Refresh inventory after unequip
                RefreshAll();
                RefreshCharacterModelPreview();
            });
        }

        private void DropInventoryItem()
        {
            if (currentSelectedItem == null) return;

            // Call RequestDropIvrtItem with slot index and amount
            UnityGameSession.RequestDropIvrtItem((byte)currentSelectedSlot, 1);
            Debug.Log($"[InventoryUI] Drop request sent for inventory item {currentSelectedItem.m_tid} from slot {currentSelectedSlot} with amount {currentSelectedItem.m_iCount}");

            // Refresh inventory after drop
            RefreshAll();
        }

        private void DropEquipItem()
        {
            if (currentSelectedItem == null) return;

            // Call RequestDropEquipItem with slot index
            UnityGameSession.RequestDropEquipItem((byte)currentSelectedSlot);
            Debug.Log($"[InventoryUI] Drop request sent for equipment item {currentSelectedItem.m_tid} from slot {currentSelectedSlot}");

            // Refresh inventory after drop
            RefreshAll();
            RefreshCharacterModelPreview();
        }

        /// <summary>
        /// Separate part of the currently selected stack into a new empty slot (C2S MOVE_IVTR_ITEM with partial count).
        /// Your UI can call this directly once you've picked the split amount.
        /// </summary>
        public bool SeparateSelectedStack(int splitAmount, int preferredEmptySlot = -1)
        {
            if (currentSelectedItem == null)
            {
                Debug.LogWarning("[InventoryUI] SeparateSelectedStack: no item selected");
                return false;
            }

            // This client-side move command is for the main inventory pack (IVTRTYPE_PACK) like the original client.
            // Task pack / other packs may need different commands depending on server implementation.
            if (currentSelectedPackage != PKG_INVENTORY)
            {
                Debug.LogWarning($"[InventoryUI] SeparateSelectedStack: unsupported package {currentSelectedPackage} (only PKG_INVENTORY supported)");
                return false;
            }

            int total = currentSelectedItem.m_iCount;
            if (total <= 1)
            {
                Debug.LogWarning("[InventoryUI] SeparateSelectedStack: item count <= 1");
                return false;
            }

            if (splitAmount <= 0 || splitAmount >= total)
            {
                Debug.LogWarning($"[InventoryUI] SeparateSelectedStack: invalid splitAmount={splitAmount}, total={total}");
                return false;
            }

            int emptySlot = preferredEmptySlot >= 0 ? preferredEmptySlot : FindEmptySlotInPackage(PKG_INVENTORY);
            if (emptySlot < 0)
            {
                Debug.LogWarning("[InventoryUI] SeparateSelectedStack: no empty slot available");
                return false;
            }

            // Send MOVE_IVTR_ITEM(src, dest, count). When dest is empty and count < stack, server will split.
            UnityGameSession.RequestMoveIvtrItem((byte)currentSelectedSlot, (byte)emptySlot, (uint)splitAmount);

            // UI will update when S2C item operation arrives; this is a best-effort immediate refresh for responsiveness.
            RefreshAll();
            return true;
        }

        /// <summary>
        /// Merge from the selected slot into another stack of the same template (C++ <c>CDlgInventory::ExchangeItem</c>
        /// branch that calls <c>c2s_CmdMoveIvtrItem</c> when dest matches and pile limit allows).
        /// Picks the lowest-index compatible destination with free stack space.
        /// </summary>
        public bool CombineSelectedStack()
        {
            if (currentSelectedItem == null)
            {
                Debug.LogWarning("[InventoryUI] CombineSelectedStack: no item selected");
                return false;
            }

            if (currentSelectedPackage != PKG_INVENTORY)
            {
                Debug.LogWarning($"[InventoryUI] CombineSelectedStack: unsupported package {currentSelectedPackage} (only PKG_INVENTORY supported)");
                return false;
            }

            if (!TryGetInventoryMergeTarget(currentSelectedSlot, currentSelectedItem, out int dstSlot, out int moveAmount))
            {
                Debug.LogWarning("[InventoryUI] CombineSelectedStack: no merge target with free stack space");
                return false;
            }

            UnityGameSession.RequestMoveIvtrItem((byte)currentSelectedSlot, (byte)dstSlot, (uint)moveAmount);
            RefreshAll();
            return true;
        }

        /// <summary>
        /// Pile cap for stacking: instance <see cref="EC_IvtrItem.m_iPileLimit"/> (from essence <c>pile_num_max</c>) is authoritative;
        /// <see cref="EC_IvtrItem.GetPileLimit"/> may still be 1 if element reflection misses field names.
        /// </summary>
        private static int GetEffectivePileLimitForStack(int tid, EC_IvtrItem a, EC_IvtrItem b)
        {
            int p = Math.Max(1, EC_IvtrItem.GetPileLimit(tid));
            if (a != null)
                p = Math.Max(p, Math.Max(1, a.GetPileLimitInstance()));
            if (b != null)
                p = Math.Max(p, Math.Max(1, b.GetPileLimitInstance()));
            return p;
        }

        /// <summary>First eligible slot (lowest index) that can accept part or all of <paramref name="srcItem"/>.</summary>
        private static bool TryGetInventoryMergeTarget(int srcSlot, EC_IvtrItem srcItem, out int dstSlot, out int moveAmount)
        {
            dstSlot = -1;
            moveAmount = 0;
            if (srcItem == null || srcItem.IsFrozen())
                return false;

            int tid = srcItem.GetTemplateID();
            int srcCount = srcItem.GetCount();
            if (srcCount < 1)
                return false;

            var host = CECGameRun.Instance?.GetHostPlayer();
            var inv = host?.GetInventory(PKG_INVENTORY);
            if (inv == null)
                return false;

            int size = inv.GetSize();
            for (int i = 0; i < size; i++)
            {
                if (i == srcSlot)
                    continue;

                var dst = inv.GetItem(i, false);
                if (dst == null || dst.IsFrozen())
                    continue;
                if (dst.GetTemplateID() != tid)
                    continue;

                int pile = GetEffectivePileLimitForStack(tid, srcItem, dst);
                if (pile <= 1)
                    continue;

                int room = pile - dst.GetCount();
                if (room <= 0)
                    continue;

                int move = Math.Min(srcCount, room);
                if (move <= 0)
                    continue;

                dstSlot = i;
                moveAmount = move;
                return true;
            }

            return false;
        }

        private int FindEmptySlotInPackage(byte package)
        {
            var host = CECGameRun.Instance?.GetHostPlayer();
            var inv = host?.GetInventory(package);
            if (inv == null) return -1;

            int size = inv.GetSize();
            for (int i = 0; i < size; i++)
            {
                if (inv.GetItem(i, false) == null)
                    return i;
            }
            return -1;
        }


        private int FindEmptyInventorySlot()
        {
            var inventoryData = model.GetInventoryData(PKG_INVENTORY);
            if (inventoryData == null) return -1;

            // Find first empty slot (assuming slots are numbered 0, 1, 2, ...)
            for (int i = 0; i < 100; i++) // Assuming max 100 inventory slots
            {
                if (!inventoryData.ContainsKey(i))
                {
                    return i;
                }
            }
            return -1;
        }

        /// <summary>
        /// Get item description from string table
        /// </summary>
        /// <param name="templateId">Item template ID</param>
        /// <returns>Item description text or null if not found</returns>
        private string GetItemDescription(int templateId)
        {
            try
            {
                // Prefer mapped message id if available
                if (EC_Game.TryGetItemMsg(templateId, out int messageId, out int displayMode))
                {
                    var itemDesc = EC_Game.GetItemDesc();
                    if (itemDesc != null && itemDesc.IsInitialized())
                    {
                        string description = itemDesc.GetWideString(messageId);
                        if (!string.IsNullOrEmpty(description))
                        {
                            return description;
                        }
                    }
                }

                // Fallback: try direct template id
                {
                    var itemDesc = EC_Game.GetItemDesc();
                    if (itemDesc != null && itemDesc.IsInitialized())
                    {
                        string description = itemDesc.GetWideString(templateId);
                        if (!string.IsNullOrEmpty(description))
                            return description;
                    }
                }
            }
            catch (System.Exception ex)
            {
                Debug.LogWarning($"[InventoryUI] Error getting item description for ID {templateId}: {ex.Message}");
            }

            return null;
        }

        /// <summary>
        /// Get extended item description from string table
        /// </summary>
        /// <param name="templateId">Item template ID</param>
        /// <returns>Extended item description text or null if not found</returns>
        private string GetItemExtendedDescription(int templateId)
        {
            try
            {
                // Prefer mapped message id if available
                if (EC_Game.TryGetItemMsg(templateId, out int messageId, out int displayMode))
                {
                    var itemExtDesc = EC_Game.GetItemExtDesc();
                    if (itemExtDesc != null && itemExtDesc.IsInitialized())
                    {
                        string extendedDesc = itemExtDesc.GetWideString(messageId);
                        if (!string.IsNullOrEmpty(extendedDesc))
                        {
                            return extendedDesc;
                        }
                    }
                }

                // Fallback: direct template id
                {
                    var itemExtDesc = EC_Game.GetItemExtDesc();
                    if (itemExtDesc != null && itemExtDesc.IsInitialized())
                    {
                        string extendedDesc = itemExtDesc.GetWideString(templateId);
                        if (!string.IsNullOrEmpty(extendedDesc))
                            return extendedDesc;
                    }
                }
            }
            catch (System.Exception ex)
            {
                Debug.LogWarning($"[InventoryUI] Error getting extended item description for ID {templateId}: {ex.Message}");
            }

            return null;
        }

        /// <summary>
        /// Get user-friendly text for item state
        /// </summary>
        /// <param name="state">Item state value</param>
        /// <returns>Human-readable state text</returns>
        private string GetItemStateText(int state)
        {
            switch (state)
            {
                case 0: return "Normal";
                case 1: return "Equipped";
                case 2: return "Broken";
                case 3: return "Locked";
                default: return $"State: {state}";
            }
        }

        // Equipment indices and resolution helpers moved to EC_IvtrType

        // === MVC: Model ===
        private class InventoryModel
        {
            public Dictionary<int, EC_IvtrItem> GetInventoryData(byte package)
            {
                // Read from host player's per-package CECInventory instance
                var host = CECGameRun.Instance?.GetHostPlayer();
                var inv = host?.GetInventory(package);
                var result = new Dictionary<int, EC_IvtrItem>();
                if (inv == null)
                    return result;

                int size = inv.GetSize();
                for (int i = 0; i < size; i++)
                {
                    var item = inv.GetItem(i, false);
                    if (item != null)
                        result[i] = item;
                }
                return result;
            }
        }

        // === MVC: View ===
        private class InventoryView
        {
            private static readonly Dictionary<Image, Sprite> _defaultSprites = new Dictionary<Image, Sprite>();

            private static readonly Dictionary<Button, Image> _overlayImages = new Dictionary<Button, Image>();

            public void RenderPackage(List<Button> buttons, Dictionary<int, EC_IvtrItem> items, byte package, System.Action<byte, int> onClick, System.Func<int, EC_IvtrItem, string> getDisplayText)
            {
                if (buttons == null)
                {
                    return;
                }

                for (int slot = 0; slot < buttons.Count; slot++)
                {
                    var button = buttons[slot];
                    if (button == null)
                    {
                        continue;
                    }

                    EC_IvtrItem itemData = null;
                    bool hasItem = items != null && items.TryGetValue(slot, out itemData);

                    button.onClick.RemoveAllListeners();
                    int capturedSlot = slot;
                    button.onClick.AddListener(() => onClick(package, capturedSlot));

                    // Update icon and count
                    var image = button.GetComponent<Image>();
                    if (image != null)
                    {
                        // Store default sprite
                        if (!_defaultSprites.ContainsKey(image))
                        {
                            _defaultSprites[image] = image.sprite;
                        }

                        // Set icon sprite based on item
                        if (hasItem && itemData != null && itemData.m_iCount > 0)
                        {
                            var sprite = EC_IvtrItemUtils.Instance.ResolveItemIconSprite(itemData.m_tid);
                            image.sprite = sprite;
                            image.enabled = true;

                            UpdateItemCountText(button, itemData.m_iCount);
                        }
                        else
                        {
                            // Restore default sprite
                            image.sprite = _defaultSprites[image];
                            image.enabled = true;

                            UpdateItemCountText(button, 0);
                        }
                    }

                    // Setup drag-drop events
                    var eventTrigger = button.GetComponent<EventTrigger>();
                    if (eventTrigger == null)
                        eventTrigger = button.gameObject.AddComponent<EventTrigger>();

                    eventTrigger.triggers.RemoveAll(e =>
                        e.eventID == EventTriggerType.BeginDrag ||
                        e.eventID == EventTriggerType.Drag ||
                        e.eventID == EventTriggerType.EndDrag ||
                        e.eventID == EventTriggerType.Drop);

                    void AddEvent(EventTriggerType type, UnityEngine.Events.UnityAction<BaseEventData> action)
                    {
                        var entry = new EventTrigger.Entry { eventID = type };
                        entry.callback.AddListener(action);
                        eventTrigger.triggers.Add(entry);
                    }

                    //AddEvent(EventTriggerType.BeginDrag, (data) => ((EC_InventoryUI)button.GetComponentInParent<EC_InventoryUI>()).OnBeginDrag((PointerEventData)data));
                    //AddEvent(EventTriggerType.Drag, (data) => ((EC_InventoryUI)button.GetComponentInParent<EC_InventoryUI>()).OnDrag((PointerEventData)data));
                    //AddEvent(EventTriggerType.EndDrag, (data) => ((EC_InventoryUI)button.GetComponentInParent<EC_InventoryUI>()).OnEndDrag((PointerEventData)data));
                    //AddEvent(EventTriggerType.Drop, (data) => ((EC_InventoryUI)button.GetComponentInParent<EC_InventoryUI>()).OnDrop((PointerEventData)data));
                }
            }

            /// <summary>
            /// Update cooldown overlay for item
            /// 更新物品冷却遮罩
            /// </summary>
            public void UpdateCooldownOverlay(Button button, EC_IvtrItem itemData)
            {
                if (button == null || itemData == null)
                {
                    return;
                }

                // Find or cache overlay image
                // 查找或缓存遮罩图片
                Image overlay = null;
                if (_overlayImages.TryGetValue(button, out overlay))
                {
                    if (overlay == null)
                    {
                        // Cached but destroyed, remove and search again
                        // 已缓存但被销毁，移除并重新查找
                        _overlayImages.Remove(button);
                    }
                }

                if (overlay == null)
                {
                    // Find image_overlay in button's children
                    // 在按钮子物体中查找 image_overlay
                    var overlayTransform = button.transform.Find("image_overlay");
                    if (overlayTransform != null)
                    {
                        overlay = overlayTransform.GetComponent<Image>();
                        if (overlay != null)
                        {
                            _overlayImages[button] = overlay;
                        }
                        else
                        {

                        }
                    }
                    else
                    {

                    }
                }

                if (overlay == null)
                {
                    return;
                }

                // Get cooldown info from item
                // 从物品获取冷却信息
                int maxCooldown = -1;
                int currentCooldown = itemData.GetCoolTime(out maxCooldown);

                if (currentCooldown > 0)
                {
                    // Show overlay and set fill amount
                    // 显示遮罩并设置填充量
                    overlay.gameObject.SetActive(true);

                    // Calculate fill amount (1 = full cooldown, 0 = ready)
                    // 计算填充量（1=完全冷却，0=就绪）
                    if (maxCooldown > 0)
                    { 
                        float fillAmount = (float)currentCooldown / maxCooldown;
                        overlay.fillAmount = fillAmount;
                    }

                }
                else
                {
                    // Hide overlay when not in cooldown
                    // 不在冷却时隐藏遮罩
                    overlay.gameObject.SetActive(false);
                }
            }

            /// <summary>
            /// Hide cooldown overlay
            /// 隐藏冷却遮罩
            /// </summary>
            public void HideCooldownOverlay(Button button)
            {
                if (button == null)
                    return;

                Image overlay = null;
                if (_overlayImages.TryGetValue(button, out overlay) && overlay != null)
                {
                    overlay.gameObject.SetActive(false);
                }
            }

            /// <summary>
            /// Stack count label under slot buttons: prefabs use <c>text_quatity</c> (typo) or <c>text_quantity</c>; legacy code used <c>text_quality</c>.
            /// Only checks immediate children (Unity <see cref="Transform.Find"/>); deeper layouts fall back to <see cref="Component.GetComponentInChildren{T}"/> below.
            /// </summary>
            private static Transform FindStackCountTextTransform(Transform root)
            {
                if (root == null) return null;
                string[] names = { "text_quality", "text_quatity", "text_quantity" };
                for (int n = 0; n < names.Length; n++)
                {
                    var t = root.Find(names[n]);
                    if (t != null) return t;
                }

                return null;
            }

            /// <summary>
            /// Update or create text component to show item count on the button
            /// </summary>
            /// <param name="button">The inventory button</param>
            /// <param name="count">Item count (0 to hide)</param>
            private void UpdateItemCountText(Button button, int count)
            {
                if (button == null) return;

                TMPro.TextMeshProUGUI tmpText = null;
                Text legacyText = null;

                var textTransform = FindStackCountTextTransform(button.transform);

                if (textTransform != null)
                {
                    tmpText = textTransform.GetComponent<TMPro.TextMeshProUGUI>();
                    legacyText = textTransform.GetComponent<Text>();
                }

                if (tmpText == null && legacyText == null)
                {
                    tmpText = button.GetComponentInChildren<TMPro.TextMeshProUGUI>();
                    if (tmpText == null)
                        legacyText = button.GetComponentInChildren<Text>();
                }

                // Update text
                if (count > 1)
                {
                    string countText = count.ToString();

                    if (tmpText != null)
                    {
                        tmpText.text = countText;
                        tmpText.gameObject.SetActive(true);
                    }
                    else if (legacyText != null)
                    {
                        legacyText.text = countText;
                        legacyText.gameObject.SetActive(true);
                    }
                }
                else
                {
                    // Hide when count <= 1
                    if (tmpText != null)
                    {
                        tmpText.text = "";
                        tmpText.gameObject.SetActive(false);
                    }
                    else if (legacyText != null)
                    {
                        legacyText.text = "";
                        legacyText.gameObject.SetActive(false);
                    }
                }
            }
        }

        // === Detail Panel Helpers ===
        // Note: TextOutlet has been moved to EC_UIUtility for reuse across the codebase

        private void ShowDetailPanel(bool show)
        {
            EC_UIUtility.ShowPanel(detailPanelRoot.gameObject, show);
            if (!show)
            {
                RefreshSplitControlsVisibility(0, null);
                RefreshCombineControlsVisibility(0, null);
            }
        }

        /// <summary>
        /// Split affordance only for main bag stacks (same as <see cref="SeparateSelectedStack"/>).
        /// If <c>splitCloseButton</c> is parented under <c>splitPanelRoot</c>, its visibility follows the modal (not this rule).
        /// </summary>
        private bool IsSplitCloseButtonOnModal()
        {
            return splitPanelRoot != null && splitCloseButton != null &&
                   splitCloseButton.transform.IsChildOf(splitPanelRoot.transform);
        }

        private bool CanShowSplitControls(byte package, EC_IvtrItem item)
        {
            if (item == null)
                return false;
            if (package != PKG_INVENTORY)
                return false;
            int n = item.GetCount();
            if (n < 2 && item.m_iCount >= 2)
                n = item.m_iCount;
            return n >= 2;
        }

        /// <summary>
        /// <c>splitOpenButton</c>: show only when a splittable main-bag stack is selected (detail panel).
        /// <c>splitCloseButton</c>: if it lives on the split modal, show only when modal is open; else same as open (detail-placed cancel).
        /// </summary>
        private void RefreshSplitControlsVisibility(byte package, EC_IvtrItem item)
        {
            bool canSplit = CanShowSplitControls(package, item);

            if (splitOpenButton != null)
                splitOpenButton.gameObject.SetActive(canSplit);

            if (splitCloseButton != null)
            {
                if (IsSplitCloseButtonOnModal())
                    splitCloseButton.gameObject.SetActive(splitPanelRoot != null && splitPanelRoot.activeSelf);
                else
                    splitCloseButton.gameObject.SetActive(canSplit);
            }
        }

        private bool CanShowCombineControls(byte package, EC_IvtrItem item)
        {
            if (item == null || package != PKG_INVENTORY)
                return false;
            return TryGetInventoryMergeTarget(currentSelectedSlot, item, out _, out _);
        }

        private void RefreshCombineControlsVisibility(byte package, EC_IvtrItem item)
        {
            bool canCombine = CanShowCombineControls(package, item);
            if (combineStackButton != null)
                combineStackButton.gameObject.SetActive(canCombine);
        }

        private Button GetButtonForSlot(byte package, int slot)
        {
            List<Button> list = null;
            switch (package)
            {
                case PKG_INVENTORY:
                case PKG_TASK:
                    list = inventoryPackButtons;
                    break;
                case PKG_EQUIPMENT:
                    list = equipmentPackButtons;
                    break;
                case PKG_FASHION:
                    list = fashionPackButtons;
                    break;
            }
            if (list == null || slot < 0 || slot >= list.Count)
            {
                return null;
            }
            return list[slot];
        }

        private void PositionDetailPanelNearButton(byte package, int slot)
        {
            if (detailPanelRoot == null)
            {
                return;
            }
            var panelRect = detailPanelRoot.transform as RectTransform;
            if (panelRect == null)
            {
                return;
            }

            var button = GetButtonForSlot(package, slot);
            if (button == null)
            {
                return;
            }
            var buttonRect = button.transform as RectTransform;
            if (buttonRect == null)
            {
                return;
            }

            // Use the extracted utility function for positioning
            EC_UIUtility.PositionPanelNearButton(panelRect, buttonRect, detailPanelOffset);
        }

        private void FillDetailPanel(byte package, EC_IvtrItem item)
        {
            if (item == null)
            {
                ShowDetailPanel(false);
                return;
            }

            // Get user-friendly name
            string itemName = EC_IvtrItemUtils.Instance.ResolveItemName(item.m_tid);
            // Centralised description:
            //  - For equipment, prefer EC_IvtrEquip description (includes stats, addons, sockets, etc.)
            //  - For other items, use EC_IvtrItem.GetDesc which reads from string tables.
            string fullDesc = null;
            if (showEquipmentDetails && currentSelectedEquipment != null)
            {
                currentSelectedEquipment.SetPriceScale((int)EC_IvtrItem.ScaleType.SCALE_SELL, 1f);
                fullDesc = currentSelectedEquipment.GetDesc(EC_IvtrItem.DescType.DESC_NORMAL, EC_Game.GetGameRun().GetHostPlayer().GetEquipment());
            }
            else
            {
                fullDesc = item.GetDesc(EC_IvtrItem.DescType.DESC_NORMAL, EC_Game.GetGameRun().GetHostPlayer().GetEquipment());
            }

            if (!string.IsNullOrEmpty(fullDesc))
            {
                // Replace C++ style "\r" line separators with real newlines for TMP
                fullDesc = fullDesc.Replace("\\r", "\n");
                descriptionText?.Set(fullDesc);
            }
            else
            {
                // Fallback to legacy string-table description if centralised pipeline returns empty
                string itemDescription = GetItemDescription(item.m_tid);
                descriptionText?.Set(itemDescription ?? "No description available");
            }

            // Get extended description exactly like C++ code: g_pGame->GetItemExtDesc(m_tid)
            // C++ code doesn't check IsInitialized() - it just calls GetWideString() directly
            // 完全按照C++代码获取扩展描述：g_pGame->GetItemExtDesc(m_tid)
            // C++代码不检查IsInitialized() - 它直接调用GetWideString()
          
            // Setup equip and drop buttons
            SetupEquipButton(package, item);
            SetupDropButton(package, item);

            // Show panel first
            // 先显示面板
            ShowDetailPanel(true);
            // After detail root is active so child buttons actually appear (fixes split controls under inactive parents).
            RefreshSplitControlsVisibility(package, item);
            RefreshCombineControlsVisibility(package, item);
            //Refresh the position of the description text. Used for UI logic purpose.
            descriptionText.tmp.gameObject.GetComponent<ItemInfoText>()?.RefreshLayout();
            
        }

        private void SetupEquipButton(byte package, EC_IvtrItem item)
        {
            if (equipButton == null) return;

            // Clear previous listeners
            equipButton.onClick.RemoveAllListeners();
            equipButton.onClick.AddListener(OnEquipButtonClicked);

            // Set button text and visibility based on package
            var buttonText = equipButton.GetComponentInChildren<UnityEngine.UI.Text>();
            if (buttonText == null)
            {
                var tmpText = equipButton.GetComponentInChildren<TMPro.TextMeshProUGUI>();
                if (tmpText != null)
                {
                    if (package == PKG_INVENTORY || package == PKG_TASK)
                    {
                        //if item is @EC_IvtrEquip and is not equipped, show equip button
                        if(item is EC_IvtrEquip)
                        {
                            tmpText.text = "Trang bị";
                            equipButton.gameObject.SetActive(true);
                        }
                        else
                        {
                            tmpText.text = "Sử dụng";
                            equipButton.gameObject.SetActive(true);
                        }
                    }
                    else if (package == PKG_EQUIPMENT)
                    {
                        tmpText.text = "Tháo";
                        equipButton.gameObject.SetActive(true);
                    }
                    else
                    {
                        equipButton.gameObject.SetActive(false);
                    }
                }
            }
            else
            {
                if (package == PKG_INVENTORY || package == PKG_TASK)
                {
                    if(item is EC_IvtrEquip)
                    {
                        buttonText.text = "Trang bị";
                        equipButton.gameObject.SetActive(true);
                    }
                    else
                    {
                        buttonText.text = "Sử dụng";
                        equipButton.gameObject.SetActive(true);
                    }
                }
                else if (package == PKG_EQUIPMENT)
                {
                    buttonText.text = "Tháo";
                    equipButton.gameObject.SetActive(true);
                }
                else
                {
                    equipButton.gameObject.SetActive(false);
                }
            }
        }

        private void SetupDropButton(byte package, EC_IvtrItem item)
        {
            if (dropButton == null) return;

            // Clear previous listeners
            dropButton.onClick.RemoveAllListeners();
            dropButton.onClick.AddListener(OnDropButtonClicked);

            // Set button text and visibility based on package
            var buttonText = dropButton.GetComponentInChildren<UnityEngine.UI.Text>();
            if (buttonText == null)
            {
                var tmpText = dropButton.GetComponentInChildren<TMPro.TextMeshProUGUI>();
                if (tmpText != null)
                {
                    if (package == PKG_INVENTORY || package == PKG_EQUIPMENT)
                    {
                        tmpText.text = "Vứt";
                        dropButton.gameObject.SetActive(true);
                    }
                    else
                    {
                        dropButton.gameObject.SetActive(false);
                    }
                }
            }
            else
            {
                if (package == PKG_INVENTORY || package == PKG_EQUIPMENT)
                {
                    buttonText.text = "Vứt";
                    dropButton.gameObject.SetActive(true);
                }
                else
                {
                    dropButton.gameObject.SetActive(false);
                }
            }
        }

        private void HandleDetailPanelDismissInput()
        {
            if (detailPanelRoot == null || !detailPanelRoot.gameObject.activeSelf)
            {
                return;
            }

            if (!TryGetPointerDownPosition(out Vector2 screenPosition))
            {
                return;
            }

            if (IsPointerOverDetailPanel(screenPosition))
            {
                return;
            }

            ShowDetailPanel(false);
        }

        private bool TryGetPointerDownPosition(out Vector2 screenPosition)
        {
            if (Input.GetMouseButtonDown(0))
            {
                screenPosition = Input.mousePosition;
                return true;
            }

            if (Input.touchCount > 0 && Input.GetTouch(0).phase == TouchPhase.Began)
            {
                screenPosition = Input.GetTouch(0).position;
                return true;
            }

            screenPosition = default;
            return false;
        }

        public void RefreshCharacterModelPreview()
        {
            var preview = PlayerModelPreview.Instance;
            if (preview != null)
            {
                RoleInfo roleInfo = BuildCurrentPreviewRoleInfo();
                if (roleInfo != null)
                {
                    preview.ReloadRoleModel(roleInfo);
                }
            }

            var inventoryPreview = FindFirstObjectByType<InventoryCharacterPreview>();
            if (inventoryPreview != null)
            {
                inventoryPreview.QueueRefresh();
            }
        }

        private RoleInfo BuildCurrentPreviewRoleInfo()
        {
            RoleInfo roleInfo = UnityGameSession.Instance != null ? UnityGameSession.Instance.GetRoleInfo() : null;
            if (roleInfo == null)
                return null;

            RoleInfo snapshot = roleInfo.Clone();
            if (snapshot.equipment == null)
                snapshot.equipment = new List<GRoleInventory>();
            else
                snapshot.equipment.Clear();

            CECHostPlayer host = CECGameRun.Instance?.GetHostPlayer();
            var equipInv = host?.GetInventory(InventoryConst.IVTRTYPE_EQUIPPACK);
            if (equipInv == null)
                return snapshot;

            int size = equipInv.GetSize();
            for (int i = 0; i < size; i++)
            {
                EC_IvtrItem item = equipInv.GetItem(i, false);
                if (item == null)
                    continue;

                snapshot.equipment.Add(new GRoleInventory
                {
                    id = (uint)item.GetTemplateID(),
                    pos = i,
                    count = item.GetCount(),
                    max_count = Math.Max(1, item.GetPileLimitInstance())
                });
            }

            return snapshot;
        }

        private bool IsPointerOverDetailPanel(Vector2 screenPosition)
        {
            var panelRect = detailPanelRoot.transform as RectTransform;
            if (panelRect == null)
            {
                return false;
            }

            var eventSystem = EventSystem.current;
            if (eventSystem != null)
            {
                var pointerData = new PointerEventData(eventSystem)
                {
                    position = screenPosition
                };

                var raycastResults = new List<RaycastResult>();
                eventSystem.RaycastAll(pointerData, raycastResults);

                for (int i = 0; i < raycastResults.Count; i++)
                {
                    var hitTransform = raycastResults[i].gameObject != null ? raycastResults[i].gameObject.transform : null;
                    if (hitTransform != null && (hitTransform == panelRect.transform || hitTransform.IsChildOf(panelRect.transform)))
                    {
                        return true;
                    }
                }
            }

            var canvas = detailPanelRoot.GetComponentInParent<Canvas>();
            Camera uiCamera = null;
            if (canvas != null && canvas.renderMode != RenderMode.ScreenSpaceOverlay)
            {
                uiCamera = canvas.worldCamera;
            }

            return RectTransformUtility.RectangleContainsScreenPoint(panelRect, screenPosition, uiCamera);
        }
        //public void OnBeginDrag(PointerEventData eventData)
        //{
        //    var btn = eventData.pointerDrag?.GetComponent<Button>();
        //    if (btn != null)
        //    {
        //        for (int i = 0; i < inventoryPackButtons.Count; i++)
        //        {
        //            if (btn == inventoryPackButtons[i])
        //            {
        //                var invItems = model.GetInventoryData(PKG_INVENTORY);
        //                if(invItems == null || !invItems.ContainsKey(i))
        //                {
        //                    return;
        //                }

        //                draggedItemSourceSlot = i;
        //                draggedItemSourcePackage = PKG_INVENTORY;

        //                var img = btn.GetComponent<Image>();
        //                if (img != null && currentDragImage != null)
        //                {
        //                    currentDragImage.sprite = img.sprite;
        //                    currentDragImage.SetNativeSize();
        //                    currentDragImage.color = img.color;
        //                    currentDragImage.gameObject.SetActive(true);
        //                    isDragging = true;
        //                }
        //                break;
        //            }
        //        }
        //        for (int i = 0; i < equipmentPackButtons.Count; i++)
        //        {
        //            if (btn == equipmentPackButtons[i])
        //            {
        //                var equipItems = model.GetInventoryData(PKG_EQUIPMENT);
        //                if(equipItems == null || !equipItems.ContainsKey(i))
        //                {
        //                    return;
        //                }

        //                draggedItemSourceSlot = i;
        //                draggedItemSourcePackage = PKG_EQUIPMENT;
        //                var img = btn.GetComponent<Image>();
        //                if (img != null && currentDragImage != null)
        //                {
        //                    currentDragImage.sprite = img.sprite;
        //                    currentDragImage.SetNativeSize();
        //                    currentDragImage.color = img.color;
        //                    currentDragImage.gameObject.SetActive(true);
        //                    isDragging = true;
        //                }
        //                return;
        //            }
        //        }
        //    }
        //}

        //public void OnDrag(PointerEventData eventData)
        //{
        //    if(isDragging && currentDragImage != null)
        //    {
        //        currentDragImage.transform.position = eventData.position;
        //    }
        //}

        //public void OnEndDrag(PointerEventData eventData)
        //{
        //    draggedItemSourceSlot = -1;
        //    draggedItemSourcePackage = 0;
        //    if(currentDragImage != null)
        //    {
        //        currentDragImage.gameObject.SetActive(false);
        //        isDragging = false;
        //    }
        //}

        //public void OnDrop(PointerEventData eventData)
        //{
        //    var btn = eventData.pointerCurrentRaycast.gameObject?.GetComponent<Button>();
        //    if (btn != null && draggedItemSourcePackage == PKG_INVENTORY)
        //    {
        //        for (int i = 0; i < equipmentPackButtons.Count; i++)
        //        {
        //            if (btn == equipmentPackButtons[i])
        //            {
        //                UnityGameSession.RequestEquipItemAsync((byte)draggedItemSourceSlot, (byte)i, () =>
        //                {
        //                    Debug.Log($"[InventoryUI] Drag-drop equip: từ inventory slot {draggedItemSourceSlot} sang equipment slot {i}");
        //                    RefreshAll();
        //                });
        //                break;
        //            }
        //        }
        //    }
        //    else if(btn != null && draggedItemSourcePackage == PKG_EQUIPMENT)
        //    {
        //        for (int i = 0; i < inventoryPackButtons.Count; i++)
        //        {
        //            if (btn == inventoryPackButtons[i])
        //            {
        //                UnityGameSession.RequestEquipItemAsync((byte)i, (byte)draggedItemSourceSlot, () =>
        //                {
        //                    Debug.Log($"[InventoryUI] Drag-drop unequip: từ equipment slot {draggedItemSourceSlot} sang inventory slot {i}");
        //                    RefreshAll();
        //                });
        //                break;
        //            }
        //        }
        //    }
        //    draggedItemSourceSlot = -1;
        //    draggedItemSourcePackage = 0;
        //}

    }
 }