[Header("Options")]
[Range(0, 10)]
[SerializeField] private int _horizontalSlotCount = 8;  // 슬롯 가로 개수
[Range(0, 10)]
[SerializeField] private int _verticalSlotCount = 8;      // 슬롯 세로 개수
[SerializeField] private float _slotMargin = 8f;          // 한 슬롯의 상하좌우 여백
[SerializeField] private float _contentAreaPadding = 20f; // 인벤토리 영역의 내부 여백
[Range(32, 64)]
[SerializeField] private float _slotSize = 64f;      // 각 슬롯의 크기

[Header("Connected Objects")]
[SerializeField] private RectTransform _contentAreaRT; // 슬롯들이 위치할 영역
[SerializeField] private GameObject _slotUiPrefab;     // 슬롯의 원본 프리팹

/// <summary> 지정된 개수만큼 슬롯 영역 내에 슬롯들 동적 생성 </summary>
private void InitSlots()
{
    // 슬롯 프리팹 설정
    _slotUiPrefab.TryGetComponent(out RectTransform slotRect);
    slotRect.sizeDelta = new Vector2(_slotSize, _slotSize);

    _slotUiPrefab.TryGetComponent(out ItemSlotUI itemSlot);
    if (itemSlot == null)
        _slotUiPrefab.AddComponent<ItemSlotUI>();

    _slotUiPrefab.SetActive(false);

    // --
    Vector2 beginPos = new Vector2(_contentAreaPadding, -_contentAreaPadding);
    Vector2 curPos = beginPos;

    _slotUIList = new List<ItemSlotUI>(_verticalSlotCount * _horizontalSlotCount);

    // 슬롯들 동적 생성
    for (int j = 0; j < _verticalSlotCount; j++)
    {
        for (int i = 0; i < _horizontalSlotCount; i++)
        {
            int slotIndex = (_horizontalSlotCount * j) + i;

            var slotRT = CloneSlot();
            slotRT.pivot = new Vector2(0f, 1f); // Left Top
            slotRT.anchoredPosition = curPos;
            slotRT.gameObject.SetActive(true);
            slotRT.gameObject.name = $"Item Slot [{slotIndex}]";

            var slotUI = slotRT.GetComponent<ItemSlotUI>();
            slotUI.SetSlotIndex(slotIndex);
            _slotUIList.Add(slotUI);

            // Next X
            curPos.x += (_slotMargin + _slotSize);
        }

        // Next Line
        curPos.x = beginPos.x;
        curPos.y -= (_slotMargin + _slotSize);
    }

    // 슬롯 프리팹 - 프리팹이 아닌 경우 파괴
    if(_slotUiPrefab.scene.rootCount != 0)
        Destroy(_slotUiPrefab);

    // -- Local Method --
    RectTransform CloneSlot()
    {
        GameObject slotGo = Instantiate(_slotUiPrefab);
        RectTransform rt = slotGo.GetComponent<RectTransform>();
        rt.SetParent(_contentAreaRT);

        return rt;
    }
}

#if UNITY_EDITOR
[SerializeField] private bool __showPreview = false;

[Range(0.01f, 1f)]
[SerializeField] private float __previewAlpha = 0.1f;

private List<GameObject> __previewSlotGoList = new List<GameObject>();
private int __prevSlotCountPerLine;
private int __prevSlotLineCount;
private float __prevSlotSize;
private float __prevSlotMargin;
private float __prevContentPadding;
private float __prevAlpha;
private bool __prevShow = false;
private bool __prevMouseReversed = false;

private void OnValidate()
{
    if (__prevMouseReversed != _mouseReversed)
    {
        __prevMouseReversed = _mouseReversed;
        InvertMouse(_mouseReversed);

        EditorLog($"Mouse Reversed : {_mouseReversed}");
    }

    if (Application.isPlaying) return;

    if (__showPreview && !__prevShow)
    {
        CreateSlots();
    }
    __prevShow = __showPreview;

    if (Unavailable())
    {
        ClearAll();
        return;
    }
    if (CountChanged())
    {
        ClearAll();
        CreateSlots();
        __prevSlotCountPerLine = _horizontalSlotCount;
        __prevSlotLineCount = _verticalSlotCount;
    }
    if (ValueChanged())
    {
        DrawGrid();
        __prevSlotSize = _slotSize;
        __prevSlotMargin = _slotMargin;
        __prevContentPadding = _contentAreaPadding;
    }
    if (AlphaChanged())
    {
        SetImageAlpha();
        __prevAlpha = __previewAlpha;
    }

    bool Unavailable()
    {
        return !__showPreview ||
                _horizontalSlotCount < 1 ||
                _verticalSlotCount < 1 ||
                _slotSize <= 0f ||
                _contentAreaRT == null ||
                _slotUiPrefab == null;
    }
    bool CountChanged()
    {
        return _horizontalSlotCount != __prevSlotCountPerLine ||
                _verticalSlotCount != __prevSlotLineCount;
    }
    bool ValueChanged()
    {
        return _slotSize != __prevSlotSize ||
                _slotMargin != __prevSlotMargin ||
                _contentAreaPadding != __prevContentPadding;
    }
    bool AlphaChanged()
    {
        return __previewAlpha != __prevAlpha;
    }
    void ClearAll()
    {
        foreach (var go in __previewSlotGoList)
        {
            Destroyer.Destroy(go);
        }
        __previewSlotGoList.Clear();
    }
    void CreateSlots()
    {
        int count = _horizontalSlotCount * _verticalSlotCount;
        __previewSlotGoList.Capacity = count;

        // 슬롯의 피벗은 Left Top으로 고정
        RectTransform slotPrefabRT = _slotUiPrefab.GetComponent<RectTransform>();
        slotPrefabRT.pivot = new Vector2(0f, 1f);

        for (int i = 0; i < count; i++)
        {
            GameObject slotGo = Instantiate(_slotUiPrefab);
            slotGo.transform.SetParent(_contentAreaRT.transform);
            slotGo.SetActive(true);
            slotGo.AddComponent<PreviewItemSlot>();

            slotGo.transform.localScale = Vector3.one; // 버그 해결

            HideGameObject(slotGo);

            __previewSlotGoList.Add(slotGo);
        }

        DrawGrid();
        SetImageAlpha();
    }
    void DrawGrid()
    {
        Vector2 beginPos = new Vector2(_contentAreaPadding, -_contentAreaPadding);
        Vector2 curPos = beginPos;

        // Draw Slots
        int index = 0;
        for (int j = 0; j < _verticalSlotCount; j++)
        {
            for (int i = 0; i < _horizontalSlotCount; i++)
            {
                GameObject slotGo = __previewSlotGoList[index++];
                RectTransform slotRT = slotGo.GetComponent<RectTransform>();

                slotRT.anchoredPosition = curPos;
                slotRT.sizeDelta = new Vector2(_slotSize, _slotSize);
                __previewSlotGoList.Add(slotGo);

                // Next X
                curPos.x += (_slotMargin + _slotSize);
            }

            // Next Line
            curPos.x = beginPos.x;
            curPos.y -= (_slotMargin + _slotSize);
        }
    }
    void HideGameObject(GameObject go)
    {
        go.hideFlags = HideFlags.HideAndDontSave;

        Transform tr = go.transform;
        for (int i = 0; i < tr.childCount; i++)
        {
            tr.GetChild(i).gameObject.hideFlags = HideFlags.HideAndDontSave;
        }
    }
    void SetImageAlpha()
    {
        foreach (var go in __previewSlotGoList)
        {
            var images = go.GetComponentsInChildren<Image>();
            foreach (var img in images)
            {
                img.color = new Color(img.color.r, img.color.g, img.color.b, __previewAlpha);
                var outline = img.GetComponent<Outline>();
                if (outline)
                    outline.effectColor = new Color(outline.effectColor.r, outline.effectColor.g, outline.effectColor.b, __previewAlpha);
            }
        }
    }
}

private class PreviewItemSlot : MonoBehaviour { }

[UnityEditor.InitializeOnLoad]
private static class Destroyer
{
    private static Queue<GameObject> targetQueue = new Queue<GameObject>();

    static Destroyer()
    {
        UnityEditor.EditorApplication.update += () =>
        {
            for (int i = 0; targetQueue.Count > 0 && i < 100000; i++)
            {
                var next = targetQueue.Dequeue();
                DestroyImmediate(next);
            }
        };
    }
    public static void Destroy(GameObject go) => targetQueue.Enqueue(go);
}
#endif

public class MovableHeaderUI : MonoBehaviour, IPointerDownHandler, IDragHandler
{
    [SerializeField]
    private Transform _targetTr; // 이동될 UI

    private Vector2 _beginPoint;
    private Vector2 _moveBegin;

    private void Awake()
    {
        // 이동 대상 UI를 지정하지 않은 경우, 자동으로 부모로 초기화
        if(_targetTr == null)
            _targetTr = transform.parent;
    }

    // 드래그 시작 위치 지정
    void IPointerDownHandler.OnPointerDown(PointerEventData eventData)
    {
        _beginPoint = _targetTr.position;
        _moveBegin = eventData.position;
    }

    // 드래그 : 마우스 커서 위치로 이동
    void IDragHandler.OnDrag(PointerEventData eventData)
    {
        _targetTr.position = _beginPoint + (eventData.position - _moveBegin);
    }
}

private GraphicRaycaster _gr;
private PointerEventData _ped;
private List<RaycastResult> _rrList;

private ItemSlotUI _beginDragSlot; // 현재 드래그를 시작한 슬롯
private Transform _beginDragIconTransform; // 해당 슬롯의 아이콘 트랜스폼

private Vector3 _beginDragIconPoint;   // 드래그 시작 시 슬롯의 위치
private Vector3 _beginDragCursorPoint; // 드래그 시작 시 커서의 위치
private int _beginDragSlotSiblingIndex;

private void Update()
{
    _ped.position = Input.mousePosition;

    OnPointerDown();
    OnPointerDrag();
    OnPointerUp();
}

private T RaycastAndGetFirstComponent<T>() where T : Component
{
    _rrList.Clear();

    _gr.Raycast(_ped, _rrList);

    if(_rrList.Count == 0)
        return null;

    return _rrList[0].gameObject.GetComponent<T>();
}

private void OnPointerDown()
{
    // Left Click : Begin Drag
    if (Input.GetMouseButtonDown(0))
    {
        _beginDragSlot = RaycastAndGetFirstComponent<ItemSlotUI>();

        // 아이템을 갖고 있는 슬롯만 해당
        if (_beginDragSlot != null && _beginDragSlot.HasItem)
        {
            // 위치 기억, 참조 등록
            _beginDragIconTransform = _beginDragSlot.IconRect.transform;
            _beginDragIconPoint = _beginDragIconTransform.position;
            _beginDragCursorPoint = Input.mousePosition;

            // 맨 위에 보이기
            _beginDragSlotSiblingIndex = _beginDragSlot.transform.GetSiblingIndex();
            _beginDragSlot.transform.SetAsLastSibling();

            // 해당 슬롯의 하이라이트 이미지를 아이콘보다 뒤에 위치시키기
            _beginDragSlot.SetHighlightOnTop(false);
        }
        else
        {
            _beginDragSlot = null;
        }
    }
}
/// <summary> 드래그하는 도중 </summary>
private void OnPointerDrag()
{
    if(_beginDragSlot == null) return;

    if (Input.GetMouseButton(0))
    {
        // 위치 이동
        _beginDragIconTransform.position =
            _beginDragIconPoint + (Input.mousePosition - _beginDragCursorPoint);
    }
}
/// <summary> 클릭을 뗄 경우 </summary>
private void OnPointerUp()
{
    if (Input.GetMouseButtonUp(0))
    {
        // End Drag
        if (_beginDragSlot != null)
        {
            // 위치 복원
            _beginDragIconTransform.position = _beginDragIconPoint;

            // UI 순서 복원
            _beginDragSlot.transform.SetSiblingIndex(_beginDragSlotSiblingIndex);

            // 드래그 완료 처리
            EndDrag();

            // 참조 제거
            _beginDragSlot = null;
            _beginDragIconTransform = null;
        }
    }
}

[Tooltip("아이템 아이콘 이미지")]
[SerializeField] private Image _iconImage;

[Tooltip("아이템 개수 텍스트")]
[SerializeField] private Text _amountText;

[Tooltip("슬롯이 포커스될 때 나타나는 하이라이트 이미지")]
[SerializeField] private Image _highlightImage;

[Space]
[Tooltip("하이라이트 이미지 알파 값")]
[SerializeField] private float _highlightAlpha = 0.5f;

[Tooltip("하이라이트 소요 시간")]
[SerializeField] private float _highlightFadeDuration = 0.2f;


/// <summary> 슬롯의 인덱스 </summary>
public int Index { get; private set; }

/// <summary> 슬롯이 아이템을 보유하고 있는지 여부 </summary>
public bool HasItem => _iconImage.sprite != null;

/// <summary> 접근 가능한 슬롯인지 여부 </summary>
public bool IsAccessible => _isAccessibleSlot && _isAccessibleItem;

public RectTransform SlotRect => _slotRect;
public RectTransform IconRect => _iconRect;


private InventoryUI _inventoryUI;

private RectTransform _slotRect;
private RectTransform _iconRect;
private RectTransform _highlightRect;

private GameObject _iconGo;
private GameObject _textGo;
private GameObject _highlightGo;

private Image _slotImage;

// 현재 하이라이트 알파값
private float _currentHLAlpha = 0f;

private bool _isAccessibleSlot = true; // 슬롯 접근가능 여부
private bool _isAccessibleItem = true; // 아이템 접근가능 여부

/// <summary> 비활성화된 슬롯의 색상 </summary>
private static readonly Color InaccessibleSlotColor = new Color(0.2f, 0.2f, 0.2f, 0.5f);
/// <summary> 비활성화된 아이콘 색상 </summary>
private static readonly Color InaccessibleIconColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);

private void ShowIcon() => _iconGo.SetActive(true);
private void HideIcon() => _iconGo.SetActive(false);

private void ShowText() => _textGo.SetActive(true);
private void HideText() => _textGo.SetActive(false);

public void SetSlotIndex(int index) => Index = index;

/// <summary> 슬롯 자체의 활성화/비활성화 여부 설정 </summary>
public void SetSlotAccessibleState(bool value)
{
    // 중복 처리는 지양
    if (_isAccessibleSlot == value) return;

    if (value)
    {
        _slotImage.color = Color.black;
    }
    else
    {
        _slotImage.color = InaccessibleSlotColor;
        HideIcon();
        HideText();
    }

    _isAccessibleSlot = value;
}

/// <summary> 아이템 활성화/비활성화 여부 설정 </summary>
public void SetItemAccessibleState(bool value)
{
    if(_isAccessibleItem == value) return;

    if (value)
    {
        _iconImage.color = Color.white;
        _amountText.color = Color.white;
    }
    else
    {
        _iconImage.color  = InaccessibleIconColor;
        _amountText.color = InaccessibleIconColor;
    }

    _isAccessibleItem = value;
}

/// <summary> 다른 슬롯과 아이템 아이콘 교환 </summary>
public void SwapOrMoveIcon(ItemSlotUI other)
{
    if (other == null) return;
    if (other == this) return; // 자기 자신과 교환 불가
    if (!this.IsAccessible) return;
    if (!other.IsAccessible) return;

    var temp = _iconImage.sprite;

    // 1. 대상에 아이템이 있는 경우 : 교환
    if (other.HasItem) SetItem(other._iconImage.sprite);

    // 2. 없는 경우 : 이동
    else RemoveItem();

    other.SetItem(temp);
}

/// <summary> 슬롯에 아이템 등록 </summary>
public void SetItem(Sprite itemSprite)
{
    if (itemSprite != null)
    {
        _iconImage.sprite = itemSprite;
        ShowIcon();
    }
    else
    {
        RemoveItem();
    }
}

/// <summary> 슬롯에서 아이템 제거 </summary>
public void RemoveItem()
{
    _iconImage.sprite = null;
    HideIcon();
    HideText();
}

/// <summary> 아이템 이미지 투명도 설정 </summary>
public void SetIconAlpha(float alpha)
{
    _iconImage.color = new Color(
        _iconImage.color.r, _iconImage.color.g, _iconImage.color.b, alpha
    );
}

/// <summary> 아이템 개수 텍스트 설정(amount가 1 이하일 경우 텍스트 미표시) </summary>
public void SetItemAmount(int amount)
{
    if (HasItem && amount > 1)
        ShowText();
    else
        HideText();

    _amountText.text = amount.ToString();
}

public abstract class ItemData : ScriptableObject
{
    public int ID => _id;
    public string Name => _name;
    public string Tooltip => _tooltip;
    public Sprite IconSprite => _iconSprite;

    [SerializeField] private int      _id;
    [SerializeField] private string   _name;    // 아이템 이름
    [Multiline]
    [SerializeField] private string   _tooltip; // 아이템 설명
    [SerializeField] private Sprite   _iconSprite; // 아이템 아이콘
    [SerializeField] private GameObject _dropItemPrefab; // 바닥에 떨어질 때 생성할 프리팹

    /// <summary> 타입에 맞는 새로운 아이템 생성 </summary>
    public abstract Item CreateItem();
}

/// <summary> 셀 수 있는 아이템 데이터 </summary>
public abstract class CountableItemData : ItemData
{
    public int MaxAmount => _maxAmount;
    [SerializeField] private int _maxAmount = 99;
}

/// <summary> 소비 아이템 정보 </summary>
[CreateAssetMenu(fileName = "Item_Portion_", menuName = "Inventory System/Item Data/Portion", order = 3)]
public class PortionItemData : CountableItemData
{
    /// <summary> 효과량(회복량 등) </summary>
    public float Value => _value;
    [SerializeField] private float _value;
    public override Item CreateItem()
    {
        return new PortionItem(this);
    }
}

public abstract class Item
{
    public ItemData Data { get; private set; }

    public Item(ItemData data) => Data = data;
}

/// <summary> 수량을 셀 수 있는 아이템 </summary>
public abstract class CountableItem : Item
{
    public CountableItemData CountableData { get; private set; }

    /// <summary> 현재 아이템 개수 </summary>
    public int Amount { get; protected set; }

    /// <summary> 하나의 슬롯이 가질 수 있는 최대 개수(기본 99) </summary>
    public int MaxAmount => CountableData.MaxAmount;

    /// <summary> 수량이 가득 찼는지 여부 </summary>
    public bool IsMax => Amount >= CountableData.MaxAmount;

    /// <summary> 개수가 없는지 여부 </summary>
    public bool IsEmpty => Amount <= 0;


    public CountableItem(CountableItemData data, int amount = 1) : base(data)
    {
        CountableData = data;
        SetAmount(amount);
    }

    /// <summary> 개수 지정(범위 제한) </summary>
    public void SetAmount(int amount)
    {
        Amount = Mathf.Clamp(amount, 0, MaxAmount);
    }

    /// <summary> 개수 추가 및 최대치 초과량 반환(초과량 없을 경우 0) </summary>
    public int AddAmountAndGetExcess(int amount)
    {
        int nextAmount = Amount + amount;
        SetAmount(nextAmount);

        return (nextAmount > MaxAmount) ? (nextAmount - MaxAmount) : 0;
    }

    /// <summary> 개수를 나누어 복제 </summary>
    public CountableItem SeperateAndClone(int amount)
    {
        // 수량이 한개 이하일 경우, 복제 불가
        if(Amount <= 1) return null;

        if(amount > Amount - 1)
            amount = Amount - 1;

        Amount -= amount;
        return Clone(amount);
    }

    protected abstract CountableItem Clone(int amount);
}

/// <summary> 수량 아이템 - 포션 아이템 </summary>
public class PortionItem : CountableItem, IUsableItem
{
    public PortionItem(PortionItemData data, int amount = 1) : base(data, amount) { }

    public bool Use()
    {
        // 임시 : 개수 하나 감소
        Amount--;

        return true;
    }

    protected override CountableItem Clone(int amount)
    {
        return new PortionItem(CountableData as PortionItemData, amount);
    }
}

/// <summary> 아이템 수용 한도 </summary>
public int Capacity { get; private set; }

// 초기 수용 한도
[SerializeField, Range(8, 64)]
private int _initalCapacity = 32;

// 최대 수용 한도(아이템 배열 크기)
[SerializeField, Range(8, 64)]
private int _maxCapacity = 64;

[SerializeField]
private InventoryUI _inventoryUI; // 연결된 인벤토리 UI

/// <summary> 아이템 목록 </summary>
[SerializeField]
private Item[] _items;

private void Awake()
{
    _items = new Item[_maxCapacity];
    Capacity = _initalCapacity;
}

private void Start()
{
    UpdateAccessibleStatesAll();
}

/// <summary> 인덱스가 수용 범위 내에 있는지 검사 </summary>
private bool IsValidIndex(int index)
{
    return index >= 0 && index < Capacity;
}

/// <summary> 앞에서부터 비어있는 슬롯 인덱스 탐색 </summary>
private int FindEmptySlotIndex(int startIndex = 0)
{
    for (int i = startIndex; i < Capacity; i++)
        if (_items[i] == null)
            return i;
    return -1;
}


/// <summary> 모든 슬롯 UI에 접근 가능 여부 업데이트 </summary>
public void UpdateAccessibleStatesAll()
{
    _inventoryUI.SetAccessibleSlotRange(Capacity);
}

/// <summary> 해당 슬롯이 아이템을 갖고 있는지 여부 </summary>
public bool HasItem(int index)
{
    return IsValidIndex(index) && _items[index] != null;
}

/// <summary> 해당 슬롯이 셀 수 있는 아이템인지 여부 </summary>
public bool IsCountableItem(int index)
{
    return HasItem(index) && _items[index] is CountableItem;
}

/// <summary>
/// 해당 슬롯의 현재 아이템 개수 리턴
/// <para/> - 잘못된 인덱스 : -1 리턴
/// <para/> - 빈 슬롯 : 0 리턴
/// <para/> - 셀 수 없는 아이템 : 1 리턴
/// </summary>
public int GetCurrentAmount(int index)
{
    if (!IsValidIndex(index)) return -1;
    if (_items[index] == null) return 0;

    CountableItem ci = _items[index] as CountableItem;
    if (ci == null)
        return 1;

    return ci.Amount;
}

/// <summary> 해당 슬롯의 아이템 정보 리턴 </summary>
public ItemData GetItemData(int index)
{
    if (!IsValidIndex(index)) return null;
    if (_items[index] == null) return null;

    return _items[index].Data;
}

/// <summary> 해당 슬롯의 아이템 이름 리턴 </summary>
public string GetItemName(int index)
{
    if (!IsValidIndex(index)) return "";
    if (_items[index] == null) return "";

    return _items[index].Data.Name;
}

/// <summary> 해당하는 인덱스의 슬롯 상태 및 UI 갱신 </summary>
public void UpdateSlot(int index)
{
    if (!IsValidIndex(index)) return;

    Item item = _items[index];

    // 1. 아이템이 슬롯에 존재하는 경우
    if (item != null)
    {
        // 아이콘 등록
        _inventoryUI.SetItemIcon(index, item.Data.IconSprite);

        // 1-1. 셀 수 있는 아이템
        if (item is CountableItem ci)
        {
            // 1-1-1. 수량이 0인 경우, 아이템 제거
            if (ci.IsEmpty)
            {
                _items[index] = null;
                RemoveIcon();
                return;
            }
            // 1-1-2. 수량 텍스트 표시
            else
            {
                _inventoryUI.SetItemAmountText(index, ci.Amount);
            }
        }
        // 1-2. 셀 수 없는 아이템인 경우 수량 텍스트 제거
        else
        {
            _inventoryUI.HideItemAmountText(index);
        }
    }
    // 2. 빈 슬롯인 경우 : 아이콘 제거
    else
    {
        RemoveIcon();
    }

    // 로컬 : 아이콘 제거하기
    void RemoveIcon()
    {
        _inventoryUI.RemoveItem(index);
        _inventoryUI.HideItemAmountText(index); // 수량 텍스트 숨기기
    }
}

private void EndDrag()
{
    ItemSlotUI endDragSlot = RaycastAndGetFirstComponent<ItemSlotUI>();

    if (endDragSlot != null && endDragSlot.IsAccessible)
    {
        TrySwapItems(_beginDragSlot, endDragSlot);
    }
}

/// <summary> 두 슬롯의 아이템 교환 </summary>
private void TrySwapItems(ItemSlotUI from, ItemSlotUI to)
{
    if (from == to)
    {
        return;
    }

    from.SwapOrMoveIcon(to);
    _inventory.Swap(from.Index, to.Index);
}

public void Swap(int indexA, int indexB)
{
    if (!IsValidIndex(indexA)) return;
    if (!IsValidIndex(indexB)) return;

    Item itemA = _items[indexA];
    Item itemB = _items[indexB];

    // 1. 셀 수 있는 아이템이고, 동일한 아이템일 경우
    //    indexA -> indexB로 개수 합치기
    if (itemA != null && itemB != null &&
        itemA.Data == itemB.Data &&
        itemA is CountableItem ciA && itemB is CountableItem ciB)
    {
        int maxAmount = ciB.MaxAmount;
        int sum = ciA.Amount + ciB.Amount;

        if (sum <= maxAmount)
        {
            ciA.SetAmount(0);
            ciB.SetAmount(sum);
        }
        else
        {
            ciA.SetAmount(sum - maxAmount);
            ciB.SetAmount(maxAmount);
        }
    }
    // 2. 일반적인 경우 : 슬롯 교체
    else
    {
        _items[indexA] = itemB;
        _items[indexB] = itemA;
    }

    // 두 슬롯 정보 갱신
    UpdateSlot(indexA, indexB);
}

/// <summary> 인벤토리에 아이템 추가
/// <para/> 넣는 데 실패한 잉여 아이템 개수 리턴
/// <para/> 리턴이 0이면 넣는데 모두 성공했다는 의미
/// </summary>
public int Add(ItemData itemData, int amount = 1)
{
    int index;

    // 1. 수량이 있는 아이템
    if (itemData is CountableItemData ciData)
    {
        bool findNextCountable = true;
        index = -1;

        while (amount > 0)
        {
            // 1-1. 이미 해당 아이템이 인벤토리 내에 존재하고, 개수 여유 있는지 검사
            if (findNextCountable)
            {
                index = FindCountableItemSlotIndex(ciData, index + 1);

                // 개수 여유있는 기존재 슬롯이 더이상 없다고 판단될 경우, 빈 슬롯부터 탐색 시작
                if (index == -1)
                {
                    findNextCountable = false;
                }
                // 기존재 슬롯을 찾은 경우, 양 증가시키고 초과량 존재 시 amount에 초기화
                else
                {
                    CountableItem ci = _items[index] as CountableItem;
                    amount = ci.AddAmountAndGetExcess(amount);

                    UpdateSlot(index);
                }
            }
            // 1-2. 빈 슬롯 탐색
            else
            {
                index = FindEmptySlotIndex(index + 1);

                // 빈 슬롯조차 없는 경우 종료
                if (index == -1)
                {
                    break;
                }
                // 빈 슬롯 발견 시, 슬롯에 아이템 추가 및 잉여량 계산
                else
                {
                    // 새로운 아이템 생성
                    CountableItem ci = ciData.CreateItem() as CountableItem;
                    ci.SetAmount(amount);

                    // 슬롯에 추가
                    _items[index] = ci;

                    // 남은 개수 계산
                    amount = (amount > ciData.MaxAmount) ? (amount - ciData.MaxAmount) : 0;

                    UpdateSlot(index);
                }
            }
        }
    }
    // 2. 수량이 없는 아이템
    else
    {
        // 2-1. 1개만 넣는 경우, 간단히 수행
        if (amount == 1)
        {
            index = FindEmptySlotIndex();
            if (index != -1)
            {
                // 아이템을 생성하여 슬롯에 추가
                _items[index] = itemData.CreateItem();
                amount = 0;

                UpdateSlot(index);
            }
        }

        // 2-2. 2개 이상의 수량 없는 아이템을 동시에 추가하는 경우
        index = -1;
        for (; amount > 0; amount--)
        {
            // 아이템 넣은 인덱스의 다음 인덱스부터 슬롯 탐색
            index = FindEmptySlotIndex(index + 1);

            // 다 넣지 못한 경우 루프 종료
            if (index == -1)
            {
                break;
            }

            // 아이템을 생성하여 슬롯에 추가
            _items[index] = itemData.CreateItem();

            UpdateSlot(index);
        }
    }

    return amount;
}

private void EndDrag()
{
    ItemSlotUI endDragSlot = RaycastAndGetFirstComponent<ItemSlotUI>();

    // 아이템 슬롯끼리 아이콘 교환 또는 이동
    if (endDragSlot != null && endDragSlot.IsAccessible)
    {
        TrySwapItems(_beginDragSlot, endDragSlot);
    }

    // 버리기(커서가 UI 레이캐스트 타겟 위에 있지 않은 경우)
    if (!IsOverUI())
    {
        TryRemoveItem(index);
    }
}

/// <summary> UI 및 인벤토리에서 아이템 제거 </summary>
private void TryRemoveItem(int index)
{
    _inventory.Remove(index);
}

private bool IsOverUI()
    => EventSystem.current.IsPointerOverGameObject();

/// <summary> 해당 슬롯의 아이템 제거 </summary>
public void Remove(int index)
{
    if (!IsValidIndex(index)) return;

    _items[index] = null;
    UpdateSlot(index);
}

[Tooltip("슬롯이 포커스될 때 나타나는 하이라이트 이미지")]
[SerializeField] private Image _highlightImage;

[Space]
[Tooltip("하이라이트 이미지 알파 값")]
[SerializeField] private float _highlightAlpha = 0.5f;

[Tooltip("하이라이트 소요 시간")]
[SerializeField] private float _highlightFadeDuration = 0.2f;

// 현재 하이라이트 알파값
private float _currentHLAlpha = 0f;

/// <summary> 슬롯에 하이라이트 표시/해제 </summary>
public void Highlight(bool show)
{
    if (show)
        StartCoroutine(nameof(HighlightFadeInRoutine));
    else
        StartCoroutine(nameof(HighlightFadeOutRoutine));
}

/// <summary> 하이라이트 알파값 서서히 증가 </summary>
private IEnumerator HighlightFadeInRoutine()
{
    StopCoroutine(nameof(HighlightFadeOutRoutine));
    _highlightGo.SetActive(true);

    float unit = _highlightAlpha / _highlightFadeDuration;

    for (; _currentHLAlpha <= _highlightAlpha; _currentHLAlpha += unit * Time.deltaTime)
    {
        _highlightImage.color = new Color(
            _highlightImage.color.r,
            _highlightImage.color.g,
            _highlightImage.color.b,
            _currentHLAlpha
        );

        yield return null;
    }
}

/// <summary> 하이라이트 알파값 0%까지 서서히 감소 </summary>
private IEnumerator HighlightFadeOutRoutine()
{
    StopCoroutine(nameof(HighlightFadeInRoutine));

    float unit = _highlightAlpha / _highlightFadeDuration;

    for (; _currentHLAlpha >= 0f; _currentHLAlpha -= unit * Time.deltaTime)
    {
        _highlightImage.color = new Color(
            _highlightImage.color.r,
            _highlightImage.color.g,
            _highlightImage.color.b,
            _currentHLAlpha
        );

        yield return null;
    }

    _highlightGo.SetActive(false);
}

private ItemSlotUI _pointerOverSlot; // 현재 포인터가 위치한 곳의 슬롯

private void Update()
{
    _ped.position = Input.mousePosition;

    OnPointerEnterAndExit();

    // ...
}

/// <summary> 슬롯에 포인터가 올라가는 경우, 슬롯에서 포인터가 빠져나가는 경우 </summary>
private void OnPointerEnterAndExit()
{
    // 이전 프레임의 슬롯
    var prevSlot = _pointerOverSlot;

    // 현재 프레임의 슬롯
    var curSlot = _pointerOverSlot = RaycastAndGetFirstComponent<ItemSlotUI>();

    if (prevSlot == null)
    {
        // Enter
        if (curSlot != null)
        {
            OnCurrentEnter();
        }
    }
    else
    {
        // Exit
        if (curSlot == null)
        {
            OnPrevExit();
        }

        // Change
        else if (prevSlot != curSlot)
        {
            OnPrevExit();
            OnCurrentEnter();
        }
    }

    // ===================== Local Methods ===============================
    void OnCurrentEnter()
    {
        curSlot.Highlight(true);
    }
    void OnPrevExit()
    {
        prevSlot.Highlight(false);
    }
}

[SerializeField]
private Text _titleText;   // 아이템 이름 텍스트

[SerializeField]
private Text _contentText; // 아이템 설명 텍스트

private RectTransform _rt;
private CanvasScaler _canvasScaler;

private void Awake()
{
    Init();
    Hide();
}

public void Show() => gameObject.SetActive(true);
public void Hide() => gameObject.SetActive(false);

private void Init()
{
    TryGetComponent(out _rt);
    _rt.pivot = new Vector2(0f, 1f); // Left Top
    _canvasScaler = GetComponentInParent<CanvasScaler>();

    DisableAllChildrenRaycastTarget(transform);
}

/// <summary> 모든 자식 UI에 레이캐스트 타겟 해제 </summary>
private void DisableAllChildrenRaycastTarget(Transform tr)
{
    // 본인이 Graphic(UI)를 상속하면 레이캐스트 타겟 해제
    tr.TryGetComponent(out Graphic gr);
    if(gr != null)
        gr.raycastTarget = false;

    // 자식이 없으면 종료
    int childCount = tr.childCount;
    if (childCount == 0) return;

    for (int i = 0; i < childCount; i++)
    {
        DisableAllChildrenRaycastTarget(tr.GetChild(i));
    }
}

/// <summary> 툴팁의 위치 조정 </summary>
public void SetRectPosition(RectTransform slotRect)
{
    // 캔버스 스케일러에 따른 해상도 대응
    float wRatio = Screen.width / _canvasScaler.referenceResolution.x;
    float hRatio = Screen.height / _canvasScaler.referenceResolution.y;
    float ratio =
        wRatio * (1f - _canvasScaler.matchWidthOrHeight) +
        hRatio * (_canvasScaler.matchWidthOrHeight);

    float slotWidth = slotRect.rect.width * ratio;
    float slotHeight = slotRect.rect.height * ratio;

    // 툴팁 초기 위치(슬롯 우하단) 설정
    _rt.position = slotRect.position + new Vector3(slotWidth, -slotHeight);
    Vector2 pos = _rt.position;

    // 툴팁의 크기
    float width = _rt.rect.width * ratio;
    float height = _rt.rect.height * ratio;

    // 우측, 하단이 잘렸는지 여부
    bool rightTruncated = pos.x + width > Screen.width;
    bool bottomTruncated = pos.y - height < 0f;

    ref bool R = ref rightTruncated;
    ref bool B = ref bottomTruncated;

    // 오른쪽만 잘림 => 슬롯의 Left Bottom 방향으로 표시
    if (R && !B)
    {
        _rt.position = new Vector2(pos.x - width - slotWidth, pos.y);
    }
    // 아래쪽만 잘림 => 슬롯의 Right Top 방향으로 표시
    else if (!R && B)
    {
        _rt.position = new Vector2(pos.x, pos.y + height + slotHeight);
    }
    // 모두 잘림 => 슬롯의 Left Top 방향으로 표시
    else if (R && B)
    {
        _rt.position = new Vector2(pos.x - width - slotWidth, pos.y + height + slotHeight);
    }
    // 잘리지 않음 => 슬롯의 Right Bottom 방향으로 표시
    // Do Nothing
}

private void Update()
{
    _ped.position = Input.mousePosition;
    OnPointerEnterAndExit();

    ShowOrHideItemTooltip();

    OnPointerDown();
    OnPointerDrag();
    OnPointerUp();
}

/// <summary> 아이템 정보 툴팁 보여주거나 감추기 </summary>
private void ShowOrHideItemTooltip()
{
    // 마우스가 유효한 아이템 아이콘 위에 올라와 있다면 툴팁 보여주기
    bool isValid =
        _pointerOverSlot != null && _pointerOverSlot.HasItem && _pointerOverSlot.IsAccessible
        && (_pointerOverSlot != _beginDragSlot); // 드래그 시작한 슬롯이면 보여주지 않기

    if (isValid)
    {
        UpdateTooltipUI(_pointerOverSlot);
        _itemTooltip.Show();
    }
    else
        _itemTooltip.Hide();
}

/// <summary> 툴팁 UI의 슬롯 데이터 갱신 </summary>
private void UpdateTooltipUI(ItemSlotUI slot)
{
    // 툴팁 정보 갱신
    _itemTooltip.SetItemInfo(_inventory.GetItemData(slot.Index));

    // 툴팁 위치 조정
    _itemTooltip.SetRectPosition(slot.SlotRect);
}

[Header("Confirmation Popup")]
[SerializeField] private GameObject _confirmationPopupObject;
[SerializeField] private Text   _confirmationItemNameText;
[SerializeField] private Text   _confirmationText;
[SerializeField] private Button _confirmationOkButton;     // Ok
[SerializeField] private Button _confirmationCancelButton; // Cancel

private event Action OnConfirmationOK; // 확인 버튼 누를 경우 실행할 이벤트

private void Awake()
{
    // 1. 확인 버튼 누를 경우 이벤트
    _confirmationOkButton.onClick.AddListener(HidePanel);
    _confirmationOkButton.onClick.AddListener(HideConfirmationPopup);
    _confirmationOkButton.onClick.AddListener(() => OnConfirmationOK?.Invoke());

    // 2. 취소 버튼 누를 경우 이벤트
    _confirmationCancelButton.onClick.AddListener(HidePanel);
    _confirmationCancelButton.onClick.AddListener(HideConfirmationPopup);
}

private void ShowPanel() => gameObject.SetActive(true);
private void HidePanel() => gameObject.SetActive(false);

private void ShowConfirmationPopup(string itemName)
{
    _confirmationItemNameText.text = itemName;
    _confirmationPopupObject.SetActive(true);
}

private void HideConfirmationPopup() => _confirmationPopupObject.SetActive(false);
private void SetConfirmationOKEvent(Action handler) => OnConfirmationOK = handler;

/// <summary> 확인/취소 팝업 띄우기 </summary>
public void OpenConfirmationPopup(Action okCallback, string itemName)
{
    ShowPanel();
    ShowConfirmationPopup(itemName);
    OnConfirmationOK = okCallback;
}

[Header("Amount Input Popup")]
[SerializeField] private GameObject _amountInputPopupObject;
[SerializeField] private Text       _amountInputItemNameText;
[SerializeField] private InputField _amountInputField;
[SerializeField] private Button _amountPlusButton;        // +
[SerializeField] private Button _amountMinusButton;       // -
[SerializeField] private Button _amountInputOkButton;     // Ok
[SerializeField] private Button _amountInputCancelButton; // Cancel

// 확인 버튼 눌렀을 때 동작할 이벤트
private event Action<int> OnAmountInputOK;

// 수량 입력 제한 개수
private int _maxAmount;

private void Awake()
{
    _amountInputOkButton.onClick.AddListener(HidePanel);
    _amountInputOkButton.onClick.AddListener(HideAmountInputPopup);
    _amountInputOkButton.onClick.AddListener(() => OnAmountInputOK?.Invoke(int.Parse(_amountInputField.text)));

    _amountInputCancelButton.onClick.AddListener(HidePanel);
    _amountInputCancelButton.onClick.AddListener(HideAmountInputPopup);

    // [-] 버튼 이벤트
    _amountMinusButton.onClick.AddListener(() =>
    {
        int.TryParse(_amountInputField.text, out int amount);
        if (amount > 1)
        {
            // Shift 누르면 10씩 감소
            int nextAmount = Input.GetKey(KeyCode.LeftShift) ? amount - 10 : amount - 1;
            if(nextAmount < 1)
                nextAmount = 1;
            _amountInputField.text = nextAmount.ToString();
        }
    });

    // [+] 버튼 이벤트
    _amountPlusButton.onClick.AddListener(() =>
    {
        int.TryParse(_amountInputField.text, out int amount);
        if (amount < _maxAmount)
        {
            // Shift 누르면 10씩 증가
            int nextAmount = Input.GetKey(KeyCode.LeftShift) ? amount + 10 : amount + 1;
            if (nextAmount > _maxAmount)
                nextAmount = _maxAmount;
            _amountInputField.text = nextAmount.ToString();
        }
    });

    // 입력 값 범위 제한
    _amountInputField.onValueChanged.AddListener(str =>
    {
        int.TryParse(str, out int amount);
        bool flag = false;

        if (amount < 1)
        {
            flag = true;
            amount = 1;
        }
        else if (amount > _maxAmount)
        {
            flag = true;
            amount = _maxAmount;
        }

        if(flag)
            _amountInputField.text = amount.ToString();
    });
}

/// <summary> 수량 입력 팝업 띄우기 </summary>
public void OpenAmountInputPopup(Action<int> okCallback, int currentAmount, string itemName)
{
    _maxAmount = currentAmount - 1;
    _amountInputField.text = "1";

    ShowPanel();
    ShowAmountInputPopup(itemName);
    OnAmountInputOK = okCallback;
}

private void ShowAmountInputPopup(string itemName)
{
    _amountInputItemNameText.text = itemName;
    _amountInputPopupObject.SetActive(true);
}

private void EndDrag()
{
    ItemSlotUI endDragSlot = RaycastAndGetFirstComponent<ItemSlotUI>();

    // 아이템 슬롯끼리 아이콘 교환 또는 이동
    if (endDragSlot != null && endDragSlot.IsAccessible)
    {
        // 수량 나누기 조건
        // 1) 마우스 클릭 떼는 순간 좌측 Ctrl 또는 Shift 키 유지
        // 2) begin : 셀 수 있는 아이템 / end : 비어있는 슬롯
        // 3) begin 아이템의 수량 > 1
        bool isSeparatable =
            (Input.GetKey(KeyCode.LeftControl) || Input.GetKey(KeyCode.LeftShift)) &&
            (_inventory.IsCountableItem(_beginDragSlot.Index) && !_inventory.HasItem(endDragSlot.Index));

        // true : 수량 나누기, false : 교환 또는 이동
        bool isSeparation = false;
        int currentAmount = 0;

        // 현재 개수 확인
        if (isSeparatable)
        {
            currentAmount = _inventory.GetCurrentAmount(_beginDragSlot.Index);
            if (currentAmount > 1)
            {
                isSeparation = true;
            }
        }

        // 1. 개수 나누기
        if(isSeparation)
            TrySeparateAmount(_beginDragSlot.Index, endDragSlot.Index, currentAmount);
        // 2. 교환 또는 이동
        else
            TrySwapItems(_beginDragSlot, endDragSlot);

        // 툴팁 갱신
        UpdateTooltipUI(endDragSlot);
        return;
    }

    // 버리기(커서가 UI 레이캐스트 타겟 위에 있지 않은 경우)
    if (!IsOverUI())
    {
        int index = _beginDragSlot.Index;
        string itemName = _inventory.GetItemName(index);
        int amount = _inventory.GetCurrentAmount(index);

        // 셀 수 있는 아이템의 경우, 수량 표시
        if(amount > 1)
            itemName += $" x{amount}";

        // 확인 팝업 띄우고 콜백 위임
        _popup.OpenConfirmationPopup(() => TryRemoveItem(index), itemName);
    }
}

/// <summary> UI 및 인벤토리에서 아이템 제거 </summary>
private void TryRemoveItem(int index)
{
    _inventory.Remove(index);
}

/// <summary> 셀 수 있는 아이템 개수 나누기 </summary>
private void TrySeparateAmount(int indexA, int indexB, int amount)
{
    if (indexA == indexB)
    {
        return;
    }
    string itemName = _inventory.GetItemName(indexA);

    _popup.OpenAmountInputPopup(
        amt => _inventory.SeparateAmount(indexA, indexB, amt),
        amount, itemName
    );
}

/// <summary> 셀 수 있는 아이템의 수량 나누기(A -> B 슬롯으로) </summary>
public void SeparateAmount(int indexA, int indexB, int amount)
{
    // amount : 나눌 목표 수량

    if(!IsValidIndex(indexA)) return;
    if(!IsValidIndex(indexB)) return;

    Item _itemA = _items[indexA];
    Item _itemB = _items[indexB];

    CountableItem _ciA = _itemA as CountableItem;

    // 조건 : A 슬롯 - 셀 수 있는 아이템 / B 슬롯 - Null
    // 조건에 맞는 경우, 복제하여 슬롯 B에 추가
    if (_ciA != null && _itemB == null)
    {
        _items[indexB] = _ciA.SeperateAndClone(amount);

        UpdateSlot(indexA, indexB);
    }
}

/// <summary> 업데이트 할 인덱스 목록 </summary>
private HashSet<int> _indexSetForUpdate = new HashSet<int>();

public void TrimAll()
{
    _indexSetForUpdate.Clear();

    int i = -1;
    while (_items[++i] != null) ;
    int j = i;

    while (true)
    {
        while (++j < Capacity && _items[j] == null);

        if (j == Capacity)
            break;

        _indexSetForUpdate.Add(i);
        _indexSetForUpdate.Add(j);

        _items[i] = _items[j];
        _items[j] = null;
        i++;
    }

    foreach (var index in _indexSetForUpdate)
    {
        UpdateSlot(index);
    }
}