XRLib/Assets/Scripts/UVC/UI/List/Tree/TreeListItemDragHandler.cs

#nullable enable
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.UI;

namespace UVC.UI.List.Tree
{
    /// <summary>
    /// TreeListItem의 드래그 & 드롭 입력을 처리하는 컴포넌트입니다.
    /// 
    /// 역할:
    ///   1. 마우스 입력 감지 (클릭, 드래그)
    ///   2. 드래그 시각 피드백 (알파값 변경, 오프셋 이동)
    ///   3. 드롭 대상 판단 (마우스 위치 기반)
    ///   4. 드래그 매니저에 이벤트 전달
    /// 
    /// 구조:
    ///   - PointerDown: 마우스 클릭 감지 → 드래그 시작 준비
    ///   - Drag: 마우스 이동 중 → 드래그 진행, 시각 피드백
    ///   - PointerUp: 마우스 해제 → 드롭 처리
    /// </summary>
    public class TreeListItemDragHandler : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
    {
        /// <summary>
        /// 부모 TreeListItem입니다.
        /// </summary>
        private TreeListItem? treeListItem;

        /// <summary>
        /// 부모 TreeList입니다.
        /// </summary>
        private TreeList? treeList;

        /// <summary>
        /// 드래그 & 드롭 매니저입니다.
        /// </summary>
        private TreeListDragDropManager? dragDropManager;

        private RectTransform? rectTransform;

        /// <summary>
        /// 드래그 중 시각 피드백을 위한 CanvasGroup입니다.
        /// </summary>
        private CanvasGroup? canvasGroup;

        /// <summary>
        /// 드래그 시작 시 원본 알파값입니다.
        /// </summary>
        private float originalAlpha = 1f;

        private Vector2 dragOffset = Vector2.zero;

        /// <summary>
        /// 드래그 중 적용할 알파값입니다.
        /// </summary>
        [SerializeField]
        private float dragAlpha = 0.5f;

        /// <summary>
        /// 드래그 활성화 여부입니다.
        /// </summary>
        [SerializeField]
        private bool enableDragDrop = true;

        /// <summary>
        /// 드롭 위치 표시 막대 프리팹입니다.
        /// </summary>
        private Image? dropIndicator;
        private RectTransform? dropIndicatorRect;

        /// <summary>
        /// 드롭 표시기의 부모 (Content 또는 EntryRoot)
        /// </summary>
        private RectTransform? dropIndicatorParent;

        /// <summary>
        /// 드래그 시작 시 아이템의 원본 부모입니다.
        /// 드래그 후 원래 위치로 복구할 때 사용합니다.
        /// </summary>
        private Transform? originalParent;
        private int originalSiblingIndex;

        private RectTransform? treeListRootParent;

        private void Awake()
        {
            rectTransform = GetComponent<RectTransform>();
            // CanvasGroup 가져오기 (없으면 생성)
            canvasGroup = GetComponent<CanvasGroup>();
            if (canvasGroup == null)
            {
                canvasGroup = gameObject.AddComponent<CanvasGroup>();
            }

            originalAlpha = canvasGroup.alpha;
        }

        public void SetDragDropManager(TreeListItem item, TreeList list, TreeListDragDropManager manager)
        {
            treeListItem = item;
            treeList = list;
            dragDropManager = manager;
            treeListRootParent = list.Root.parent as RectTransform;
            Debug.Log($"[TreeListItemDragHandler] 드래그 핸들러 설정: {item.Data?.Name ?? "Unknown"}");
        }

        /// <summary>
        /// 드래그가 시작될 때 호출됩니다. (IBeginDragHandler)
        /// OnPointerDown 이후 마우스가 약간 움직이면 자동으로 호출됩니다.
        /// </summary>
        public void OnBeginDrag(PointerEventData eventData)
        {
            Debug.Log($"[OnPointerDown]");
            if (!enableDragDrop || treeListItem?.Data == null || dragDropManager == null)
            {
                return;
            }

            // 마우스 버튼이 왼쪽이 아니면 무시
            if (eventData.button != PointerEventData.InputButton.Left)
            {
                return;
            }

            // 드래그 시작 준비: 마우스 위치와 아이템 위치의 오프셋 계산
            RectTransformUtility.ScreenPointToLocalPointInRectangle(
                treeListRootParent,//rectTransform,
                eventData.position,
                null,
                out var localPoint);

            dragOffset = localPoint;

            Debug.Log($"[OnPointerDown] {treeListItem.Data.Name}에 포인터 다운, offset: {dragOffset}");
        }

        /// <summary>
        /// 드래그 중에 마우스가 이동할 때 호출됩니다. (IDragHandler)
        /// </summary>
        public void OnDrag(PointerEventData eventData)
        {
            if (!enableDragDrop || dragDropManager == null || treeListItem?.Data == null || treeList == null || rectTransform == null)
            {
                Debug.LogWarning("[OnDrag] 필수 컴포넌트 누락 또는 비활성화됨");
                return;
            }

            if (eventData.button != PointerEventData.InputButton.Left)
            {
                return;
            }

            Debug.Log($"[OnDrag] {treeListItem.Data.Name} 드래그 중");

            // 드래그 시작 처리 (첫 드래그 프레임)
            if (!dragDropManager.IsDragging)
            {
                dragDropManager.StartDrag(treeListItem.Data);

                // 원본 부모와 위치 저장
                originalParent = rectTransform.parent;
                originalSiblingIndex = rectTransform.GetSiblingIndex();

                // 드래그 중 시각 피드백
                if (canvasGroup != null)
                {
                    canvasGroup.alpha = dragAlpha;
                    canvasGroup.blocksRaycasts = false;
                }

                // 드롭 위치 표시 막대 생성
                CreateDropIndicator();

                Debug.Log($"[OnDrag] {treeListItem.Data.Name} 드래그 시작");
            }

            // 아이템이 마우스를 따라다니도록 위치 업데이트
            //UpdateDragPosition(eventData);

            // 마우스 위의 드롭 대상 찾기
            var targetItem = GetItemAtMousePosition(eventData.position);
            dragDropManager.OnDragOver(targetItem?.Data);

            // 드롭 위치 표시 업데이트
            UpdateDropIndicator(targetItem);
        }

        /// <summary>
        /// 드래그가 종료될 때 호출됩니다. (IEndDragHandler)
        /// 마우스 버튼을 놓으면 자동으로 호출됩니다.
        /// </summary>
        public void OnEndDrag(PointerEventData eventData)
        {
            Debug.Log($"[OnPointerUp]");
            if (!enableDragDrop || dragDropManager == null)
            {
                return;
            }

            Debug.Log($"[OnPointerUp] 드래그 완료");

            // 원본 알파값으로 복구
            if (canvasGroup != null)
            {
                canvasGroup.alpha = originalAlpha;
                canvasGroup.blocksRaycasts = true;
            }

            // 원본 부모로 복구 (드래그 중 이동했던 위치 복구)
            if (originalParent != null)
            {
                rectTransform?.SetParent(originalParent);
                if (rectTransform != null)
                {
                    rectTransform.SetSiblingIndex(originalSiblingIndex);
                }
            }

            // 드롭 위치 표시 막대 숨김
            HideDropIndicator();

            // 드래그가 시작되지 않았으면 무시
            if (!dragDropManager.IsDragging)
            {
                dragDropManager.EndDrag();
                return;
            }

            // 마우스 위치의 대상 아이템 찾기
            var targetItem = GetItemAtMousePosition(eventData.position);


            // 드롭 시도
            if (treeListItem?.Data != null)
            {
                var result = dragDropManager.TryDrop(targetItem?.Data);
                Debug.Log($"[OnPointerUp] 드롭 결과: {(result ? "성공" : "실패")}");

                if (result)
                {
                    // 드롭 성공 → 데이터 동기화
                    HandleDropSuccess(treeListItem.Data, targetItem);
                }
            }

            dragDropManager.EndDrag();
        }

        /// <summary>
        /// 드래그 중 아이템이 마우스를 따라다니도록 위치를 업데이트합니다.
        /// Y축만 이동 (X축은 고정)
        /// </summary>
        private void UpdateDragPosition(PointerEventData eventData)
        {
            if (rectTransform == null || treeList == null)
            {
                return;
            }

            var canvasRect = treeList.GetComponent<RectTransform>();
            if (canvasRect == null)
            {
                return;
            }

            // 스크린 좌표를 캔버스 로컬 좌표로 변환
            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(
                treeListRootParent, //canvasRect,
                eventData.position,
                null,
                out var canvasLocalPoint))
            {
                // ✅ Y축만 업데이트 (X는 고정)
                // 드래그 오프셋을 고려한 Y 위치만 계산
                var currentPosition = rectTransform.anchoredPosition;
                rectTransform.anchoredPosition = new Vector2(
                    currentPosition.x,  // ✅ X는 그대로 유지
                    canvasLocalPoint.y - dragOffset.y  // ✅ Y만 마우스를 따라 이동
                );
            }
        }

        /// <summary>
        /// 드롭 위치 표시 막대를 생성합니다.
        /// </summary>
        private void CreateDropIndicator()
        {
            Debug.Log($"[CreateDropIndicator] dropIndicator != null:{dropIndicator != null}");
            if (dropIndicator != null)
            {
                return;
            }

            //기존에 생성된 DropIndicator가 있는지 확인
            var existingDropIndicator = FindDropIndicatorInRoot();
            if (existingDropIndicator != null)
            {
                // 기존 DropIndicator 사용
                dropIndicator = existingDropIndicator.GetComponent<Image>();
                dropIndicatorRect = existingDropIndicator.GetComponent<RectTransform>();
                dropIndicatorParent = treeListRootParent;

                Debug.Log("[CreateDropIndicator] 기존 DropIndicator를 재사용합니다");
                return;
            }

            // ✅ Root(root)를 부모로 설정
            // 계층 구조: TreeList > ScrollView > Viewport > Content > Root > TreeListItem
            dropIndicatorParent = treeListRootParent;// rectTransform?.parent as RectTransform;

            if (dropIndicatorParent == null)
            {
                Debug.LogError("[CreateDropIndicator] EntryRoot/Content를 찾을 수 없습니다");
                return;
            }


            // 새로운 GameObject 생성
            var indicatorGo = new GameObject("DropIndicator");
            indicatorGo.transform.SetParent(dropIndicatorParent, false);

            // Image 컴포넌트 추가
            dropIndicator = indicatorGo.AddComponent<Image>();
            dropIndicator.color = new Color(0.2f, 0.8f, 1f, 0.5f); // 반투명 파란색

            // RectTransform 설정
            dropIndicatorRect = indicatorGo.GetComponent<RectTransform>();
            if (dropIndicatorRect != null)
            {
                dropIndicatorRect.anchorMin = new Vector2(0, 1f);
                dropIndicatorRect.anchorMax = new Vector2(1, 1f);
                dropIndicatorRect.pivot = new Vector2(0, 1f);
                dropIndicatorRect.sizeDelta = new Vector2(0, 2f); // 높이 3
            }

            dropIndicator.raycastTarget = false;
            indicatorGo.SetActive(false);

            Debug.Log("[CreateDropIndicator] 드롭 위치 표시 막대 생성됨");
        }

        /// <summary>
        /// 드롭 위치 표시 막대를 업데이트합니다.
        /// VerticalLayoutGroup 환경에서도 정확하게 위치를 계산합니다.
        /// </summary>
        private void UpdateDropIndicator(TreeListItem? targetItem)
        {
            if (dropIndicator == null || dropIndicatorRect == null || dropIndicatorParent == null)
            {
                return;
            }

            if (targetItem == null)
            {
                dropIndicator.gameObject.SetActive(false);
                return;
            }

            // 드롭 위치 판단
            var targetRect = targetItem.GetComponent<RectTransform>();
            if (targetRect == null)
            {
                dropIndicator.gameObject.SetActive(false);
                return;
            }

            var dropPosition = GetDropPosition(targetRect);

            dropIndicator.gameObject.SetActive(true);

            // ✅ 핵심: 월드 좌표로 변환해서 부모 기준 로컬 좌표 계산
            Vector3[] targetCorners = new Vector3[4];
            targetRect.GetWorldCorners(targetCorners);

            // 🎯 아이템의 월드 X 좌표 (왼쪽 끝)
            float targetWorldX = targetCorners[0].x;

            // 아이템의 월드 Y 좌표
            float targetWorldY = targetCorners[0].y;

            // 부모(Root)의 월드 좌표
            Vector3[] parentCorners = new Vector3[4];
            dropIndicatorParent.GetWorldCorners(parentCorners);
            float parentWorldY = parentCorners[0].y;
            float parentWorldX = parentCorners[0].x;
            float parentHeight = parentCorners[1].y - parentCorners[0].y;
            float parentWidth = parentCorners[3].x - parentCorners[0].x;

            // 🎯 월드 X를 부모 기준 로컬 X로 변환
            float relativeX = targetWorldX - parentWorldX;

            // 월드 Y를 부모 기준 로컬 Y로 변환
            float relativeY = targetWorldY - parentWorldY;

            // 🎯 부모의 pivot을 고려한 로컬 X 계산
            float pivotAdjustedX = relativeX - (parentWidth * dropIndicatorParent.pivot.x);

            // 부모의 pivot을 고려한 로컬 Y 계산
            float pivotAdjustedY = relativeY - (parentHeight * dropIndicatorParent.pivot.y) + targetRect.rect.height / 2;

            float indicatorX = 0;
            float indicatorY = 0;
            float indicatorHeight = 3f;  // 기본 높이

            switch (dropPosition)
            {
                case DropPosition.Above:
                    // 대상 아이템 위 (아이템 높이의 절반)
                    indicatorX = pivotAdjustedX;
                    indicatorY = pivotAdjustedY + (targetRect.rect.height / 2);
                    indicatorHeight = 2f;  // 얇은 선
                    break;

                case DropPosition.Below:
                    // 대상 아이템 아래
                    indicatorX = pivotAdjustedX;
                    indicatorY = pivotAdjustedY - (targetRect.rect.height / 2);
                    indicatorHeight = 2f;  // 얇은 선
                    break;

                case DropPosition.InsideAsChild:
                    // 대상 아이템 중앙
                    indicatorX = pivotAdjustedX;
                    indicatorY = pivotAdjustedY + (targetRect.rect.height / 2); //indicatorHeight 크기 때문에 반영
                    // 🎯 targetRect의 높이만큼 설정
                    indicatorHeight = targetRect.rect.height;
                    break;
            }

            // ✅ DropIndicator 위치 설정
            dropIndicatorRect.anchoredPosition = new Vector2(indicatorX, indicatorY);
            // 🎯 DropIndicator 높이 설정
            dropIndicatorRect.sizeDelta = new Vector2(dropIndicatorRect.sizeDelta.x, indicatorHeight);
            //dropIndicatorRect의 x 시작 위치를 targetRect.rect의 위치와 맞춤

            Debug.Log($"[UpdateDropIndicator] {targetItem?.Data?.Name} 위치: {dropPosition}, targetY: {targetWorldY}, parentY: {parentWorldY}, indicatorY: {indicatorY}");
        }

        /// <summary>
        /// 드롭 위치 표시 막대를 숨깁니다.
        /// </summary>
        private void HideDropIndicator()
        {
            if (dropIndicator != null)
            {
                dropIndicator.gameObject.SetActive(false);
            }
        }

        /// <summary>
        /// treeListRootParent의 자식 중에서 "DropIndicator"라는 이름의 GameObject를 찾습니다.
        /// </summary>
        /// <returns>찾은 GameObject (없으면 null)</returns>
        private GameObject? FindDropIndicatorInRoot()
        {
            if (treeListRootParent == null)
            {
                Debug.LogWarning("[FindDropIndicatorInRoot] treeListRootParent가 null입니다");
                return null;
            }

            // 1️. treeListRootParent의 모든 직접 자식을 순회
            for (int i = 0; i < treeListRootParent.childCount; i++)
            {
                Transform child = treeListRootParent.GetChild(i);

                // 2️. 자식의 이름이 "DropIndicator"인지 확인
                if (child.name == "DropIndicator")
                {
                    Debug.Log("[FindDropIndicatorInRoot] DropIndicator를 찾았습니다");
                    return child.gameObject;
                }
            }

            Debug.Log("[FindDropIndicatorInRoot] DropIndicator를 찾지 못했습니다");
            return null;
        }

        /// <summary>
        /// 주어진 스크린 좌표에 있는 TreeListItem을 찾습니다.
        /// </summary>
        /// <param name="screenPosition">스크린 좌표</param>
        /// <returns>찾은 TreeListItem (없으면 null)</returns>
        private TreeListItem? GetItemAtMousePosition(Vector2 screenPosition)
        {
            if (treeList == null)
            {
                return null;
            }

            // Raycast로 UI 요소 찾기
            var results = new System.Collections.Generic.List<RaycastResult>();
            var eventData = new PointerEventData(EventSystem.current)
            {
                position = screenPosition
            };

            EventSystem.current.RaycastAll(eventData, results);

            Debug.Log($"[GetItemAtMousePosition] Raycast 결과: {results.Count}개");

            foreach (var result in results)
            {
                var item = result.gameObject.GetComponentInParent<TreeListItem>();
                if (item != null)// && item != treeListItem)
                {
                    Debug.Log($"[GetItemAtMousePosition] 찾은 아이템: {item.Data?.Name ?? "Unknown"}");
                    return item;
                }
            }

            return null;
        }


        /// <summary>
        /// 드롭 성공 후 데이터를 동기화합니다.
        /// </summary>
        /// <param name="draggedData">드래그된 아이템</param>
        /// <param name="targetItem">드롭 대상 UI 아이템</param>
        private void HandleDropSuccess(TreeListItemData? draggedData, TreeListItem? targetItem)
        {
            if (draggedData == null || treeList == null)
            {
                return;
            }

            // 드롭 대상이 없으면 (빈 공간에 드롭) 루트로 이동
            if (targetItem == null)
            {
                Debug.Log($"[HandleDropSuccess] 루트로 이동");
                MoveToRoot(draggedData);
                treeList.UpdateFlattenedItemDataList();
                return;
            }

            var targetData = targetItem.Data;
            if (targetData == null)
            {
                return;
            }

            // 드롭 위치 판단: 대상의 위/아래 또는 자식으로
            var dropPosition = GetDropPosition(targetItem.GetComponent<RectTransform>());

            Debug.Log($"[HandleDropSuccess] 드롭 위치: {targetItem?.Data?.Name} {dropPosition}");

            switch (dropPosition)
            {
                case DropPosition.InsideAsChild:
                    // 대상의 자식으로 이동
                    MoveAsChild(draggedData, targetData);
                    break;

                case DropPosition.Above:
                    // 대상 위에 위치 (같은 부모 내에서)
                    MoveBefore(draggedData, targetData);
                    break;

                case DropPosition.Below:
                    // 대상 아래에 위치 (같은 부모 내에서)
                    MoveAfter(draggedData, targetData);
                    break;
            }

            treeList.UpdateFlattenedItemDataList();
        }

        /// <summary>
        /// 드롭 위치를 판단합니다.
        /// </summary>
        /// <param name="targetRect">대상 아이템의 RectTransform</param>
        /// <returns>드롭 위치</returns>
        private DropPosition GetDropPosition(RectTransform targetRect)
        {
            // 목표: 마우스 Y 위치를 기반으로 위/아래/안쪽 판단
            // 상위 1/3: 위
            // 중간 1/3: 자식
            // 하위 1/3: 아래

            var height = targetRect.rect.height;
            var thresholdUpper = height * 0.3f;
            var thresholdLower = height * 0.7f;

            // 월드 좌표에서 로컬 좌표로 변환
            RectTransformUtility.ScreenPointToLocalPointInRectangle(
                targetRect,
                Input.mousePosition,
                null,
                out var localMousePos);

            // 로컬 Y 좌표로 판단 (RectTransform의 피벗이 중앙이면 -height/2 ~ height/2)
            float relativeY = localMousePos.y;

            //Debug.Log($"GetDropPosition height:{height}, relativeY:{relativeY}, thresholdUpper:{thresholdUpper}, thresholdLower:{thresholdLower}");

            if (relativeY > -thresholdUpper)
            {
                return DropPosition.Above;
            }
            else if (relativeY < -thresholdLower)
            {
                return DropPosition.Below;
            }
            else
            {
                return DropPosition.InsideAsChild;
            }
        }

        /// <summary>
        /// 아이템을 루트 레벨로 이동합니다.
        /// </summary>
        private void MoveToRoot(TreeListItemData draggedData)
        {
            // 기존 부모에서 제거
            //RemoveFromParent(draggedData);
            Debug.Log($"[MoveToRoot] {draggedData.Name}을(를) 루트로 이동");

            // ✅ 루트 레벨에 추가
            // TreeList의 Root는 직접 자식들을 포함하는 컨테이너
            // Root의 자식 TreeListItem들이 실제 루트 레벨 아이템
            // 데이터 구조에서 루트 아이템을 찾기 위해 모든 루트 아이템들을 순회
            // 
            if (treeList == null)
            {
                return;
            }

            var root = treeList.Root;
            if (root == null)
            {
                return;
            }

            // 1️. 현재 마우스 위치(드래그 대상)를 기반으로 루트 아이템의 인덱스 계산
            // 2️. AddItemAt()을 호출하여 정확한 위치에 아이템 추가

            // 루트 아이템 중 마우스 위의 아이템 찾기
            var targetItem = GetItemAtMousePosition(Input.mousePosition);

            if (targetItem != null && targetItem.Data != null)
            {
                // 드롭 위치 판단
                var dropPosition = GetDropPosition(targetItem.GetComponent<RectTransform>());
                var targetData = targetItem.Data;

                // 대상 아이템이 루트 레벨의 아이템인지 확인
                if (targetData.Parent == null)
                {
                    // 루트 레벨 아이템이라면 해당 위치에 삽입
                    int targetIndex = treeList.Items.IndexOf(targetData);

                    if (targetIndex >= 0)
                    {
                        // Above: 대상 아이템 앞에 삽입
                        if (dropPosition == DropPosition.Above)
                        {
                            treeList.AddItemAt(draggedData, targetIndex);
                        }
                        // Below: 대상 아이템 뒤에 삽입
                        else if (dropPosition == DropPosition.Below)
                        {
                            treeList.AddItemAt(draggedData, targetIndex + 1);
                        }
                        else
                        {
                            // InsideAsChild: 루트 레벨에서는 아래에 추가
                            treeList.AddItemAt(draggedData, targetIndex + 1);
                        }

                        Debug.Log($"[MoveToRoot] {draggedData.Name}을(를) 루트 레벨의 인덱스 {targetIndex}에 추가");
                        return;
                    }
                }
            }

            // 루트 레벨에 아이템이 없거나 유효한 위치를 찾지 못한 경우 끝에 추가
            treeList.AddItem(draggedData);
            Debug.Log($"[MoveToRoot] {draggedData.Name}을(를) 루트 레벨의 끝에 추가");

        }

        /// <summary>
        /// 아이템을 다른 아이템의 자식으로 이동합니다.
        /// </summary>
        private void MoveAsChild(TreeListItemData draggedData, TreeListItemData targetData)
        {
            //RemoveFromParent(draggedData);
            targetData.AddChild(draggedData);
            Debug.Log($"[MoveAsChild] {draggedData.Name}을(를) {targetData.Name}의 자식으로 이동");
        }

        /// <summary>
        /// 아이템을 다른 아이템 앞으로 이동합니다.
        /// </summary>
        private void MoveBefore(TreeListItemData draggedData, TreeListItemData targetData)
        {
            var parentData = targetData.Parent;// FindParentOfItem(targetData);
            //RemoveFromParent(draggedData);

            if (parentData != null)
            {
                var targetIndex = parentData.Children.IndexOf(targetData);
                if (targetIndex >= 0)
                {
                    parentData.AddChildAt(draggedData, targetIndex); // 자식으로 추가
                    Debug.Log($"[MoveBefore] {draggedData.Name}을(를) {targetData.Name} 앞으로 이동");
                }
            }
            else
            {
                // 루트 레벨인 경우
                var treeListItems = treeList?.Items;
                if (treeListItems != null)
                {
                    var targetIndex = treeListItems.IndexOf(targetData);
                    if (targetIndex >= 0)
                    {
                        treeList?.AddItemAt(draggedData, targetIndex);
                        Debug.Log($"[MoveBefore] {draggedData.Name}을(를) {targetData.Name} 앞으로 이동 (루트 레벨)");
                    }
                }

            }
        }

        /// <summary>
        /// 아이템을 다른 아이템 뒤로 이동합니다.
        /// </summary>
        private void MoveAfter(TreeListItemData draggedData, TreeListItemData targetData)
        {
            var parentData = targetData.Parent;
            //RemoveFromParent(draggedData);

            if (parentData != null)
            {
                var targetIndex = parentData.Children.IndexOf(targetData);
                if (targetIndex >= 0)
                {
                    parentData.AddChildAt(draggedData, targetIndex + 1);
                    Debug.Log($"[MoveAfter] {draggedData.Name}을(를) {targetData.Name} 뒤로 이동");
                }
            }
            else
            {
                // 루트 레벨인 경우
                var treeListItems = treeList?.Items;
                if (treeListItems != null)
                {
                    var targetIndex = treeListItems.IndexOf(targetData);
                    if (targetIndex >= 0)
                    {
                        treeList?.AddItemAt(draggedData, targetIndex + 1);
                        Debug.Log($"[MoveAfter] {draggedData.Name}을(를) {targetData.Name} 뒤로 이동 (루트 레벨)");
                    }
                }
            }
        }


        /// <summary>
        /// 아이템을 현재 부모에서 제거합니다.
        /// </summary>
        private void RemoveFromParent(TreeListItemData item)
        {

            Debug.Log($"[RemoveFromParent] {item.Name}을(를) 부모 {item.Parent == null}에서 제거");
            if (item.Parent != null)
            {
                item.Parent.RemoveChild(item);
            }
            else
            {
                // 루트 레벨에서 제거
                treeList?.RemoveItem(item);
            }
            treeList?.UpdateFlattenedItemDataList();
        }

        /// <summary>
        /// 주어진 아이템의 부모를 찾습니다.
        /// </summary>
        private TreeListItemData? FindParentOfItem(TreeListItemData item)
        {
            if (treeList == null)
            {
                return null;
            }

            foreach (TreeListItemData data in treeList!.AllItemsFlattened)
            {
                if (data == item)
                {
                    return data.Parent;
                }
            }
            return null;
        }


        /// <summary>
        /// 드롭 위치를 나타내는 열거형입니다.
        /// </summary>
        private enum DropPosition
        {
            /// <summary>위 (형제 아이템으로 앞쪽)</summary>
            Above,

            /// <summary>안쪽 (자식으로)</summary>
            InsideAsChild,

            /// <summary>아래 (형제 아이템으로 뒤쪽)</summary>
            Below
        }
    }
}