#nullable enable
using System;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UIElements;
using UVC.UIToolkit;

/// <summary>
/// UTKMultiSelectDropdown 컴포넌트 샘플
/// UXML 파일을 로드하여 쿼리 방식으로 사용하는 예제
/// </summary>
[RequireComponent(typeof(UIDocument))]
public class UTKMultiSelectDropdownSample : MonoBehaviour
{
    #region Enums
    /// <summary>게임 난이도</summary>
    public enum Difficulty
    {
        Easy,
        Normal,
        Hard,
        Expert
    }

    /// <summary>품질 설정</summary>
    public enum QualityLevel
    {
        Low,
        Medium,
        High,
        Ultra
    }

    /// <summary>파일 형식</summary>
    public enum FileFormat
    {
        PNG,
        JPG,
        GIF,
        BMP,
        TIFF
    }

    /// <summary>정렬 방식</summary>
    public enum SortOrder
    {
        Ascending,
        Descending
    }
    #endregion

    #region Fields
    [SerializeField]
    [Tooltip("UI를 표시할 UIDocument 컴포넌트")]
    public UIDocument? _uiDocument;

    [SerializeField]
    [Tooltip("시작 시 적용할 테마")]
    private UTKTheme initialTheme = UTKTheme.Dark;

    private UTKToggle _themeToggle;

    private VisualElement? _root;

    // 다중 선택 드롭다운 참조
    private UTKMultiSelectDropdown? _dropdownBasic;
    private UTKMultiSelectDropdown? _dropdownDefault;
    private UTKMultiSelectDropdown? _dropdownCategory;
    private UTKMultiSelectDropdown? _dropdownTag;
    private UTKMultiSelectDropdown? _dropdownSelectAll;
    private UTKMultiSelectDropdown? _dropdownDisabled;

    // 다중 선택 결과 라벨 참조
    private Label? _resultBasic;
    private Label? _resultDefault;
    private Label? _resultCategory;
    private Label? _resultTag;
    private Label? _resultSelectAll;

    // 버튼 참조
    private UTKButton? _btnSelectAll;
    private UTKButton? _btnClear;

    // 단일 선택 드롭다운 참조
    private UTKDropdown? _dropdownSingleBasic;
    private UTKDropdown? _dropdownSingleDefault;
    private UTKDropdown? _dropdownSingleSort;
    private UTKDropdown? _dropdownSingleDisabled;

    // 단일 선택 결과 라벨 참조
    private Label? _dropdownResultBasic;
    private Label? _dropdownResultDefault;
    private Label? _dropdownResultSort;

    // Enum 드롭다운 참조
    private UTKEnumDropDown? _enumDropdownDifficulty;
    private UTKEnumDropDown? _enumDropdownQuality;
    private UTKEnumDropDown? _enumDropdownFormat;
    private UTKEnumDropDown? _enumDropdownDisabled;

    // Enum 결과 라벨 참조
    private Label? _enumResultDifficulty;
    private Label? _enumResultQuality;
    private Label? _enumResultFormat;
    #endregion

    #region Unity Lifecycle
    private void Start()
    {
        var doc = GetComponent<UIDocument>();
        if (doc == null)
        {
            Debug.LogError("UIDocument가 할당되지 않았습니다.");
            return;
        }
        _uiDocument = doc;

        var toggle = _uiDocument.rootVisualElement.Q<UTKToggle>("toggle");
        if (toggle == null)
        {
            Debug.LogError("UXML에서 UTKToggle을 찾을 수 없습니다.");
            return;
        }
        _themeToggle = toggle;

        UTKThemeManager.Instance.RegisterRoot(_uiDocument.rootVisualElement);
        UTKThemeManager.Instance.SetTheme(initialTheme);
        
        _themeToggle.OnValueChanged += (isOn) =>
        {
            UTKThemeManager.Instance.SetTheme(!isOn ? UTKTheme.Dark : UTKTheme.Light);
        };

        LoadUIFromUXML();
    }

    private void OnDestroy()
    {
        UnregisterEvents();
    }
    #endregion

    #region Setup
    private void LoadUIFromUXML()
    {
        // UIDocument 참조 확인
        var doc = GetComponent<UIDocument>();
        if (doc == null)
        {
            Debug.LogError("UIDocument가 할당되지 않았습니다.");
            return;
        }
        _uiDocument = doc;
        

        // UI 생성
        _root = _uiDocument.rootVisualElement;
        

        // 요소 쿼리
        QueryElements();

        // 초기 설정
        SetupInitialValues();

        // 이벤트 등록
        RegisterEvents();
    }

    private void QueryElements()
    {
        if (_root == null) return;

        // 다중 선택 드롭다운 쿼리
        _dropdownBasic = _root.Q<UTKMultiSelectDropdown>("dropdown-basic");
        _dropdownDefault = _root.Q<UTKMultiSelectDropdown>("dropdown-default");
        _dropdownCategory = _root.Q<UTKMultiSelectDropdown>("dropdown-category");
        _dropdownTag = _root.Q<UTKMultiSelectDropdown>("dropdown-tag");
        _dropdownSelectAll = _root.Q<UTKMultiSelectDropdown>("dropdown-selectall");
        _dropdownDisabled = _root.Q<UTKMultiSelectDropdown>("dropdown-disabled");

        // 다중 선택 결과 라벨 쿼리
        _resultBasic = _root.Q<Label>("result-basic");
        _resultDefault = _root.Q<Label>("result-default");
        _resultCategory = _root.Q<Label>("result-category");
        _resultTag = _root.Q<Label>("result-tag");
        _resultSelectAll = _root.Q<Label>("result-selectall");

        // 버튼 쿼리
        _btnSelectAll = _root.Q<UTKButton>("btn-selectall");
        _btnClear = _root.Q<UTKButton>("btn-clear");

        // 단일 선택 드롭다운 쿼리
        _dropdownSingleBasic = _root.Q<UTKDropdown>("dropdown-single-basic");
        _dropdownSingleDefault = _root.Q<UTKDropdown>("dropdown-single-default");
        _dropdownSingleSort = _root.Q<UTKDropdown>("dropdown-single-sort");
        _dropdownSingleDisabled = _root.Q<UTKDropdown>("dropdown-single-disabled");

        // 단일 선택 결과 라벨 쿼리
        _dropdownResultBasic = _root.Q<Label>("dropdown-result-basic");
        _dropdownResultDefault = _root.Q<Label>("dropdown-result-default");
        _dropdownResultSort = _root.Q<Label>("dropdown-result-sort");

        // Enum 드롭다운 쿼리
        _enumDropdownDifficulty = _root.Q<UTKEnumDropDown>("enum-dropdown-difficulty");
        _enumDropdownQuality = _root.Q<UTKEnumDropDown>("enum-dropdown-quality");
        _enumDropdownFormat = _root.Q<UTKEnumDropDown>("enum-dropdown-format");
        _enumDropdownDisabled = _root.Q<UTKEnumDropDown>("enum-dropdown-disabled");

        // Enum 결과 라벨 쿼리
        _enumResultDifficulty = _root.Q<Label>("enum-result-difficulty");
        _enumResultQuality = _root.Q<Label>("enum-result-quality");
        _enumResultFormat = _root.Q<Label>("enum-result-format");
    }

    private void SetupInitialValues()
    {
        // [다중 선택] 샘플 2: 기본값 설정 (한국어, English 선택)
        _dropdownDefault?.SetSelectedIndices(new List<int> { 0, 1 }, notify: false);
        if (_resultDefault != null && _dropdownDefault != null)
        {
            _resultDefault.text = $"선택 언어: {string.Join(", ", _dropdownDefault.SelectedValues)}";
        }

        // [다중 선택] 샘플 6: 비활성화 드롭다운 기본값 설정
        _dropdownDisabled?.SetSelectedIndices(new List<int> { 0, 2 }, notify: false);

        // [단일 선택] 샘플 2: 기본값 설정 (한국어 선택)
        if (_dropdownResultDefault != null && _dropdownSingleDefault != null)
        {
            _dropdownResultDefault.text = $"선택 언어: {_dropdownSingleDefault.SelectedValue}";
        }

        // [Enum] 샘플 1: 난이도 드롭다운 초기화
        _enumDropdownDifficulty?.Init(Difficulty.Normal);
        if (_enumResultDifficulty != null && _enumDropdownDifficulty != null)
        {
            _enumResultDifficulty.text = $"선택 난이도: {_enumDropdownDifficulty.Value}";
        }

        // [Enum] 샘플 2: 품질 드롭다운 초기화
        _enumDropdownQuality?.Init(QualityLevel.High);

        // [Enum] 샘플 3: 파일 형식 드롭다운 초기화
        _enumDropdownFormat?.Init(FileFormat.PNG);
        if (_enumResultFormat != null && _enumDropdownFormat != null)
        {
            _enumResultFormat.text = $"선택 형식: {_enumDropdownFormat.Value}";
        }

        // [Enum] 샘플 4: 비활성화 드롭다운 초기화
        _enumDropdownDisabled?.Init(SortOrder.Ascending);
    }

    private void RegisterEvents()
    {
        // [다중 선택] 샘플 1: 기본 다중 선택 드롭다운
        if (_dropdownBasic != null && _resultBasic != null)
        {
            _dropdownBasic.OnSelectionChanged += OnBasicSelectionChanged;
        }

        // [다중 선택] 샘플 2: 기본값이 있는 드롭다운
        if (_dropdownDefault != null && _resultDefault != null)
        {
            _dropdownDefault.OnSelectionChanged += OnDefaultSelectionChanged;
        }

        // [다중 선택] 샘플 3: 카테고리 필터
        if (_dropdownCategory != null && _resultCategory != null)
        {
            _dropdownCategory.OnSelectionChanged += OnCategorySelectionChanged;
        }

        // [다중 선택] 샘플 4: 태그 선택기
        if (_dropdownTag != null && _resultTag != null)
        {
            _dropdownTag.OnSelectionChanged += OnTagSelectionChanged;
        }

        // [다중 선택] 샘플 5: 전체 선택/해제
        if (_dropdownSelectAll != null && _resultSelectAll != null)
        {
            _dropdownSelectAll.OnSelectionChanged += OnSelectAllSelectionChanged;
        }

        if (_btnSelectAll != null)
        {
            _btnSelectAll.OnClicked += OnSelectAllButtonClicked;
        }

        if (_btnClear != null)
        {
            _btnClear.OnClicked += OnClearButtonClicked;
        }

        // [단일 선택] 샘플 1: 기본 단일 선택 드롭다운
        if (_dropdownSingleBasic != null && _dropdownResultBasic != null)
        {
            _dropdownSingleBasic.OnSelectionChanged += OnDropdownBasicSelectionChanged;
        }

        // [단일 선택] 샘플 2: 기본값이 있는 드롭다운
        if (_dropdownSingleDefault != null && _dropdownResultDefault != null)
        {
            _dropdownSingleDefault.OnSelectionChanged += OnDropdownDefaultSelectionChanged;
        }

        // [단일 선택] 샘플 3: 정렬 옵션
        if (_dropdownSingleSort != null && _dropdownResultSort != null)
        {
            _dropdownSingleSort.OnSelectionChanged += OnDropdownSortSelectionChanged;
        }

        // [Enum] 샘플 1: 난이도 선택
        if (_enumDropdownDifficulty != null && _enumResultDifficulty != null)
        {
            _enumDropdownDifficulty.OnValueChanged += OnEnumDifficultyChanged;
        }

        // [Enum] 샘플 2: 품질 선택
        if (_enumDropdownQuality != null && _enumResultQuality != null)
        {
            _enumDropdownQuality.OnValueChanged += OnEnumQualityChanged;
        }

        // [Enum] 샘플 3: 파일 형식 선택
        if (_enumDropdownFormat != null && _enumResultFormat != null)
        {
            _enumDropdownFormat.OnValueChanged += OnEnumFormatChanged;
        }
    }

    private void UnregisterEvents()
    {
        if (_dropdownBasic != null)
        {
            _dropdownBasic.OnSelectionChanged -= OnBasicSelectionChanged;
        }

        if (_dropdownDefault != null)
        {
            _dropdownDefault.OnSelectionChanged -= OnDefaultSelectionChanged;
        }

        if (_dropdownCategory != null)
        {
            _dropdownCategory.OnSelectionChanged -= OnCategorySelectionChanged;
        }

        if (_dropdownTag != null)
        {
            _dropdownTag.OnSelectionChanged -= OnTagSelectionChanged;
        }

        if (_dropdownSelectAll != null)
        {
            _dropdownSelectAll.OnSelectionChanged -= OnSelectAllSelectionChanged;
        }

        if (_btnSelectAll != null)
        {
            _btnSelectAll.OnClicked -= OnSelectAllButtonClicked;
        }

        if (_btnClear != null)
        {
            _btnClear.OnClicked -= OnClearButtonClicked;
        }

        // [단일 선택] 이벤트 해제
        if (_dropdownSingleBasic != null)
        {
            _dropdownSingleBasic.OnSelectionChanged -= OnDropdownBasicSelectionChanged;
        }

        if (_dropdownSingleDefault != null)
        {
            _dropdownSingleDefault.OnSelectionChanged -= OnDropdownDefaultSelectionChanged;
        }

        if (_dropdownSingleSort != null)
        {
            _dropdownSingleSort.OnSelectionChanged -= OnDropdownSortSelectionChanged;
        }

        // [Enum] 이벤트 해제
        if (_enumDropdownDifficulty != null)
        {
            _enumDropdownDifficulty.OnValueChanged -= OnEnumDifficultyChanged;
        }

        if (_enumDropdownQuality != null)
        {
            _enumDropdownQuality.OnValueChanged -= OnEnumQualityChanged;
        }

        if (_enumDropdownFormat != null)
        {
            _enumDropdownFormat.OnValueChanged -= OnEnumFormatChanged;
        }
    }
    #endregion

    #region Event Handlers
    private void OnBasicSelectionChanged(List<int> indices, List<string> values)
    {
        if (_resultBasic == null) return;

        Debug.Log($"[기본 샘플] 선택된 개수: {values.Count}");
        Debug.Log($"[기본 샘플] 선택 항목: {string.Join(", ", values)}");

        _resultBasic.text = values.Count > 0
            ? $"선택 결과: {string.Join(", ", values)}"
            : "선택 결과: 없음";
    }

    private void OnDefaultSelectionChanged(List<int> indices, List<string> values)
    {
        if (_resultDefault == null) return;

        Debug.Log($"[기본값 샘플] 선택 언어: {string.Join(", ", values)}");

        _resultDefault.text = values.Count > 0
            ? $"선택 언어: {string.Join(", ", values)}"
            : "선택 언어: 없음";
    }

    private void OnCategorySelectionChanged(List<int> indices, List<string> values)
    {
        if (_resultCategory == null) return;

        var categoryText = values.Count > 0
            ? string.Join(", ", values)
            : "전체";

        Debug.Log($"[카테고리 필터] 선택된 카테고리: {categoryText}");

        // 실제로는 여기서 필터링 로직 수행
        _resultCategory.text = values.Count > 0
            ? $"필터링된 항목: {values.Count * 15}개 (예시)"
            : "필터링된 항목: 전체 120개";
    }

    private void OnTagSelectionChanged(List<int> indices, List<string> values)
    {
        if (_resultTag == null) return;

        _resultTag.text = values.Count > 0
            ? $"적용된 태그: [{string.Join("] [", values)}]"
            : "적용된 태그: 없음";
    }

    private void OnSelectAllSelectionChanged(List<int> indices, List<string> values)
    {
        if (_resultSelectAll == null) return;

        _resultSelectAll.text = values.Count > 0
            ? $"선택된 권한: {string.Join(", ", values)}"
            : "선택된 권한: 없음";
    }

    private void OnSelectAllButtonClicked()
    {
        _dropdownSelectAll?.SelectAll();
        Debug.Log("[전체 선택] 모든 권한 선택됨");
    }

    private void OnClearButtonClicked()
    {
        _dropdownSelectAll?.ClearSelection();
        Debug.Log("[전체 해제] 모든 권한 해제됨");
    }

    // [단일 선택] 이벤트 핸들러
    private void OnDropdownBasicSelectionChanged(int index, string value)
    {
        if (_dropdownResultBasic == null) return;

        Debug.Log($"[단일 선택 - 기본] 선택: [{index}] {value}");

        _dropdownResultBasic.text = !string.IsNullOrEmpty(value)
            ? $"선택 결과: {value}"
            : "선택 결과: 없음";
    }

    private void OnDropdownDefaultSelectionChanged(int index, string value)
    {
        if (_dropdownResultDefault == null) return;

        Debug.Log($"[단일 선택 - 기본값] 선택 언어: {value}");

        _dropdownResultDefault.text = !string.IsNullOrEmpty(value)
            ? $"선택 언어: {value}"
            : "선택 언어: 없음";
    }

    private void OnDropdownSortSelectionChanged(int index, string value)
    {
        if (_dropdownResultSort == null) return;

        Debug.Log($"[단일 선택 - 정렬] 정렬 방식: {value}");

        // 실제로는 여기서 정렬 로직 수행
        _dropdownResultSort.text = !string.IsNullOrEmpty(value)
            ? $"정렬 방식: {value}"
            : "정렬 방식: 없음";
    }

    // [Enum] 이벤트 핸들러
    private void OnEnumDifficultyChanged(Enum? value)
    {
        if (_enumResultDifficulty == null) return;

        if (value is Difficulty difficulty)
        {
            Debug.Log($"[Enum - 난이도] 선택: {difficulty}");
            _enumResultDifficulty.text = $"선택 난이도: {difficulty}";

            // 실제로는 여기서 난이도 적용 로직 수행
            switch (difficulty)
            {
                case Difficulty.Easy:
                    Debug.Log("쉬운 난이도 적용");
                    break;
                case Difficulty.Normal:
                    Debug.Log("보통 난이도 적용");
                    break;
                case Difficulty.Hard:
                    Debug.Log("어려운 난이도 적용");
                    break;
                case Difficulty.Expert:
                    Debug.Log("전문가 난이도 적용");
                    break;
            }
        }
        else
        {
            _enumResultDifficulty.text = "선택 난이도: 없음";
        }
    }

    private void OnEnumQualityChanged(Enum? value)
    {
        if (_enumResultQuality == null) return;

        if (value is QualityLevel quality)
        {
            Debug.Log($"[Enum - 품질] 선택: {quality}");
            _enumResultQuality.text = $"선택 품질: {quality}";

            // 실제로는 여기서 품질 설정 로직 수행
            switch (quality)
            {
                case QualityLevel.Low:
                    Debug.Log("낮은 품질 적용");
                    break;
                case QualityLevel.Medium:
                    Debug.Log("중간 품질 적용");
                    break;
                case QualityLevel.High:
                    Debug.Log("높은 품질 적용");
                    break;
                case QualityLevel.Ultra:
                    Debug.Log("최고 품질 적용");
                    break;
            }
        }
        else
        {
            _enumResultQuality.text = "선택 품질: 없음";
        }
    }

    private void OnEnumFormatChanged(Enum? value)
    {
        if (_enumResultFormat == null) return;

        if (value is FileFormat format)
        {
            Debug.Log($"[Enum - 파일 형식] 선택: {format}");
            _enumResultFormat.text = $"선택 형식: {format}";

            // 실제로는 여기서 파일 형식 설정 로직 수행
            Debug.Log($"파일을 {format} 형식으로 저장합니다.");
        }
        else
        {
            _enumResultFormat.text = "선택 형식: 없음";
        }
    }
    #endregion
}