#nullable enable
using Gpm.Ui;
using System;
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using UVC.Extention;
using UVC.Factory.Component;
using UVC.Locale;
using UVC.UI.Modal;

namespace UVC.UI.List.ComponentList
{
    /// <summary>
    /// 컴포넌트 목록 UI를 관리하는 클래스입니다.
    /// InfiniteScroll을 사용하여 대량의 데이터를 효율적으로 표시하고,
    /// 검색 및 필터링 기능을 제공합니다.
    /// </summary>
    public class ComponentList : MonoBehaviour
    {
        [Tooltip("데이터를 표시할 InfiniteScroll 컴포넌트입니다.")]
        [SerializeField]
        protected InfiniteScroll? scrollList = null;

        [Tooltip("검색어 입력을 위한 TMP_InputField 컴포넌트입니다.")]
        [SerializeField]
        protected TMP_InputField? inputField = null;

        // InfiniteScroll에 표시될 원본 데이터 리스트입니다.
        protected List<ComponentListItemData>? data;
        protected List<ComponentListItemData>? filteredData;

        /// <summary>
        /// SingletonScene 초기화 과정에서 호출됩니다.
        /// 필요한 컴포넌트를 찾고, 이벤트 리스너를 등록합니다.
        /// </summary>
        protected void Start()
        {
            // scrollList가 인스펙터에서 할당되지 않았을 경우, 자식에서 찾아봅니다.
            if (scrollList == null)
            {
                scrollList = GetComponentInChildren<InfiniteScroll>();
            }

            if (scrollList == null)
            {
                Debug.LogError("InfiniteScroll component is not assigned or found in Children.");
                return;
            }

            // inputField가 인스펙터에서 할당되지 않았을 경우, 자식에서 찾아봅니다.
            if (inputField == null)
            {
                inputField = GetComponentInChildren<TMP_InputField>();
            }
            if (inputField != null)
            {
                // 사용자가 검색어를 입력하고 Enter 키를 누르거나 입력을 완료했을 때 OnInputFieldChanged 메서드가 호출되도록 이벤트를 등록합니다.
                //inputField.onEndEdit.AddListener(OnInputFieldChanged);
                inputField.onSubmit.AddListener(OnInputFieldChanged);
            }
        }

        protected void OnDestroy()
        {
            if (inputField != null)
            {
                // Init에서 등록한 리스너를 제거합니다.
                //inputField.onEndEdit.RemoveListener(OnInputFieldChanged);
                inputField.onSubmit.RemoveListener(OnInputFieldChanged);
            }
        }

        /// <summary>
        /// FactoryObjectManager에서 데이터를 가져와 스크롤 리스트를 설정합니다.
        /// 데이터를 카테고리별로 그룹화하고, 각 카테고리와 해당 항목들을 리스트에 추가합니다.
        /// </summary>
        public virtual void SetupData(SortedDictionary<string, List<FactoryObjectInfo>> objectsData)
        {
            if (scrollList == null)
            {
                Debug.LogError("InfiniteScroll component is not assigned.");
                return;
            }

            if (inputField != null) inputField.text = string.Empty;

            //toggle 않된 카테고리 찾기
            List<string> notExpendedCategory = new List<string>();
            if (scrollList.GetDataCount() > 0)
            {
                List<InfiniteScrollData> scrollDatalist = scrollList.GetDataList();
                foreach (var data in scrollDatalist)
                {
                    if (data is ComponentListItemData itemData && itemData.isCategory)
                    {
                        itemData.OnCategoryExpendAction = null;
                        if (!itemData.isExpanded) notExpendedCategory.Add(itemData.categoryName);
                    }
                }
            }

            //transform.SetAsFirstSibling();
            scrollList.ClearData(); // 스크롤 리스트의 기존 데이터를 모두 비웁니다.

            if (data != null) data?.Clear();
            data = new List<ComponentListItemData>();

            // 1. FactoryObjectManager에서 카테고리별로 그룹화된 객체 정보를 가져옵니다.
            //var infos = FactoryObjectManager.Instance.GetFactoryObjectInfosByCategory();

            //보여주기 용 list
            List<ComponentListItemData> listData = new List<ComponentListItemData>();

            // 2. 각 카테고리에 대해 루프를 돕니다.
            foreach (var info in objectsData)
            {
                bool isExpended = !notExpendedCategory.Contains(info.Key);
                // 2-1. 카테고리 아이템 데이터를 추가합니다.
                var categoryData = new ComponentListItemData
                {
                    isCategory = true,
                    categoryName = info.Key, // 카테고리 이름 (예: "전기 설비")
                    categoryBadgeCount = info.Value.Count, // 해당 카테고리의 항목 수
                    OnCategoryExpendAction = ToggleCategory, // 액션 할당
                    isExpanded = isExpended,
                };
                data.Add(categoryData);
                listData.Add(categoryData);


                // 2-2. 해당 카테고리에 속한 모든 일반 항목 데이터를 추가합니다.
                foreach (var item in info.Value)
                {
                    var itemData = new ComponentListItemData
                    {
                        isCategory = false,
                        generalName = item.Name, // 항목 이름 (예: "분전반")
                        generalOption = item.Floor, // 항목 옵션 (예: "1F")
                        factoryObjectInfo = item // 이 항목이 속한 카테고리 이름 (필터링을 위해 필요)
                    };
                    data.Add(itemData);
                    //카테고리가 축소된 상태라면, 자식 항목들을 추가하지 않고 다음 카테고리로 넘어갑니다.
                    if (isExpended) listData.Add(itemData);
                }
            }

            // 3. 완성된 데이터 리스트를 InfiniteScroll에 한 번에 삽입하여 UI를 업데이트합니다.
            scrollList.InsertData(listData.ToArray());
        }

        /// <summary>
        /// 카테고리의 확장/축소 상태를 토글하고, 그에 따라 자식 아이템들의 표시 여부를 업데이트합니다.
        /// </summary>
        /// <param name="categoryData">상태를 변경할 카테고리 데이터</param>
        public virtual void ToggleCategory(ComponentListItemData categoryData)
        {
            if (scrollList == null || data == null) return;

            // 1. 현재 스크롤 리스트에서 토글할 카테고리의 인덱스를 찾습니다.
            List<InfiniteScrollData> scrollDatalist = scrollList.GetDataList();
            int categoryIndex = scrollDatalist.FindIndex(0, (item) =>
            {
                if (item is ComponentListItemData data) return data.categoryName == categoryData.categoryName;
                return false;
            });

            if (categoryIndex == -1) return; // 카테고리를 찾지 못하면 중단

            List<ComponentListItemData> list = filteredData != null ? filteredData : data;

            // 2. 카테고리의 확장 상태를 변경합니다.
            categoryData.isExpanded = !categoryData.isExpanded;

            // 3. 확장/축소 상태에 따라 자식 아이템을 추가하거나 제거합니다.
            if (categoryData.isExpanded) // 카테고리 확장
            {
                // 원본 데이터 리스트에서 이 카테고리에 속한 자식들을 찾습니다.
                int originalDataIndex = list.IndexOf(categoryData);
                if (originalDataIndex != -1)
                {
                    var childrenToAdd = list.Skip(originalDataIndex + 1)
                                            .Take(categoryData.categoryBadgeCount)
                                            .ToArray();

                    // 카테고리 바로 다음 위치에 자식 아이템들을 삽입합니다.
                    if (childrenToAdd.Length > 0)
                    {
                        scrollList.InsertData(childrenToAdd, categoryIndex + 1, true);
                    }
                }
            }
            else // 카테고리 축소
            {
                // 카테고리 바로 다음에 있는 자식 아이템들을 제거합니다.
                // 한 번에 하나씩 제거하므로, 항상 categoryIndex + 1 위치의 아이템을 제거합니다.
                for (int i = 0; i < categoryData.categoryBadgeCount; i++)
                {
                    // 제거할 아이템이 리스트 범위 내에 있는지 확인
                    if (categoryIndex + 1 < scrollList.GetDataCount())
                    {
                        scrollList.RemoveData(categoryIndex + 1, true);
                    }
                    else
                    {
                        break; // 범위를 벗어나면 중단
                    }
                }
            }
        }


        /// <summary>
        /// 검색 입력 필드의 내용이 변경되고 제출(Enter)되었을 때 호출됩니다.
        /// 입력된 텍스트를 기반으로 scrollList의 내용을 필터링합니다.
        /// </summary>
        /// <param name="text">사용자가 입력한 검색어</param>
        protected virtual void OnInputFieldChanged(string text)
        {
            Debug.Log($"Searching1 for: {text}");
            if (scrollList == null || inputField == null) return;
            // 검색어가 비어있으면 필터링을 수행하지 않습니다.
            if (string.IsNullOrEmpty(text)) return;

            // 검색어가 너무 짧으면 사용자에게 알림을 표시하고 입력을 초기화합니다.
            if (text.Length < 3)
            {
                inputField.text = string.Empty;  // 입력 필드 초기화
                inputField.ActivateInputField(); // 입력 필드에 다시 포커스 설정
                Toast.Show("검색어는 3글자 이상 입력해주세요.", 2f);
                return;
            }

            Debug.Log($"Searching2 for: {text}");

            // 특수 필터 키워드가 있는지 확인합니다.
            // 예: "@Category 전기" -> '전기' 카테고리 필터
            bool hasCategoryFilter = text.StartsWith("@Category ");
            bool hasAreaFilter = text.StartsWith("@Area ");
            bool hasFloorFilter = text.StartsWith("@Floor ");

            // 원본 데이터(data)를 기반으로 필터링된 새로운 리스트를 생성합니다.
            List<ComponentListItemData> filteredItems = data.Where(itemData =>
            {
                if (itemData.isCategory) return false; // 카테고리 항목은 항상 제외

                if (hasCategoryFilter)
                {
                    string categoryText = text.Substring("@Category ".Length).Trim();
                    return itemData.categoryName.Contains(categoryText, StringComparison.OrdinalIgnoreCase);
                }
                else if (hasAreaFilter)
                {
                    string areaText = text.Substring("@Area ".Length).Trim();
                    return itemData.factoryObjectInfo?.Area.Contains(areaText, StringComparison.OrdinalIgnoreCase) == true;
                }
                else if (hasFloorFilter)
                {
                    string floorText = text.Substring("@Floor ".Length).Trim();
                    return itemData.factoryObjectInfo?.Floor.Contains(floorText, StringComparison.OrdinalIgnoreCase) == true;
                }
                else
                {
                    return itemData.generalName.Contains(text, StringComparison.OrdinalIgnoreCase);
                }
            }).ToList();

            if (filteredData == null)
            {
                filteredData = new List<ComponentListItemData>();
            }
            else
            {
                filteredData.Clear();
            }
            string resultText = LocalizationManager.Instance.GetString("검색결과");

            // 검색 결과 카테고리 아이템을 추가합니다.
            filteredData.Add(new ComponentListItemData
            {
                isCategory = true,
                categoryName = $"{resultText}: {filteredItems.Count}건",
                categoryBadgeCount = filteredItems.Count,
                isExpanded = true, // 검색 결과는 항상 펼쳐진 상태로 시작
                OnCategoryExpendAction = ToggleCategory // 액션 할당
            });

            // 필터링된 아이템들을 결과 리스트에 추가합니다.
            filteredData.AddRange(filteredItems);

            // 스크롤 리스트를 비우고 필터링된 결과로 새로 채웁니다.
            scrollList.Clear();
            scrollList.InsertData(filteredData.ToArray(), true);
        }

        public void SetSearchText(string text)
        {
            if (inputField != null)
            {
                inputField.text = $"@{text} ";
                inputField.SetCaretToEndAsync().Forget();
            }
        }


        /// <summary>
        /// 검색창의 'X' 버튼 클릭 시 호출됩니다.
        /// 입력 필드를 비우고, 적용되었던 모든 필터를 제거합니다.
        /// </summary>
        public virtual void OnClickClearText()
        {
            if (inputField != null && scrollList != null && data != null)
            {
                inputField.text = string.Empty; // 입력 필드 초기화
                inputField.ActivateInputField(); // 입력 필드에 다시 포커스 설정
                if (filteredData != null)
                {
                    // 각 아이템의 Action 참조를 명시적으로 해제하여 메모리 누수 가능성을 방지합니다.
                    foreach (var item in filteredData)
                    {
                        item.OnCategoryExpendAction = null;
                    }
                    filteredData.Clear(); // 필터링된 데이터 리스트를 비웁니다.
                    filteredData = null;
                }
                // scrollList에 설정된 필터를 제거(null)하여 모든 항목이 보이도록 합니다.
                scrollList.SetFilter(null);
                scrollList.ClearData(); // 스크롤 리스트의 내용을 비웁니다.
                scrollList.InsertData(data.ToArray());
            }
        }


    }
}