test/Assets/PerfectWorld/Scripts/Managers/EC_InventoryUI.cs

using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;

namespace PerfectWorld.Scripts.Managers
{
    public class EC_InventoryUI : MonoBehaviour
    {
        [Header("UI References")]
        [SerializeField] private GridLayoutGroup gridLayoutGroup;
        [SerializeField] private GameObject inventoryButtonPrefab;
        [SerializeField] private Transform inventoryContainer;
        
        [Header("Inventory Settings")]
        [SerializeField] private byte targetPackage = 0; // 0 = PACK_INVENTORY, 1 = PACK_EQUIPMENT, 2 = PACK_TASKINVENTORY
        [SerializeField] private bool autoRefresh = true;
        [SerializeField] private float refreshInterval = 1.0f;
        
        private List<GameObject> inventoryButtons = new List<GameObject>();
        private float lastRefreshTime;
        
        private void Start()
        {
            InitializeUI();
            RefreshInventory();
        }
        
        private void Update()
        {
            if (autoRefresh && Time.time - lastRefreshTime >= refreshInterval)
            {
                RefreshInventory();
            }
        }
        
        private void InitializeUI()
        {
            if (gridLayoutGroup == null)
            {
                Debug.LogError("[InventoryUI] GridLayoutGroup is not assigned!");
                return;
            }
            
            if (inventoryButtonPrefab == null)
            {
                Debug.LogError("[InventoryUI] Inventory Button Prefab is not assigned!");
                return;
            }
            
            if (inventoryContainer == null)
            {
                inventoryContainer = gridLayoutGroup.transform;
            }
        }
        
        public void RefreshInventory()
        {
            lastRefreshTime = Time.time;
            ClearInventoryButtons();
            
            // Get inventory data from EC_Inventory
            var inventoryData = GetInventoryData(targetPackage);
            
            if (inventoryData == null || inventoryData.Count == 0)
            {
                Debug.Log($"[InventoryUI] No items found in package {targetPackage}");
                return;
            }
            
            // Create buttons for each inventory item
            foreach (var item in inventoryData.Values.OrderBy(x => x.Slot))
            {
                CreateInventoryButton(item);
            }
            
            Debug.Log($"[InventoryUI] Refreshed inventory with {inventoryData.Count} items");
        }
        
        private Dictionary<int, InventoryItemData> GetInventoryData(byte package)
        {
            // Access the private _itemsByPackage dictionary from EC_Inventory using reflection
            var inventoryType = typeof(EC_Inventory);
            var itemsByPackageField = inventoryType.GetField("_itemsByPackage", 
                System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
            
            if (itemsByPackageField == null)
            {
                Debug.LogError("[InventoryUI] Could not access _itemsByPackage field from EC_Inventory");
                return new Dictionary<int, InventoryItemData>();
            }
            
            var itemsByPackage = itemsByPackageField.GetValue(null) as Dictionary<byte, Dictionary<int, InventoryItemData>>;
            if (itemsByPackage == null)
            {
                Debug.LogError("[InventoryUI] _itemsByPackage is null");
                return new Dictionary<int, InventoryItemData>();
            }
            
            if (itemsByPackage.TryGetValue(package, out var packageItems))
            {
                return packageItems;
            }
            
            return new Dictionary<int, InventoryItemData>();
        }
        
        private void CreateInventoryButton(InventoryItemData itemData)
        {
            if (inventoryButtonPrefab == null) return;
            
            // Instantiate button
            GameObject buttonObj = Instantiate(inventoryButtonPrefab, inventoryContainer);
            inventoryButtons.Add(buttonObj);
            
            // Get button components
            Button button = buttonObj.GetComponent<Button>();
            if (button == null)
            {
                Debug.LogWarning("[InventoryUI] Button component not found on prefab");
                return;
            }
            
            // Set up button text
            SetupButtonText(buttonObj, itemData);
            
            // Set up button click handler
            button.onClick.RemoveAllListeners();
            button.onClick.AddListener(() => OnInventoryItemClicked(itemData));
            
            // Set up button visual state
            SetupButtonVisual(buttonObj, itemData);
        }
        
        private void SetupButtonText(GameObject buttonObj, InventoryItemData itemData)
        {
            // Try to find Text component (for older UI system)
            Text textComponent = buttonObj.GetComponentInChildren<Text>();
            if (textComponent != null)
            {
                string itemName = EC_IvtrItem.ResolveItemName(itemData.TemplateId);
                string displayText = string.IsNullOrEmpty(itemName) ? 
                    $"Item {itemData.TemplateId}" : itemName;
                
                if (itemData.Count > 1)
                {
                    displayText += $" x{itemData.Count}";
                }
                
                textComponent.text = displayText;
                return;
            }
            
            // Try to find TextMeshProUGUI component (for TextMeshPro)
            var tmpComponent = buttonObj.GetComponentInChildren<TMPro.TextMeshProUGUI>();
            if (tmpComponent != null)
            {
                string itemName = EC_IvtrItem.ResolveItemName(itemData.TemplateId);
                string displayText = string.IsNullOrEmpty(itemName) ? 
                    $"Item {itemData.TemplateId}" : itemName;
                
                if (itemData.Count > 1)
                {
                    displayText += $" x{itemData.Count}";
                }
                
                tmpComponent.text = displayText;
                return;
            }
            
            Debug.LogWarning("[InventoryUI] No text component found on button prefab");
        }
        
        private void SetupButtonVisual(GameObject buttonObj, InventoryItemData itemData)
        {
            // Set button color based on item state or other properties
            Image buttonImage = buttonObj.GetComponent<Image>();
            if (buttonImage != null)
            {
                // You can customize colors based on item properties
                if (itemData.State != 0)
                {
                    buttonImage.color = Color.yellow; // Highlight special state items
                }
                else if (itemData.Count <= 0)
                {
                    buttonImage.color = Color.gray; // Gray out empty items
                }
                else
                {
                    buttonImage.color = Color.white; // Default color
                }
            }
        }
        
        private void OnInventoryItemClicked(InventoryItemData itemData)
        {
            string itemName = EC_IvtrItem.ResolveItemName(itemData.TemplateId);
            Debug.Log($"[InventoryUI] Item clicked: {itemName} (ID: {itemData.TemplateId}, Count: {itemData.Count}, Slot: {itemData.Slot})");
            
            // Add your custom item click logic here
            // For example: show item details, use item, etc.
        }
        
        private void ClearInventoryButtons()
        {
            foreach (GameObject button in inventoryButtons)
            {
                if (button != null)
                {
                    DestroyImmediate(button);
                }
            }
            inventoryButtons.Clear();
        }
        
        public void SetTargetPackage(byte package)
        {
            targetPackage = package;
            RefreshInventory();
        }
        
        public void ToggleAutoRefresh()
        {
            autoRefresh = !autoRefresh;
        }
        
        public void SetRefreshInterval(float interval)
        {
            refreshInterval = Mathf.Max(0.1f, interval);
        }
        
        private void OnDestroy()
        {
            ClearInventoryButtons();
        }
    }
}