#nullable enable
using Cysharp.Threading.Tasks;
using System;
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UVC.Pool;
using UVC.UI.Modal.DatePicker;

namespace UVC.UI.List.Tree
{
    /// <summary>
    /// 트리 구조의 리스트를 관리하고 제어하는 클래스입니다.
    ///
    /// 주요 기능:
    ///   - 계층 구조 아이템의 추가/제거 관리
    ///   - 단일 및 다중 선택 지원 (파일 탐색기와 동일)
    ///   - 키보드 입력(Delete, 화살표, Ctrl, Shift) 처리
    ///   - 드래그 & 드롭 기능 지원
    ///   - 선택 상태 변경 이벤트 제공
    ///
    /// 선택 동작:
    ///   - 클릭: 한 항목 선택
    ///   - Ctrl+클릭: 여러 항목 선택 (기존 선택 유지)
    ///   - Shift+클릭: 범위 선택 (시작~끝)
    ///   - 화살표: 선택된 아이템 이동
    ///   - Delete: 선택된 아이템 삭제
    /// </summary>
    public class TreeList : MonoBehaviour
    {
        /// <summary>
        /// UI 아이템 프리팹 (복제할 템플릿)
        /// </summary>
        [SerializeField]
        protected TreeListItem itemPrefab;

        /// <summary>
        /// itemPrefab 프로퍼티 (읽기 전용)
        /// </summary>
        public TreeListItem ItemPrefab => itemPrefab;

        /// <summary>
        /// 모든 아이템을 담는 부모 컨테이너 (RectTransform)
        /// </summary>
        [SerializeField]
        protected RectTransform root;

        /// <summary>
        /// root 프로퍼티 (읽기 전용)
        /// </summary>
        public RectTransform Root => root;

        /// <summary>
        /// 다중 선택 허용 여부
        /// (true: 여러 개 선택 가능, false: 한 개만 선택 가능)
        /// </summary>
        [SerializeField]
        protected bool allowMultipleSelection = true;

        /// <summary>
        /// 드래그 & 드롭 기능 활성화 여부
        /// </summary>
        [SerializeField]
        protected bool enableDragDrop = true;

        /// <summary>
        /// 현재 선택된 아이템 리스트
        /// </summary>
        protected List<TreeListItemData> selectedItems = new List<TreeListItemData>();

        /// <summary>
        /// 마지막으로 선택한 아이템 (Shift+클릭 범위 선택의 시작점)
        /// </summary>
        protected TreeListItemData? lastSelectedItem = null;

        /// <summary>
        /// 모든 아이템을 1차원으로 평탄화한 리스트 (범위 선택용)
        /// </summary>
        protected List<TreeListItemData> allItemDataFlattened = new List<TreeListItemData>();

        /// <summary>
        /// 평탄화된 아이템 데이터 리스트 (읽기 전용)
        /// </summary>
        public List<TreeListItemData> AllItemDataFlattened => allItemDataFlattened;

        /// <summary>
        /// 루트 레벨 아이템 리스트
        /// </summary>
        protected List<TreeListItemData> items = new List<TreeListItemData>();

        /// <summary>
        /// 루트 레벨 아이템 리스트 (읽기 전용)
        /// </summary>
        public List<TreeListItemData> Items => items;

        /// <summary>
        /// 평탄화된 UI 아이템(TreeListItem) 리스트
        /// </summary>
        protected List<TreeListItem> allItemFlattened = new List<TreeListItem>();

        /// <summary>
        /// 평탄화된 UI 아이템 리스트 (읽기 전용)
        /// </summary>
        public List<TreeListItem> AllItemFlattened => allItemFlattened;

        /// <summary>
        /// 드래그 & 드롭 매니저
        /// </summary>
        protected TreeListDragDropManager dragDropManager = new TreeListDragDropManager();

        /// <summary>
        /// 드래그 & 드롭 매니저 (읽기 전용)
        /// </summary>
        public TreeListDragDropManager DragDropManager => dragDropManager;

        #region 오브젝트 풀링 (Object Pooling)

        /// <summary>
        /// TreeListItem 오브젝트 풀
        /// </summary>
        protected GameObjectPool<TreeListItem>? _itemPool;

        /// <summary>
        /// 재활용 컨테이너 (비활성 아이템 보관용)
        /// </summary>
        [SerializeField]
        protected Transform? recycledContainer;

        /// <summary>
        /// 오브젝트 풀 읽기 전용 접근자
        /// </summary>
        public GameObjectPool<TreeListItem>? ItemPool => _itemPool;

        #endregion

        /// <summary>
        /// 아이템 선택 상태 변경 이벤트 (data, isSelected)
        /// TreeListItem에서 호출됩니다.
        /// </summary>
        public Action<TreeListItemData, bool>? OnItemSelectionChanged;

        /// <summary>
        /// 아이템 데이터 변경 이벤트 (changedType, changedData, index)
        /// TreeListItemData의 데이터가 변경될 때 호출됩니다.
        /// </summary>
        public Action<ChangedType, TreeListItemData, int>? OnItemDataChanged;

        /// <summary>
        /// 아이템 클릭 이벤트 (data)
        /// TreeListItem이 클릭될 때 호출됩니다.
        /// </summary>
        public Action<TreeListItemData>? OnItemClickAction;

        /// <summary>
        /// 아이템 가시성 변경 이벤트 (changedData, isVisible)
        /// </summary>
        public Action<TreeListItemData, bool>? OnItemVisibilityChanged;

        /// <summary>
        /// 아이템 더블클릭 이벤트 (data)
        /// TreeListItem이 더블클릭될 때 호출됩니다.
        /// </summary>
        public Action<TreeListItemData>? OnItemDoubleClicked;

        /// <summary>
        /// 현재 선택된 아이템 목록 (읽기 전용)
        /// </summary>
        public IReadOnlyList<TreeListItemData> SelectedItems => selectedItems.AsReadOnly();

        /// <summary>
        /// root 아래의 모든 TreeListItem 컴포넌트
        /// </summary>
        public List<TreeListItem> TreeLists => root.GetComponentsInChildren<TreeListItem>().ToList();

        // 뷰 매핑: 데이터 ↔ View O(1) 조회
        protected readonly Dictionary<TreeListItemData, TreeListItem> _viewMap = new Dictionary<TreeListItemData, TreeListItem>();

        // 플래튼 업데이트 스로틀링 플래그
        protected bool _flattenScheduled;

        protected void Awake()
        {
            // 드래그 & 드롭 이벤트 구독
            if (enableDragDrop)
            {
                dragDropManager.OnDropped += HandleItemDropped;
            }

            // 오브젝트 풀 초기화
            InitializePool();
        }

        /// <summary>
        /// 오브젝트 풀 초기화
        /// </summary>
        protected virtual void InitializePool()
        {
            if (itemPrefab == null) return;

            // recycledContainer가 없으면 동적 생성
            if (recycledContainer == null)
            {
                var recycledGO = new GameObject("_RecycledItems");
                recycledGO.transform.SetParent(transform, false);
                recycledGO.SetActive(false); // 비활성 상태로 유지
                recycledContainer = recycledGO.transform;
            }

            _itemPool = new GameObjectPool<TreeListItem>(
                itemPrefab.gameObject,
                root,
                recycledContainer
            );
        }

        /// <summary>
        /// 풀에서 TreeListItem 획득
        /// </summary>
        /// <param name="key">아이템 고유 키 (TreeListItemData.Id.ToString())</param>
        /// <param name="parent">부모 Transform (null이면 root 사용)</param>
        /// <returns>풀에서 획득한 TreeListItem</returns>
        public TreeListItem? GetPooledItem(string key, Transform? parent = null)
        {
            if (_itemPool == null)
            {
                InitializePool();
            }

            var item = _itemPool!.GetItem(key, true, parent ?? root);
            return item;
        }

        /// <summary>
        /// TreeListItem을 풀에 반환
        /// </summary>
        /// <param name="item">반환할 TreeListItem</param>
        /// <param name="key">아이템 고유 키</param>
        public void ReturnItemToPool(TreeListItem item, string key)
        {
            if (_itemPool == null || item == null) return;

            _itemPool.ReturnItem(key, true);
        }

        /// <summary>
        /// 모든 아이템을 풀에 반환
        /// </summary>
        public void ReturnAllToPool()
        {
            _itemPool?.ReturnAll();
            allItemFlattened.Clear();
            allItemDataFlattened.Clear();
            selectedItems.Clear();
            _viewMap.Clear();
        }

        protected void OnDestroy()
        {
            if (enableDragDrop)
            {
                dragDropManager.OnDropped -= HandleItemDropped;
            }

            // 이벤트 핸들러 정리
            OnItemSelectionChanged = null;
            OnItemDataChanged = null;
            OnItemClickAction = null;
            OnItemVisibilityChanged = null;

            // 데이터 및 뷰 맵 정리
            _viewMap.Clear();
            allItemFlattened.Clear();
            allItemDataFlattened.Clear();
            selectedItems.Clear();
            items.Clear();

            // 풀 정리
            _itemPool?.ClearRecycledItems();
        }

        #region 데이터 변경 메서드 (Data Modification Methods)

        /// <summary>
        /// 아이템 이름을 변경하고 UI를 갱신합니다.
        /// </summary>
        public void SetItemName(TreeListItemData data, string name)
        {
            if (data.Name == name) return;
            data.Name = name;
            NotifyDataChanged(data, ChangedType.Name);
        }

        /// <summary>
        /// 아이템 옵션을 변경하고 UI를 갱신합니다.
        /// </summary>
        public void SetItemOption(TreeListItemData data, string option)
        {
            if (data.Option == option) return;
            data.Option = option;
            NotifyDataChanged(data, ChangedType.Option);
        }

        /// <summary>
        /// 아이템 펼침 상태를 변경하고 UI를 갱신합니다.
        /// </summary>
        public void SetItemExpanded(TreeListItemData data, bool expanded)
        {
            if (data.IsExpanded == expanded) return;
            data.IsExpanded = expanded;
            NotifyDataChanged(data, ChangedType.Expanded);
        }

        /// <summary>
        /// 아이템 가시성 상태를 변경하고 UI를 갱신합니다.
        /// </summary>
        public void SetItemVisible(TreeListItemData data, bool visible)
        {
            if (data.IsVisible == visible) return;
            data.IsVisible = visible;
            NotifyDataChanged(data, ChangedType.TailButtons);
        }

        /// <summary>
        /// 부모 아이템에 자식을 추가하고 UI를 갱신합니다.
        /// </summary>
        public void AddChild(TreeListItemData parent, TreeListItemData child)
        {
            parent.AddChild(child);
            NotifyDataChanged(parent, ChangedType.AddChild, child);
        }

        /// <summary>
        /// 부모 아이템의 특정 위치에 자식을 추가하고 UI를 갱신합니다.
        /// </summary>
        public void AddChildAt(TreeListItemData parent, TreeListItemData child, int index)
        {
            parent.AddChildAt(child, index);
            NotifyDataChanged(parent, ChangedType.AddAtChild, child, index);
        }

        /// <summary>
        /// 자식을 복제하여 부모에 추가하고 UI를 갱신합니다.
        /// </summary>
        public void AddCloneChild(TreeListItemData parent, TreeListItemData child)
        {
            NotifyDataChanged(parent, ChangedType.AddCloneChild, child);
        }

        /// <summary>
        /// 자식을 복제하여 부모의 특정 위치에 추가하고 UI를 갱신합니다.
        /// </summary>
        public void AddCloneChildAt(TreeListItemData parent, TreeListItemData child, int index)
        {
            NotifyDataChanged(parent, ChangedType.AddCloneAtChild, child, index);
        }

        /// <summary>
        /// 자식을 특정 위치로 이동하고 UI를 갱신합니다.
        /// </summary>
        public void SwapChild(TreeListItemData parent, TreeListItemData child, int index)
        {
            parent.SwapChild(child, index);
            NotifyDataChanged(parent, ChangedType.SwapChild, child, index);
        }

        /// <summary>
        /// 부모에서 자식을 제거하고 UI를 갱신합니다.
        /// </summary>
        public void RemoveChild(TreeListItemData parent, TreeListItemData child)
        {
            if (parent.RemoveChild(child))
            {
                NotifyDataChanged(parent, ChangedType.RemoveChild, child);
            }
        }

        /// <summary>
        /// 부모의 모든 자식을 제거하고 UI를 갱신합니다.
        /// </summary>
        public void ClearChildren(TreeListItemData parent)
        {
            parent.ClearChildren();
            NotifyDataChanged(parent, ChangedType.ResetChildren);
        }

        /// <summary>
        /// 데이터 변경을 View에 알립니다.
        /// </summary>
        internal void NotifyDataChanged(TreeListItemData owner, ChangedType changedType, TreeListItemData? target = null, int index = -1)
        {
            // View가 있으면 알림
            if (_viewMap.TryGetValue(owner, out var view) && view != null)
            {
                view.HandleDataChanged(changedType, target ?? owner, index);
            }

            // 외부 이벤트 발생
            OnItemDataChanged?.Invoke(changedType, target ?? owner, index);
        }

        /// <summary>
        /// 선택 상태 변경을 View에 알립니다.
        /// </summary>
        internal void NotifySelectionChanged(TreeListItemData data, bool isSelected)
        {
            // View가 있으면 알림
            if (_viewMap.TryGetValue(data, out var view) && view != null)
            {
                view.HandleSelectionChanged();
            }

            // 외부 이벤트 발생
            OnItemSelectionChanged?.Invoke(data, isSelected);
        }

        #endregion

        protected void Update()
        {
            // 입력 필드에 포커스가 있으면 키보드 입력 무시
            if (IsInputFieldFocused()) return;

            // Escape 키 입력 감지 - 선택 해제
            if (Input.GetKeyDown(KeyCode.Escape))
            {
                HandleEscapeKeyPressed();
            }

            // Delete 키 입력 감지
            if (Input.GetKeyDown(KeyCode.Delete))
            {
                HandleDeleteKeyPressed();
            }

            // 위/아래 화살표 키로 선택 아이템 변경
            if (Input.GetKeyDown(KeyCode.UpArrow))
            {
                HandleUpArrowKeyPressed();
            }

            if (Input.GetKeyDown(KeyCode.DownArrow))
            {
                HandleDownArrowKeyPressed();
            }

            // 좌/우 키로 선택된 아이템 접힘/펼침접힘
            if (Input.GetKeyDown(KeyCode.RightArrow))
            {
                HandleRightArrowKeyPressed();
            }

            if (Input.GetKeyDown(KeyCode.LeftArrow))
            {
                HandleLeftArrowKeyPressed();
            }
        }

        /// <summary>
        /// 입력 필드에 포커스가 있는지 확인합니다.
        /// </summary>
        private bool IsInputFieldFocused()
        {
            var eventSystem = EventSystem.current;
            if (eventSystem == null) return false;

            var selected = eventSystem.currentSelectedGameObject;
            if (selected == null) return false;

            // TMP_InputField 확인 (자기 자신 및 부모 계층에서 검색)
            var tmpInput = selected.GetComponent<TMP_InputField>();
            if (tmpInput == null)
            {
                tmpInput = selected.GetComponentInParent<TMP_InputField>();
            }
            if (tmpInput != null && tmpInput.isFocused) return true;

            // Legacy InputField 확인 (자기 자신 및 부모 계층에서 검색)
            var legacyInput = selected.GetComponent<UnityEngine.UI.InputField>();
            if (legacyInput == null)
            {
                legacyInput = selected.GetComponentInParent<UnityEngine.UI.InputField>();
            }
            if (legacyInput != null && legacyInput.isFocused) return true;

            return false;
        }

        /// <summary>
        /// View 등록(데이터↔View 맵). Init 시점에 호출됩니다.
        /// </summary>
        internal void RegisterView(TreeListItemData data, TreeListItem view)
        {
            if (data == null || view == null) return;
            _viewMap[data] = view;
        }

        /// <summary>
        /// View 등록 해제. Delete/OnDestroy 시점에 호출됩니다.
        /// </summary>
        internal void UnregisterView(TreeListItemData data, TreeListItem view)
        {
            if (data == null) return;
            if (_viewMap.TryGetValue(data, out var existing) && existing == view)
            {
                _viewMap.Remove(data);
            }
        }

        /// <summary>
        /// 다음 프레임에 평탄화 리스트 업데이트를 예약합니다.
        /// 과도한 재계산을 방지하기 위한 스로틀링 유틸입니다.
        /// </summary>
        public void ScheduleFlattenedUpdate()
        {
            if (_flattenScheduled) return;
            _flattenScheduled = true;
            UniTask.NextFrame().ContinueWith(() =>
            {
                _flattenScheduled = false;
                UpdateFlattenedItemDataList();
            });
        }

        /// <summary>
        /// Escape 키 입력 시 모든 선택 해제
        /// 
        /// 동작:
        ///   1. 선택된 아이템이 있는지 확인
        ///   2. ClearSelection() 호출하여 모든 선택 해제
        ///   3. lastSelectedItem 초기화
        /// 
        /// 용도: 사용자가 선택을 취소하고 싶을 때 빠른 해제
        /// </summary>
        protected void HandleEscapeKeyPressed()
        {
            // 선택된 아이템이 없으면 아무것도 하지 않음
            if (selectedItems.Count == 0)
            {
                return;
            }

            // 디버그 로그
            //Debug.Log($"Escape key pressed. Clearing {selectedItems.Count} selected item(s).");

            // 모든 선택 해제
            ClearSelection();

            // 마지막 선택 아이템 초기화
            lastSelectedItem = null;
        }

        /// <summary>
        /// Delete 키 입력 시 선택된 모든 아이템 삭제
        /// 
        /// 동작:
        ///   1. 선택된 아이템 목록 복사
        ///   2. 각 아이템에 대해 DeleteItem() 호출
        ///   3. 평탄화 리스트 업데이트
        /// 
        /// 주의: 반복 중 리스트 수정으로 인한 문제 방지를 위해 
        ///      ToList()로 복사 후 순회합니다.
        /// </summary>
        protected void HandleDeleteKeyPressed()
        {
            // 선택된 아이템이 없으면 아무것도 하지 않음
            if (selectedItems.Count == 0)
            {
                return;
            }

            // 선택된 아이템 목록을 복사 (역순 삭제 시 안전)
            var itemsToDelete = selectedItems.ToList();

            // 디버그 로그
            //Debug.Log($"Delete key pressed. Removing {itemsToDelete.Count} selected item(s).");

            // 각 선택된 아이템에 대해 삭제 이벤트 발생 후 삭제
            foreach (var item in itemsToDelete)
            {
                // 삭제 전 이벤트 발생 (View 업데이트 + 외부에서 연관 데이터 정리 가능)
                NotifyDataChanged(item, ChangedType.Delete, item);
                DeleteItem(item);
            }

            UpdateFlattenedItemDataList();
        }

        /// <summary>
        /// 펼쳐진 아이템들만 포함하는 가시 리스트 생성
        /// 
        /// 동작:
        ///   1. 루트 레벨 아이템부터 시작
        ///   2. IsExpanded=true인 아이템의 자식들만 포함
        ///   3. 재귀적으로 모든 가시 아이템 수집
        /// 
        /// 용도: 화살표 키 네비게이션 시 보이는 아이템만 선택 가능
        /// </summary>
        protected List<TreeListItemData> GetVisibleFlattenedItems()
        {
            List<TreeListItemData> visibleItems = new List<TreeListItemData>();

            // 루트 레벨 아이템들부터 시작
            foreach (var rootItem in items)
            {
                AddVisibleItemsRecursive(rootItem, visibleItems);
            }

            return visibleItems;
        }

        /// <summary>
        /// 가시 아이템을 재귀적으로 추가
        /// 
        /// 동작:
        ///   1. 현재 아이템을 리스트에 추가
        ///   2. IsExpanded=true이면 모든 자식 재귀 처리
        ///   3. IsExpanded=false이면 자식 무시 (접혀있음)
        /// </summary>
        /// <param name="item">현재 처리할 아이템</param>
        /// <param name="visibleItems">수집 결과 리스트</param>
        protected void AddVisibleItemsRecursive(TreeListItemData item, List<TreeListItemData> visibleItems)
        {
            // 현재 아이템을 리스트에 추가
            visibleItems.Add(item);

            // IsExpanded=true인 경우에만 자식들 처리
            if (item.IsExpanded)
            {
                foreach (var child in item.Children)
                {
                    AddVisibleItemsRecursive(child, visibleItems);
                }
            }
        }

        /// <summary>
        /// 위쪽 화살표 키 처리: 선택 아이템을 위로 이동
        /// 
        /// 동작:
        ///   1. 정확히 1개 아이템만 선택되어 있는지 확인
        ///   2. 가시 리스트에서 현재 아이템의 위치 찾기
        ///   3. 이전 아이템이 있으면 선택 변경
        /// 
        /// 제약: 단일 선택 상태에서만 작동
        /// </summary>
        protected void HandleUpArrowKeyPressed()
        {
            // 정확히 하나의 아이템만 선택되어 있어야 함
            if (selectedItems.Count != 1)
            {
                return;
            }

            TreeListItemData currentSelected = selectedItems[0];

            // 펼쳐진 아이템들만 포함하는 임시 리스트 생성
            List<TreeListItemData> visibleItems = GetVisibleFlattenedItems();

            // 임시 리스트에서 현재 선택된 아이템의 인덱스 찾기
            int currentIndex = visibleItems.IndexOf(currentSelected);

            // 아이템을 찾을 수 없으면 종료
            if (currentIndex == -1)
            {
                return;
            }

            // 이전 아이템이 있는지 확인 (0보다 크면 이전 아이템이 있음)
            if (currentIndex > 0)
            {
                int previousIndex = currentIndex - 1;
                TreeListItemData previousItem = visibleItems[previousIndex];

                // 현재 아이템 선택 해제
                DeselectItem(currentSelected);

                // 이전 아이템 선택
                SelectItem(previousItem);
                lastSelectedItem = previousItem;

                // 디버그 로그
                //Debug.Log($"Up arrow: Selected '{previousItem.Name}' (visible index {previousIndex})");
            }
        }

        /// <summary>
        /// 아래쪽 화살표 키 처리: 선택 아이템을 아래로 이동
        /// 
        /// 동작:
        ///   1. 가시 리스트 생성
        ///   2. 선택 없음: 첫 번째 아이템 선택
        ///   3. 단일 선택: 다음 아이템으로 이동
        ///   4. 다중 선택: 무시
        /// 
        /// 제약: 단일 선택 상태에서만 작동
        /// </summary>
        protected void HandleDownArrowKeyPressed()
        {
            // 펼쳐진 아이템들만 포함하는 임시 리스트 생성
            List<TreeListItemData> visibleItems = GetVisibleFlattenedItems();

            // 선택된 아이템이 없는 경우
            if (selectedItems.Count == 0)
            {
                // 펼쳐진 아이템 리스트에 아이템이 있으면 첫 번째 아이템 선택
                if (visibleItems.Count > 0)
                {
                    TreeListItemData firstItem = visibleItems[0];
                    SelectItem(firstItem);
                    lastSelectedItem = firstItem;

                    // 디버그 로그
                    //Debug.Log($"Down arrow (no selection): Selected first visible item '{firstItem.Name}'");
                }
                return;
            }

            // 정확히 하나의 아이템만 선택되어 있어야 함
            if (selectedItems.Count != 1)
            {
                return;
            }

            TreeListItemData currentSelected = selectedItems[0];

            // 임시 리스트에서 현재 선택된 아이템의 인덱스 찾기
            int currentIndex = visibleItems.IndexOf(currentSelected);

            // 아이템을 찾을 수 없으면 종료
            if (currentIndex == -1)
            {
                return;
            }

            // 다음 아이템이 있는지 확인
            if (currentIndex < visibleItems.Count - 1)
            {
                int nextIndex = currentIndex + 1;
                TreeListItemData nextItem = visibleItems[nextIndex];

                // 현재 아이템 선택 해제
                DeselectItem(currentSelected);

                // 다음 아이템 선택
                SelectItem(nextItem);
                lastSelectedItem = nextItem;

                // 디버그 로그
                //Debug.Log($"Down arrow: Selected '{nextItem.Name}' (visible index {nextIndex})");
            }
        }

        /// <summary>
        /// 우측 화살표 키 처리: 선택된 아이템 펼치기
        /// 
        /// 동작:
        ///   1. 정확히 1개 아이템만 선택되어 있는지 확인
        ///   2. IsExpanded를 true로 설정
        ///   3. 평탄화 리스트 업데이트
        /// 
        /// 제약: 이미 펼쳐진 아이템은 동작 없음
        /// </summary>
        protected void HandleRightArrowKeyPressed()
        {
            // 선택된 아이템이 없으면 아무것도 하지 않음
            if (selectedItems.Count == 0)
            {
                return;
            }

            // 정확히 하나의 아이템만 선택되어 있어야 함
            // (다중 선택 상태에서는 작동하지 않음)
            if (selectedItems.Count != 1)
            {
                return;
            }

            TreeListItemData selectedItem = selectedItems[0];

            if (selectedItem.IsExpanded) return;

            // IsExpanded 상태를 true로 설정하고 UI 갱신
            SetItemExpanded(selectedItem, true);

            // 펼침/접힘 상태 변경을 UI에 반영하기 위해 평탄화 리스트 업데이트
            UpdateFlattenedItemDataList();
        }

        /// <summary>
        /// 좌측 화살표 키 처리: 선택된 아이템 접기
        ///
        /// 동작:
        ///   1. 정확히 1개 아이템만 선택되어 있는지 확인
        ///   2. IsExpanded를 false로 설정
        ///   3. 평탄화 리스트 업데이트
        ///
        /// 제약: 이미 접혀진 아이템은 동작 없음
        /// </summary>
        protected void HandleLeftArrowKeyPressed()
        {
            // 선택된 아이템이 없으면 아무것도 하지 않음
            if (selectedItems.Count == 0)
            {
                return;
            }

            // 정확히 하나의 아이템만 선택되어 있어야 함
            // (다중 선택 상태에서는 작동하지 않음)
            if (selectedItems.Count != 1)
            {
                return;
            }

            TreeListItemData selectedItem = selectedItems[0];

            if (!selectedItem.IsExpanded) return;

            // IsExpanded 상태를 false로 설정하고 UI 갱신
            SetItemExpanded(selectedItem, false);

            // 펼침/접힘 상태 변경을 UI에 반영하기 위해 평탄화 리스트 업데이트
            UpdateFlattenedItemDataList();
        }

        /// <summary>
        /// TreeListItem 프리팹 인스턴스화
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        protected T? Create<T>() where T : TreeListItem
        {
            T? item = GameObject.Instantiate(ItemPrefab, root) as T;
            return item;
        }

        /// <summary>
        /// 새 아이템 추가
        /// 
        /// 동작:
        ///   1. 아이템 프리팹 인스턴스화
        ///   2. UI 초기화 (Init 호출)
        ///   3. 데이터 리스트에 추가
        ///   4. 평탄화 리스트 업데이트
        /// 
        /// 매개변수:
        ///   - data: 추가할 아이템 데이터
        /// </summary>
        /// <param name="data">추가할 아이템 데이터</param>
        public void AddItem<T>(TreeListItemData data) where T : TreeListItem
        {
            data.Parent = null;
            // Instantiate(템플릿, 부모 Transform)
            // = 템플릿을 복제하고 부모의 자식으로 설정
            T? item = Create<T>();

            // 생성된 아이템 초기화
            // 데이터를 UI에 바인딩하고 이벤트 리스너 등록
            item?.Init(data, this, dragDropManager);
            items.Add(data);

            // 범위 선택에 필요한 평탄화 리스트 업데이트
            UpdateFlattenedItemDataList();

        }

        /// <summary>
        /// 새 아이템들 추가
        /// </summary>
        /// <typeparam name="T">추가 할 타입</typeparam>
        /// <param name="datas">추가 할 데이터들</param>
        public void AddItems<T>(IEnumerable<TreeListItemData> datas) where T : TreeListItem
        {
            foreach (var data in datas)
            {
                data.Parent = null;
                // Instantiate(템플릿, 부모 Transform)
                // = 템플릿을 복제하고 부모의 자식으로 설정
                T? item = Create<T>();
                // 생성된 아이템 초기화
                // 데이터를 UI에 바인딩하고 이벤트 리스너 등록
                item?.Init(data, this, dragDropManager);
                items.Add(data);
            }
            UpdateFlattenedItemDataList();
        }

        /// <summary>
        /// 지정 인덱스에 아이템 추가
        /// 
        /// 동작:
        ///   1. 아이템 프리팹 인스턴스화
        ///   2. 지정 위치에 데이터 삽입
        ///   3. UI 순서 조정
        ///   4. 평탄화 리스트 업데이트
        /// </summary>
        /// <param name="data">추가할 아이템 데이터</param>
        /// <param name="index">삽입 위치</param>
        public void AddItemAt<T>(TreeListItemData data, int index) where T : TreeListItem
        {
            data.Parent = null;

            T item = GameObject.Instantiate(ItemPrefab, root) as T;
            item.Init(data, this, dragDropManager);
            index = Mathf.Clamp(index, 0, items.Count);
            items.Insert(index, data);

            UniTask.DelayFrame(1).ContinueWith(() =>
            {
                //gameObject 순서 조절
                item.transform.SetSiblingIndex(index);

                // 범위 선택에 필요한 평탄화 리스트 업데이트
                UpdateFlattenedItemDataList();
            });
        }

        /// <summary>
        /// 아이템 복제 추가
        /// </summary>
        /// <param name="data">복제할 원본 아이템 데이터</param>
        public void AddCloneItem(TreeListItemData data)
        {
            TreeListItemData clone = data.CloneWithChild();

            //호출 순서 중요
            //data에 해당하는 TreeListItem 찾기
            TreeListItem? item = allItemFlattened.FirstOrDefault(x => x.Data == data);

            //changedData 부모에게 알림
            if (data.Parent != null)
            {
                RemoveChild(data.Parent, data);
            }
            else
            {
                RemoveItem(data);
            }

            if (item != null) item.Delete(true);

            AddItem<TreeListItem>(clone);

        }

        /// <summary>
        /// 아이템 복제 후 지정 인덱스에 추가
        /// </summary>
        /// <param name="data">복제할 원본 아이템 데이터</param>
        /// <param name="index">삽입 위치</param>
        public void AddCloneItemAt(TreeListItemData data, int index)
        {
            TreeListItemData clone = data.CloneWithChild();

            //호출 순서 중요
            //data에 해당하는 TreeListItem 찾기
            TreeListItem? item = allItemFlattened.FirstOrDefault(x => x.Data == data);

            //changedData 부모에게 알림
            if (data.Parent != null)
            {
                RemoveChild(data.Parent, data);
            }
            else
            {
                RemoveItem(data);
            }

            if (item != null) item.Delete(true);

            AddItemAt<TreeListItem>(clone, index);
        }

        /// <summary>
        /// 아이템을 지정 인덱스로 이동합니다(기존 위치 제거 후 삽입).
        /// </summary>
        public void SwapItem(TreeListItemData data, int index)
        {
            // 기존 위치 제거
            items.Remove(data);
            // 인덱스 보정 후 삽입
            index = Mathf.Clamp(index, 0, items.Count);
            items.Insert(index, data);

            TreeListItem? item = allItemFlattened.FirstOrDefault(x => x.Data == data);
            UniTask.DelayFrame(1).ContinueWith(() =>
            {
                if (item != null) item.transform.SetSiblingIndex(index);
                UpdateFlattenedItemDataList();
            });
        }

        public void RemoveItem(TreeListItemData data)
        {
            if (items.Contains(data)) items.Remove(data);
            UpdateFlattenedItemDataList();
        }


        /// <summary>
        /// 아이템 삭제
        ///
        /// 동작:
        ///   1. 데이터 리스트에서 제거 (루트 또는 부모의 Children)
        ///   2. 선택 리스트에서 제거
        ///   3. UI 컴포넌트 삭제
        ///   4. 데이터 메모리 해제
        /// </summary>
        /// <param name="data">삭제할 아이템 데이터</param>
        public void DeleteItem(TreeListItemData data)
        {
            // 루트 레벨이면 items에서 제거, 자식이면 부모의 Children에서 제거
            if (data.Parent != null)
            {
                data.Parent.RemoveChild(data);
            }
            else
            {
                items.Remove(data);
            }

            // selectedItems에서도 제거
            if (selectedItems.Contains(data))
            {
                selectedItems.Remove(data);
            }

            // UI 삭제 - _viewMap에서 먼저 찾기 (풀링 적용 후 더 정확함)
            if (_viewMap.TryGetValue(data, out var viewItem) && viewItem != null)
            {
                viewItem.Delete(true);
            }
            else
            {
                // fallback: allItemFlattened에서 찾기
                TreeListItem? item = allItemFlattened.FirstOrDefault(x => x.Data == data);
                if (item != null)
                {
                    item.Delete(true);
                }
            }
        }

        /// <summary>
        /// 컬렉션에서 모든 항목을 지우고 관련 리소스를 해제합니다.
        /// </summary>
        /// <remarks>이 메서드는 컬렉션에서 모든 항목을 제거하고, 내부 데이터 구조를 지우고,
        /// <see cref="Delete"/> 메서드를 <see
        /// langword="true"/> 매개변수로 호출하여 각 항목을 삭제합니다.</remarks>
        public void ClearItems()
        {
            foreach (var item in allItemFlattened)
            {
                item.Delete(true);
            }

            allItemFlattened.Clear();
            allItemDataFlattened.Clear();
            items.Clear();
            selectedItems.Clear();
            _viewMap.Clear();
        }

        /// <summary>
        /// 모든 아이템을 1차원 리스트로 평탄화
        /// 
        /// 동작:
        ///   1. 평탄화 리스트 초기화
        ///   2. 루트 아이템부터 재귀적으로 추가
        ///   3. 각 데이터에 대응하는 UI 컴포넌트 수집
        /// 
        /// 용도: 범위 선택 및 화살표 네비게이션
        /// </summary>
        internal void UpdateFlattenedItemDataList()
        {
            // 기존 평탄화 리스트 비우기
            allItemDataFlattened.Clear();

            // root의 모든 직접 자식을 순회
            // (손자, 증손자는 재귀로 처리됨)
            foreach (TreeListItemData itemData in items)
            {
                // 이 아이템과 자식들을 재귀적으로 평탄화 리스트에 추가
                AddItemDataToFlattened(itemData);
            }

            allItemFlattened.Clear();
            foreach (var data in allItemDataFlattened)
            {
                if (_viewMap.TryGetValue(data, out var item) && item != null)
                {
                    allItemFlattened.Add(item);
                }
            }
        }

        /// <summary>
        /// 아이템과 자식들을 재귀적으로 평탄화
        /// 
        /// 동작:
        ///   1. 현재 아이템 추가
        ///   2. 모든 자식에 대해 재귀 호출
        /// 
        /// 트리 구조를 1차원 배열로 변환하여 
        /// 빠른 인덱스 검색 및 범위 선택을 가능하게 합니다.
        /// </summary>
        /// <param name="data">현재 처리할 아이템</param>
        protected void AddItemDataToFlattened(TreeListItemData data)
        {
            // 현재 아이템을 평탄화 리스트에 추가
            allItemDataFlattened.Add(data);

            // 현재 아이템의 모든 자식을 순회
            foreach (var child in data.Children)
            {
                // 각 자식에 대해 재귀 호출
                // = 자식의 자식들도 모두 추가됨
                AddItemDataToFlattened(child);
            }
        }

        /// <summary>
        /// 아이템 클릭 처리 (TreeListItem에서 호출)
        ///
        /// 동작:
        ///   1. 키 입력 상태 확인 (Ctrl, Shift)
        ///   2. 선택 모드에 따라 로직 실행:
        ///      - 일반 클릭: 이 아이템만 선택
        ///      - Ctrl+클릭: 토글 (기존 선택 유지)
        ///      - Shift+클릭: 범위 선택
        ///   3. 마지막 선택 아이템 기록
        /// </summary>
        /// <param name="data">클릭한 아이템</param>
        /// <param name="ctrlPressed">Ctrl 키 입력 여부</param>
        /// <param name="shiftPressed">Shift 키 입력 여부</param>
        internal void HandleItemClicked(TreeListItemData data, bool ctrlPressed, bool shiftPressed)
        {
            // 디버그 로그: 클릭 정보를 콘솔에 출력 (개발 중 확인용)
            //Debug.Log($"OnItemClicked {data.Name}, ctrlPressed:{ctrlPressed}, shiftPressed:{shiftPressed}, lastSelectedItem:{lastSelectedItem}");

            // 다중 선택 비활성화
            if (!allowMultipleSelection)
            {
                ToggleItemSelection(data);
                return;
            }

            // Ctrl+클릭: 토글
            if (ctrlPressed)
            {
                ToggleItemSelection(data);
                lastSelectedItem = data;
            }
            // Shift+클릭: 범위 선택
            else if (shiftPressed)
            {
                if (lastSelectedItem != null)
                {
                    // 마지막 선택부터 현재 아이템까지 범위 선택
                    SelectRange(lastSelectedItem, data);
                }
                else
                {
                    // 아직 선택한 게 없으면 단순 선택
                    ClearSelection();
                    SelectItem(data);
                }

                // 이 아이템을 "마지막 선택"으로 기억
                lastSelectedItem = data;
            }
            // 일반 클릭: 단일 선택
            else
            {
                if (data.IsSelected)
                {
                    // 이미 선택된 아이템을 다시 클릭 → 선택 해제
                    DeselectItem(data);
                    lastSelectedItem = null;
                }
                else
                {
                    // 선택되지 않은 아이템 클릭 → 다른 선택 모두 해제하고 이것 선택
                    ClearSelection();
                    SelectItem(data);
                    lastSelectedItem = data;
                }
            }
        }

        /// <summary>
        /// 두 아이템 사이의 범위 선택
        /// 
        /// 동작:
        ///   1. 평탄화 리스트에서 두 아이템의 인덱스 찾기
        ///   2. 범위 정렬 (시작 ≤ 끝)
        ///   3. 범위 내 모든 아이템 선택
        /// 
        /// 매개변수:
        ///   - startItem: 범위 시작 아이템
        ///   - endItem: 범위 끝 아이템
        /// </summary>
        /// <param name="startItem">범위 시작 아이템</param>
        /// <param name="endItem">범위 끝 아이템</param>
        protected void SelectRange(TreeListItemData startItem, TreeListItemData endItem)
        {
            // 평탄화 리스트에서 시작 아이템의 위치(인덱스) 찾기
            int startIndex = allItemDataFlattened.IndexOf(startItem);

            // 평탄화 리스트에서 끝 아이템의 위치(인덱스) 찾기
            int endIndex = allItemDataFlattened.IndexOf(endItem);

            // 두 아이템 모두 리스트에 없으면 종료
            if (startIndex == -1 || endIndex == -1)
            {
                return;
            }

            // 시작과 끝의 순서를 정렬
            // 사용자가 거꾸로 선택할 수도 있으므로 (끝→시작)
            // 항상 작은 인덱스 = 시작, 큰 인덱스 = 끝으로 정렬
            int minIndex = Mathf.Min(startIndex, endIndex);
            int maxIndex = Mathf.Max(startIndex, endIndex);

            // 범위 내의 모든 아이템 선택
            // i = minIndex부터 i = maxIndex까지 (포함)
            for (int i = minIndex; i <= maxIndex; i++)
            {
                SelectItem(allItemDataFlattened[i]);
            }
        }

        /// <summary>
        /// 아이템 선택 상태 토글
        /// 
        /// 동작:
        ///   - 선택됨 → 해제
        ///   - 미선택 → 선택
        /// </summary>
        /// <param name="data">토글할 아이템</param>
        public void ToggleItemSelection(TreeListItemData data)
        {
            if (data.IsSelected)
            {
                // 선택됨 → 해제
                DeselectItem(data);
            }
            else
            {
                // 선택 안 됨 → 선택
                SelectItem(data);
            }
        }

        /// <summary>
        /// 이름으로 아이템 선택
        /// </summary>
        /// <param name="name"></param>
        public void SelectItem(string name)
        {
            var item = allItemDataFlattened.FirstOrDefault(x => x.Name == name);
            if (item != null)
            {
                SelectItem(item);
            }
        }

        /// <summary>
        /// 아이템 선택
        /// 
        /// 동작:
        ///   1. 중복 선택 방지
        ///   2. 다중 선택 비활성화 시 기존 선택 해제
        ///   3. 아이템 선택 표시
        ///   4. 선택 리스트에 추가
        ///   5. 선택 변경 이벤트 발생
        /// </summary>
        /// <param name="data">선택할 아이템</param>
        public void SelectItem(TreeListItemData data)
        {
            // 이미 선택되어 있으면 중복 선택 방지
            if (data.IsSelected && selectedItems.Contains(data))
            {
                return;
            }

            // 다중 선택이 불가능한 경우, 기존 선택 해제
            // (새 선택만 유지)
            if (!allowMultipleSelection && selectedItems.Count > 0)
            {
                //선택 항목 해제
                ClearSelection();
            }

            // 아이템의 선택 상태를 true로 설정
            data.IsSelected = true;

            // 아직 리스트에 없으면 추가
            if (!selectedItems.Contains(data))
            {
                selectedItems.Add(data);
            }

            // View에 알리고 이벤트 발생
            NotifySelectionChanged(data, true);
        }

        /// <summary>
        /// 이름으로 아이템 선택 해제
        /// </summary>
        /// <param name="name"></param>
        public void DeselectItem(string name)
        {
            var item = allItemDataFlattened.FirstOrDefault(x => x.Name == name);
            if (item != null)
            {
                DeselectItem(item);
            }
        }

        /// <summary>
        /// 아이템 선택 해제
        ///
        /// 동작:
        ///   1. 중복 해제 방지
        ///   2. 아이템 선택 상태 해제
        ///   3. 선택 리스트에서 제거
        ///   4. 선택 변경 이벤트 발생
        /// </summary>
        /// <param name="data">선택 해제할 아이템</param>
        public void DeselectItem(TreeListItemData data)
        {
            // 이미 선택 해제되어 있으면 아무것도 안 함
            if (!data.IsSelected)
            {
                return;
            }

            // 아이템의 선택 상태를 false로 설정
            data.IsSelected = false;

            // selectedItems 리스트에서 제거
            selectedItems.Remove(data);

            // View에 알리고 이벤트 발생
            NotifySelectionChanged(data, false);
        }

        /// <summary>
        /// 모든 아이템 선택 해제
        /// 
        /// 동작:
        ///   1. 선택 리스트 복사 (반복 중 수정 방지)
        ///   2. 각 아이템에 대해 DeselectItem() 호출
        /// </summary>
        public void ClearSelection()
        {
            // ToList()로 복사
            // = selectedItems의 현재 상태를 새로운 리스트로 만듦
            // 반복 중에 원본을 수정해도 안전하게 함
            foreach (var item in selectedItems.ToList())
            {
                DeselectItem(item);
            }
        }

        /// <summary>
        /// 다중 선택 활성화/비활성화 설정
        /// 
        /// 동작:
        ///   1. allowMultipleSelection 값 변경
        ///   2. false로 변경 시 여러 선택이 있으면 첫 번째만 유지
        /// </summary>
        /// <param name="allow">true: 다중 선택 허용, false: 단일 선택만 허용</param>
        public void SetAllowMultipleSelection(bool allow)
        {
            // 다중 선택 가능 여부 설정
            allowMultipleSelection = allow;

            // false로 변경되었는데 여러 개가 선택되어 있으면 정리
            if (!allow && selectedItems.Count > 1)
            {
                // 첫 번째 아이템 보관
                var firstItem = selectedItems[0];

                // 모든 선택 해제
                ClearSelection();

                // 첫 번째 아이템만 다시 선택
                SelectItem(firstItem);
            }
        }

        /// <summary>
        /// 드롭 완료 후 UI 업데이트
        /// </summary>
        /// <param name="draggedItem">드래그된 아이템</param>
        /// <param name="targetItem">드롭 대상 아이템 (null: 루트)</param>
        protected void HandleItemDropped(TreeListItemData draggedItem, TreeListItemData? targetItem)
        {
            // 평탄화 리스트 업데이트
            UpdateFlattenedItemDataList();

            // 필요시 UI 재구성 (예: 자식 컨테이너 위치 변경 등)
            //Debug.Log($"Item '{draggedItem.Name}' dropped on '{(targetItem?.Name ?? "Root")}'");
        }

        /// <summary>
        /// 지정한 데이터 항목을 트리에서 찾아 부모 체인을 펼치고 선택합니다.
        /// 기존 선택이 있으면 해제합니다.
        /// </summary>
        /// <param name="data">선택 및 표시할 데이터 (트리의 실제 데이터 참조)</param>
        /// <param name="clearExisting">true면 기존 선택을 모두 해제</param>
        public void RevealAndSelectItem(TreeListItemData? data, bool clearExisting = true)
        {
            if (data == null) return;

            if (clearExisting)
            {
                ClearSelection();
            }

            // 부모 체인 펼치기
            var parent = data.Parent;
            while (parent != null)
            {
                SetItemExpanded(parent, true);
                parent = parent.Parent;
            }

            // 평탄화 리스트 갱신 및 대상 선택
            UpdateFlattenedItemDataList();
            SelectItem(data);
        }

    }
}