using System.Collections.Generic;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using UVC.Extension;
using UVC.Locale;
using UVC.UI.Tooltip;

namespace UVC.UI.Toolbar
{
    /// <summary>
    /// ToolbarModel에 정의된 데이터를 기반으로 실제 툴바 UI를 생성하고 관리하는 MonoBehaviour 클래스입니다.
    /// 사용자의 UI 상호작용을 감지하여 모델의 상태를 변경하거나 커맨드를 실행하고,
    /// 모델의 상태 변경에 따라 UI를 업데이트합니다.
    /// </summary>
    /// <remarks>
    /// 주요 역할:
    /// - UI 렌더링: ToolbarModel의 Items 리스트를 순회하며 각 항목에 맞는 UI GameObject(버튼, 구분선 등)를 프리팹으로부터 생성하여 화면에 표시합니다.
    /// - 이벤트 바인딩: 생성된 UI 요소(예: Unity Button의 onClick)와 ToolbarButtonBase 모델의 ExecuteClick 메서드를 연결합니다.
    ///   또한, 모델의 OnStateChanged, OnToggleStateChanged 등의 이벤트를 구독하여 모델 상태 변경 시 UI를 업데이트합니다.
    /// - UI 업데이트: 모델의 상태(텍스트, 아이콘, 활성화 상태, 선택 상태 등)가 변경되면 해당 UI 요소의 시각적 표현을 업데이트합니다.
    /// - 리소스 관리: 생성된 UI GameObject들과 이벤트 구독을 관리하며, 툴바가 파괴되거나 다시 렌더링될 때 정리합니다(ClearToolbar).
    /// - 하위 메뉴 관리: ToolbarExpandableButton 클릭 시 하위 메뉴 UI를 생성하고 토글합니다.
    /// - 툴팁 관리: 각 버튼에 TooltipHandler를 추가하여 툴팁 기능을 제공합니다.
    /// 
    /// 이 클래스의 인스턴스는 Unity 씬 내의 GameObject에 컴포넌트로 추가되어야 하며,
    /// Inspector를 통해 필요한 프리팹들(standardButtonPrefab, toggleButtonPrefab 등)과
    /// UI 요소들이 배치될 부모 Transform(toolbarContainer), LayoutGroup 등을 할당받아야 합니다.
    /// </remarks>
    /// <example>
    /// <code>
    /// // 1. Unity 에디터에서 빈 GameObject를 만들고 ToolbarView 스크립트를 추가합니다.
    /// // 2. Inspector에서 ToolbarView 컴포넌트의 다음 필드들을 설정합니다:
    /// //    - Standard Button Prefab: 표준 버튼 UI 프리팹
    /// //    - Toggle Button Prefab: 토글 버튼 UI 프리팹
    /// //    - Radio Button Prefab: 라디오 버튼 UI 프리팹
    /// //    - Expandable Button Prefab: 확장 버튼 UI 프리팹
    /// //    - Separator Prefab: 구분선 UI 프리팹
    /// //    - Sub Menu Panel Prefab: 확장 버튼의 하위 메뉴 패널 UI 프리팹
    /// //    - Toolbar Container: 생성된 툴바 항목 UI들이 자식으로 추가될 Transform (보통 이 GameObject 자체 또는 자식 Panel)
    /// //    - Layout Group: Toolbar Container에 연결된 LayoutGroup (예: VerticalLayoutGroup, HorizontalLayoutGroup)
    /// //    - Root Canvas: (선택 사항, TooltipManager 초기화에 필요하며 보통 자동으로 찾음)
    /// // 
    /// // 3. ToolbarController (또는 유사 클래스)에서 ToolbarModel을 설정한 후,
    /// //    ToolbarView의 Initialize 메서드를 호출하여 툴바 UI를 생성합니다.
    /// //    ToolbarController controller = GetComponent<ToolbarController>(); // 또는 다른 방식으로 참조
    /// //    ToolbarModel model = controller.GetConfiguredModel(); // 가정: 컨트롤러가 모델을 반환
    /// //    Initialize(model);
    /// </code>
    /// </example>
    public class ToolbarView : MonoBehaviour
    {
        /// <summary>
        /// 현재 툴바 UI의 기반이 되는 데이터 모델입니다.
        /// Initialize 메서드를 통해 외부(주로 ToolbarController)에서 주입받습니다.
        /// </summary>
        protected ToolbarModel ToolbarModel { get; private set; }

        // --- Inspector에서 할당할 프리팹 및 UI 요소들 ---
        [Header("UI Prefabs")]
        [Tooltip("표준 버튼 UI에 사용될 프리팹입니다.")]
        public GameObject standardButtonPrefab;
        [Tooltip("토글 버튼 UI에 사용될 프리팹입니다.")]
        public GameObject toggleButtonPrefab;
        [Tooltip("라디오 버튼 UI에 사용될 프리팹입니다.")]
        public GameObject radioButtonPrefab;
        [Tooltip("확장 가능한 버튼 UI에 사용될 프리팹입니다.")]
        public GameObject expandableButtonPrefab;
        [Tooltip("구분선 UI에 사용될 프리팹입니다.")]
        public GameObject separatorPrefab;
        [Tooltip("확장 버튼의 하위 메뉴 패널 UI에 사용될 프리팹입니다.")]
        public GameObject subMenuPanelPrefab;

        [Header("UI Layout")]
        [Tooltip("생성된 툴바 항목 UI들이 자식으로 추가될 부모 Transform입니다.")]
        public Transform toolbarContainer;
        [Tooltip("툴바 항목들의 자동 배치를 담당하는 LayoutGroup 컴포넌트입니다 (예: VerticalLayoutGroup).")]
        public LayoutGroup layoutGroup;

        /// <summary>
        /// 툴바 버튼 모델(ToolbarButtonBase)과 해당 모델을 나타내는 실제 UI GameObject를 매핑하는 딕셔너리입니다.
        /// 모델 상태 변경 시 해당 GameObject를 찾아 UI를 업데이트하거나, UI 정리 시 사용됩니다.
        /// </summary>
        protected Dictionary<ToolbarButtonBase, GameObject> _modelToGameObjectMap = new Dictionary<ToolbarButtonBase, GameObject>();

        /// <summary>
        /// 툴팁 표시에 사용될 루트 Canvas입니다.
        /// Inspector에서 할당하거나, Awake에서 자동으로 찾으려고 시도합니다.
        /// </summary>
        protected Canvas rootCanvas;

        /// <summary>
        /// MonoBehaviour의 Awake 메서드입니다.
        /// toolbarContainer, layoutGroup, rootCanvas 등의 필수 참조를 초기화하고,
        /// TooltipManager를 초기화합니다.
        /// </summary>
        protected virtual void Awake()
        {

            // toolbarContainer 자동 할당 (Inspector에서 할당되지 않은 경우)
            if (toolbarContainer == null) toolbarContainer = GetComponent<Transform>();
            if (toolbarContainer == null) toolbarContainer = GetComponentInChildren<Transform>(true); // 비활성 자식도 포함
            if (toolbarContainer == null) Debug.LogError("ToolbarView: toolbarContainer가 할당되지 않았습니다. Inspector에서 설정하거나 현재 GameObject에 Transform이 있어야 합니다.", this);

            // layoutGroup 자동 할당 및 추가 (Inspector에서 할당되지 않은 경우)
            if (layoutGroup == null && toolbarContainer != null)
            {
                layoutGroup = toolbarContainer.gameObject.GetComponent<LayoutGroup>();
                if (layoutGroup == null)
                {
                    // 기본으로 VerticalLayoutGroup 추가. 필요시 프로젝트에 맞게 수정.
                    layoutGroup = toolbarContainer.gameObject.AddComponent<VerticalLayoutGroup>();
                    Debug.LogWarning("ToolbarView: LayoutGroup이 toolbarContainer에 없어 새로 추가합니다. (기본 VerticalLayoutGroup)", this);
                }
            }
            if (layoutGroup == null) Debug.LogError("ToolbarView: layoutGroup이 할당되지 않았습니다. toolbarContainer에 LayoutGroup 컴포넌트를 추가해주세요.", this);


            // rootCanvas 자동 찾기 (TooltipManager 초기화에 필요)
            if (rootCanvas == null) rootCanvas = GetComponentInParent<Canvas>();
            if (rootCanvas == null)
            {
                Canvas[] canvases = FindObjectsByType<Canvas>(FindObjectsSortMode.None); // Unity 2023부터 FindObjectsByType 사용 권장
                foreach (Canvas c in canvases) { if (c.isRootCanvas) { rootCanvas = c; break; } }
                if (rootCanvas == null && canvases.Length > 0) rootCanvas = canvases[0]; // 최후의 수단
            }

            // TooltipManager 초기화
            if (rootCanvas != null)
            {
                if(!TooltipManager.Instance.IsInitialized) TooltipManager.Instance.Initialize(rootCanvas.transform, rootCanvas);
            }
            else
            {
                Debug.LogError("ToolbarView: rootCanvas를 찾을 수 없어 TooltipVisualManager를 초기화할 수 없습니다.");
            }
        }

        /// <summary>
        /// 지정된 ToolbarModel을 사용하여 툴바 UI를 초기화하고 렌더링합니다.
        /// 기존 UI가 있다면 정리(ClearToolbar)한 후, 새 모델에 따라 UI를 다시 생성(RenderToolbar)합니다.
        /// </summary>
        /// <param name="toolbarModel">화면에 표시할 툴바의 데이터 모델입니다.</param>
        public virtual void Initialize(ToolbarModel toolbarModel)
        {
            this.ToolbarModel = toolbarModel;

            if (toolbarContainer == null)
            {
                Debug.LogError("ToolbarView: Initialize 실패. toolbarContainer가 할당되지 않았습니다.", this);
                return;
            }
            if (layoutGroup == null) // layoutGroup도 필수적이므로 확인
            {
                Debug.LogError("ToolbarView: Initialize 실패. layoutGroup이 할당되지 않았습니다.", this);
                return;
            }
            if (this.ToolbarModel == null)
            {
                Debug.LogError("ToolbarView: Initialize 실패. 제공된 toolbarModel이 null입니다.", this);
                ClearToolbar(); // 모델이 없으면 기존 UI라도 정리
                return;
            }

            RenderToolbar();
        }

        /// <summary>
        /// 현재 툴바에 표시된 모든 UI 요소들을 제거하고, 관련된 이벤트 구독을 해제합니다.
        /// _modelToGameObjectMap, _toggleGroups를 비우고, 열려있는 하위 메뉴(currentSubMenu)도 파괴합니다.
        /// 툴팁도 숨깁니다.
        /// </summary>
        protected virtual void ClearToolbar()
        {
            if (_modelToGameObjectMap != null)
            {
                foreach (var pair in _modelToGameObjectMap)
                {
                    if (pair.Key != null) // 모델(버튼)에 연결된 이벤트 구독 해제
                    {
                        pair.Key.OnStateChanged -= () => UpdateItemVisuals(pair.Key);
                        if (pair.Key is ToolbarToggleButton toggleButton)
                        {
                            toggleButton.OnToggleStateChanged -= (isSelected) => UpdateToggleVisuals(toggleButton, isSelected);
                        }
                    }
                    if (pair.Value != null) // UI GameObject 파괴
                    {
                        TooltipHandler handler = pair.Value.GetComponent<TooltipHandler>();
                        if (handler != null) // 툴팁 핸들러 이벤트도 정리 (필요시)
                        {
                            handler.OnPointerEnterAction = null;
                            handler.OnPointerExitAction = null;
                        }
                        Destroy(pair.Value);
                    }
                }
                _modelToGameObjectMap.Clear();
            }

            if (_toggleGroups != null) // 토글 그룹 GameObject들도 정리
            {
                foreach (var groupObj in _toggleGroups.Values)
                {
                    if (groupObj != null && groupObj.gameObject != null) Destroy(groupObj.gameObject);
                }
                _toggleGroups.Clear();
            }

            if (currentSubMenu != null) // 열려있는 하위 메뉴 파괴
            {
                Destroy(currentSubMenu);
                currentSubMenu = null;
            }

            if (TooltipManager.Instance != null && TooltipManager.Instance.IsInitialized) // 툴팁 숨기기
            {
                TooltipManager.Instance.HideTooltip();
            }
        }

        /// <summary>
        /// ToolbarModel에 정의된 항목들을 기반으로 실제 UI 요소들을 생성하여 툴바를 구성합니다.
        /// 먼저 ClearToolbar를 호출하여 기존 UI를 정리한 후, 모델의 각 항목에 대해 적절한 프리팹을 사용하여
        /// UI GameObject를 생성하고, 필요한 설정(이벤트 바인딩, 툴팁 등)을 수행합니다.
        /// </summary>
        protected void RenderToolbar()
        {
            ClearToolbar(); // 기존 UI 및 이벤트 구독 정리

            if (ToolbarModel == null || ToolbarModel.Items == null) return;
            if (toolbarContainer == null)
            {
                Debug.LogError("ToolbarView: RenderToolbar 중단. toolbarContainer가 null입니다.", this);
                return;
            }

            foreach (var itemModel in ToolbarModel.Items)
            {
                GameObject itemUIObject = null;// 생성될 UI GameObject

                // 1. 모델 타입에 따라 적절한 프리팹 선택 및 인스턴스화
                if (itemModel is ToolbarSeparator)
                {
                    if (separatorPrefab != null) itemUIObject = Instantiate(separatorPrefab, toolbarContainer);
                    else Debug.LogError("ToolbarView: separatorPrefab이 할당되지 않았습니다.", this);
                }
                else if (itemModel is ToolbarButtonBase buttonModel) // 모든 버튼 타입의 기본 처리
                {
                    GameObject prefabToUse = null;
                    if (buttonModel is ToolbarRadioButton) prefabToUse = radioButtonPrefab;
                    else if (buttonModel is ToolbarToggleButton) prefabToUse = toggleButtonPrefab; // 라디오 버튼보다 먼저 와야 함 (상속 관계)
                    else if (buttonModel is ToolbarExpandableButton) prefabToUse = expandableButtonPrefab;
                    else if (buttonModel is ToolbarStandardButton) prefabToUse = standardButtonPrefab;
                    // else: 다른 커스텀 버튼 타입이 있다면 여기에 추가

                    if (prefabToUse != null)
                    {
                        itemUIObject = Instantiate(prefabToUse, toolbarContainer);
                    }
                    else
                    {
                        Debug.LogError($"ToolbarView: {buttonModel.GetType().Name}에 대한 프리팹이 할당되지 않았거나 알 수 없는 버튼 타입입니다.", this);
                        continue; // 이 버튼은 건너뜀
                    }

                    // 2. 모델-UI 매핑 및 모델 상태 변경 구독
                    _modelToGameObjectMap[buttonModel] = itemUIObject;
                    // 모델의 OnStateChanged 이벤트가 발생하면 UpdateItemVisuals 메서드를 호출하여 UI를 업데이트합니다.
                    // 람다 표현식에서 buttonModel을 직접 클로저로 캡처합니다.
                    buttonModel.OnStateChanged += () => UpdateItemVisuals(buttonModel);

                    // 3. 버튼 UI 초기 설정 및 사용자 상호작용(이벤트) 바인딩
                    SetupButtonVisualsAndInteractions(buttonModel, itemUIObject);

                    // 4. 툴팁 핸들러 추가 및 설정
                    if (!string.IsNullOrEmpty(buttonModel.TooltipKey))
                    {
                        TooltipHandler tooltipHandler = itemUIObject.GetComponent<TooltipHandler>();
                        if (tooltipHandler == null) tooltipHandler = itemUIObject.AddComponent<TooltipHandler>();

                        tooltipHandler.Tooltip = buttonModel.TooltipKey; // 툴팁 내용 또는 키 전달
                        // TooltipManager의 이벤트 핸들러 연결
                        if (TooltipManager.Instance != null && TooltipManager.Instance.IsInitialized)
                        {
                            tooltipHandler.OnPointerEnterAction = TooltipManager.Instance.HandlePointerEnter;
                            tooltipHandler.OnPointerExitAction = TooltipManager.Instance.HandlePointerExit;
                        }
                    }
                }
                else
                {
                    Debug.LogWarning($"ToolbarView: 알 수 없는 IToolbarItem 타입 ({itemModel.GetType().Name})이거나, UI 생성이 지원되지 않습니다.", this);
                }

                if (itemUIObject != null)
                {
                    itemUIObject.name = $"ToolbarItem_{itemModel.GetType().Name}_{(itemModel is ToolbarButtonBase b ? b.Text : "")}";
                }
            }

            // 모든 UI 항목이 추가된 후 레이아웃 그룹 업데이트
            if (layoutGroup != null)
            {
                // LayoutRebuilder.ForceRebuildLayoutImmediate(layoutGroup.GetComponent<RectTransform>()); // 즉시 업데이트
                // 또는 FitToChildren 확장 메서드 사용 (UVC.Extension에 정의되어 있다고 가정)
                layoutGroup.FitToChildren(width: layoutGroup is VerticalLayoutGroup, height: true);
            }
        }


        /// <summary>
        /// 버튼 모델(ToolbarButtonBase)과 해당 UI GameObject를 받아,
        /// 버튼의 초기 시각적 요소(텍스트, 아이콘, 활성화 상태)를 설정하고,
        /// UI 상호작용(예: 클릭) 시 모델의 메서드가 호출되도록 이벤트를 연결합니다.
        /// </summary>
        /// <param name="model">설정할 버튼의 데이터 모델입니다.</param>
        /// <param name="itemObj">모델에 해당하는, 화면에 표시될 UI GameObject입니다.</param>
        protected void SetupButtonVisualsAndInteractions(ToolbarButtonBase model, GameObject itemObj)
        {
            // 1. 공통 UI 요소(텍스트, 아이콘, 활성화 상태) 초기 업데이트
            UpdateCommonButtonVisuals(model, itemObj);

            // 2. 버튼 타입별 특화된 UI 요소 설정 및 이벤트 바인딩// 2. 버튼 타입별 특화된 UI 요소 설정 및 이벤트 바인딩
            if (model is ToolbarRadioButton radioModel)
            {
                Toggle toggleComponent = itemObj.GetComponent<Toggle>(); // 라디오 버튼 프리팹에는 Toggle 컴포넌트가 있어야 함
                if (toggleComponent != null)
                {
                    // UnityEngine.UI.ToggleGroup 가져오거나 생성하여 할당
                    ToggleGroup uiToggleGroup = GetOrCreateToggleGroup(radioModel.GroupName);
                    toggleComponent.group = uiToggleGroup;

                    // 초기 선택 상태 설정 (UI 이벤트 발생 없이)
                    toggleComponent.SetIsOnWithoutNotify(radioModel.IsSelected);

                    // UI 토글 값 변경(사용자 클릭) 시 모델 업데이트
                    toggleComponent.onValueChanged.AddListener((isSelected) =>
                    {
                        // 사용자가 UI를 직접 클릭하여 상태를 변경한 경우
                        if (isSelected) // 라디오 버튼은 선택될 때만 모델 업데이트 요청
                        {
                            // 모델의 ExecuteClick을 호출하여 그룹 내 선택 로직 및 커맨드 실행을 트리거합니다.
                            // 파라미터로 true (선택됨) 또는 모델 자체를 전달할 수 있습니다.
                            radioModel.ExecuteClick(true);
                        }
                    });

                    // 모델의 IsSelected 상태 변경(OnToggleStateChanged 이벤트) 시 UI 업데이트
                    // 이 이벤트는 모델의 IsSelected 속성이 코드에 의해 변경될 때 발생합니다.
                    radioModel.OnToggleStateChanged += (isSelected) => UpdateToggleVisuals(radioModel, isSelected);
                }
                else Debug.LogError($"ToolbarView: RadioButton '{model.Text}'의 GameObject에 Toggle 컴포넌트가 없습니다.", itemObj);
            }
            else if (model is ToolbarToggleButton toggleModel)
            {
                Toggle toggleComponent = itemObj.GetComponent<Toggle>(); // 토글 버튼 프리팹에도 Toggle 컴포넌트 필요
                if (toggleComponent != null)
                {
                    toggleComponent.SetIsOnWithoutNotify(toggleModel.IsSelected);
                    toggleComponent.onValueChanged.AddListener((isSelected) =>
                    {
                        // 사용자가 UI 토글을 클릭하면 모델의 ExecuteClick을 호출합니다.
                        // ExecuteClick 내부에서 IsSelected가 변경되고 관련 이벤트/콜백이 호출됩니다.
                        toggleModel.ExecuteClick();
                    });
                    toggleModel.OnToggleStateChanged += (isSelected) => UpdateToggleVisuals(toggleModel, isSelected);
                }
                else Debug.LogError($"ToolbarView: ToggleButton '{model.Text}'의 GameObject에 Toggle 컴포넌트가 없습니다.", itemObj);
            }
            else if (model is ToolbarExpandableButton expandableModel)
            {
                Button uiButton = itemObj.GetComponent<Button>(); // 확장 버튼 프리팹에는 Button 컴포넌트 필요
                if (uiButton != null)
                {
                    uiButton.onClick.AddListener(() =>
                    {
                        expandableModel.ExecuteClick(); // 주 버튼의 커맨드 실행 (있다면)
                        ToggleSubMenu(expandableModel, itemObj); // 하위 메뉴 토글 (itemObj는 위치 기준으로 사용)
                    });
                }
                else Debug.LogError($"ToolbarView: ExpandableButton '{model.Text}'의 GameObject에 Button 컴포넌트가 없습니다.", itemObj);
            }
            else if (model is ToolbarStandardButton standardModel)
            {
                Button uiButton = itemObj.GetComponent<Button>(); // 표준 버튼 프리팹에도 Button 컴포넌트 필요
                if (uiButton != null)
                {
                    uiButton.onClick.AddListener(() =>
                    {
                        // 표준 버튼 클릭 시 모델의 ExecuteClick 호출.
                        // 파라미터로 버튼 텍스트(또는 다른 식별자)를 전달할 수 있으나,
                        // ClickCommand가 파라미터를 받는 형태로 정의되어 있어야 합니다.
                        // 여기서는 standardModel.Text를 전달하는 예시입니다.
                        standardModel.ExecuteClick(standardModel.Text);
                    });
                }
                else Debug.LogError($"ToolbarView: StandardButton '{model.Text}'의 GameObject에 Button 컴포넌트가 없습니다.", itemObj);
            }
        }

        /// <summary>
        /// 버튼 모델의 상태(Text, IconSpritePath, IsEnabled 등)가 변경되었을 때 호출되어,
        /// 해당 버튼의 모든 관련 UI 시각적 요소를 업데이트합니다.
        /// 이 메서드는 주로 모델의 OnStateChanged 이벤트에 의해 호출됩니다.
        /// </summary>
        /// <param name="model">상태가 변경된 버튼의 모델입니다.</param>
        protected void UpdateItemVisuals(ToolbarButtonBase model)
        {
            if (_modelToGameObjectMap.TryGetValue(model, out GameObject itemObj))
            {
                // 1. 공통 시각적 요소(텍스트, 아이콘, 활성화 상태) 업데이트
                UpdateCommonButtonVisuals(model, itemObj);

                // 2. 타입별 특화된 UI 업데이트 (예: Toggle 컴포넌트의 isOn 상태)
                if (model is ToolbarToggleButton tb) // ToolbarRadioButton도 ToolbarToggleButton을 상속하므로 여기에 해당
                {
                    Toggle toggleComponent = itemObj.GetComponent<Toggle>();
                    if (toggleComponent != null)
                    {
                        // UI의 현재 상태와 모델의 상태가 다를 때만 UI를 업데이트하여 불필요한 이벤트 발생 방지
                        if (toggleComponent.isOn != tb.IsSelected)
                        {
                            toggleComponent.SetIsOnWithoutNotify(tb.IsSelected);
                        }
                    }
                }
                // 다른 버튼 타입에 대한 추가적인 시각적 업데이트 로직이 필요하면 여기에 추가
            }
            // else: 모델에 해당하는 GameObject를 찾지 못한 경우 (오류 상황일 수 있음)
            // Debug.LogWarning($"ToolbarView: UpdateItemVisuals - 모델 '{model.Text}'에 대한 GameObject를 찾을 수 없습니다.", this);
        }

        /// <summary>
        /// 특정 토글 버튼 또는 라디오 버튼의 IsSelected 상태가 모델에서 변경되었을 때 호출됩니다.
        /// 해당 UI Toggle 컴포넌트의 isOn 상태를 모델의 IsSelected 값과 동기화합니다.
        /// 이 메서드는 주로 모델의 OnToggleStateChanged 이벤트에 의해 호출됩니다.
        /// </summary>
        /// <param name="model">IsSelected 상태가 변경된 토글/라디오 버튼의 모델입니다.</param>
        /// <param name="isSelected">모델의 새로운 IsSelected 값입니다.</param>
        protected void UpdateToggleVisuals(ToolbarToggleButton model, bool isSelected)
        {
            if (_modelToGameObjectMap.TryGetValue(model, out GameObject itemObj))
            {
                Toggle toggleComponent = itemObj.GetComponent<Toggle>();
                if (toggleComponent != null)
                {
                    if (toggleComponent.isOn != isSelected) // UI와 모델 상태가 다를 때만 업데이트
                    {
                        toggleComponent.SetIsOnWithoutNotify(isSelected);
                    }
                }
            }
            // else: Debug.LogWarning($"ToolbarView: UpdateToggleVisuals - 모델 '{model.Text}'에 대한 GameObject를 찾을 수 없습니다.", this);
        }


        /// <summary>
        /// 버튼 모델과 UI GameObject를 기반으로 공통적인 시각적 요소(텍스트, 아이콘, 활성화 상태)를 업데이트합니다.
        /// </summary>
        /// <param name="model">업데이트할 버튼의 데이터 모델입니다.</param>
        /// <param name="itemObj">업데이트할 UI GameObject입니다.</param>
        protected void UpdateCommonButtonVisuals(ToolbarButtonBase model, GameObject itemObj)
        {
            if (model == null || itemObj == null) return;

            // 1. 텍스트 업데이트 (TextMeshProUGUI 사용 가정)
            // 프리팹 내부에 TextMeshProUGUI 컴포넌트를 가진 자식 오브젝트가 있다고 가정합니다.
            // 이름으로 찾거나, GetComponentInChildren을 사용할 수 있습니다. 여기서는 후자를 사용합니다.
            TextMeshProUGUI buttonTextComponent = itemObj.GetComponentInChildren<TextMeshProUGUI>(true); // true: 비활성 자식도 검색
            if (buttonTextComponent != null)
            {
                string displayText = model.Text;
                // LocalizationManager가 있고, model.Text가 비어있지 않다면 다국어 처리 시도
                if (LocalizationManager.Instance != null && !string.IsNullOrEmpty(model.Text))
                {
                    displayText = LocalizationManager.Instance.GetString(model.Text, model.Text); // 키가 없으면 키 자체를 반환하도록 설정
                }
                buttonTextComponent.text = displayText;
                // 텍스트가 없으면 비활성화 (선택적)
                // buttonTextComponent.gameObject.SetActive(!string.IsNullOrEmpty(displayText));
            }

            // 2. 아이콘 업데이트 (Image 컴포넌트 사용 가정)
            // 프리팹 내부에 "Icon"이라는 이름을 가진 자식 GameObject에 Image 컴포넌트가 있다고 가정합니다.
            // 또는 GetComponentInChildren<Image>를 사용하여 첫 번째 Image 컴포넌트를 찾을 수도 있습니다.
            Image iconImageComponent = null;
            Transform iconTransform = itemObj.transform.Find("Icon"); // 이름으로 먼저 찾아봄
            if (iconTransform != null) iconImageComponent = iconTransform.GetComponent<Image>();
            if (iconImageComponent == null) iconImageComponent = itemObj.GetComponentInChildren<Image>(true); // 못찾으면 자식에서 검색

            if (iconImageComponent != null)
            {
                string iconPathToLoad = model.IconSpritePath; // 기본적으로 선택/활성 상태 아이콘 경로

                // 토글 버튼 또는 라디오 버튼의 경우, IsSelected 상태에 따라 다른 아이콘 경로 사용
                if (model is ToolbarToggleButton toggleButton) // ToolbarRadioButton도 ToolbarToggleButton을 상속
                {
                    iconPathToLoad = toggleButton.IsSelected ? toggleButton.IconSpritePath : toggleButton.OffIconSpritePath;
                }
                // (ToolbarRadioButton에 대한 특별 처리는 ToolbarToggleButton에서 이미 커버됨)

                if (!string.IsNullOrEmpty(iconPathToLoad))
                {
                    Sprite iconSprite = LoadSpriteFromResources(iconPathToLoad);
                    iconImageComponent.sprite = iconSprite;
                    iconImageComponent.enabled = (iconSprite != null); // 스프라이트가 있어야 활성화
                }
                else
                {
                    iconImageComponent.sprite = null; // 아이콘 경로 없으면 스프라이트 제거
                    iconImageComponent.enabled = false; // 비활성화
                }
            }

            // 3. 활성화 상태(interactable) 업데이트
            // 버튼 UI GameObject에 Selectable (Button, Toggle 등) 컴포넌트가 있다고 가정합니다.
            Selectable selectableComponent = itemObj.GetComponent<Selectable>();
            if (selectableComponent != null)
            {
                selectableComponent.interactable = model.IsEnabled;
            }
        }

        protected Dictionary<string, ToggleGroup> _toggleGroups = new Dictionary<string, ToggleGroup>();
        /// <summary>
        /// 라디오 버튼 그룹 이름에 해당하는 UnityEngine.UI.ToggleGroup을 가져오거나, 없으면 새로 생성합니다.
        /// 생성된 ToggleGroup GameObject는 toolbarContainer의 자식으로 추가되며, 레이아웃에 영향을 주지 않도록 설정됩니다.
        /// </summary>
        /// <param name="groupName">찾거나 생성할 토글 그룹의 이름입니다.</param>
        /// <returns>해당 이름의 ToggleGroup 컴포넌트입니다.</returns>
        protected ToggleGroup GetOrCreateToggleGroup(string groupName)
        {
            if (string.IsNullOrEmpty(groupName))
            {
                Debug.LogError("ToolbarView: GetOrCreateToggleGroup - groupName이 null이거나 비어있습니다.", this);
                // 임시 그룹 또는 null 반환 등의 예외 처리 필요
                GameObject tempGroupObj = new GameObject($"ToggleGroup_UnnamedDynamic");
                tempGroupObj.transform.SetParent(toolbarContainer, false);
                return tempGroupObj.AddComponent<ToggleGroup>();
            }

            if (!_toggleGroups.TryGetValue(groupName, out ToggleGroup group))
            {
                // 새 ToggleGroup GameObject 생성
                GameObject groupObj = new GameObject($"ToggleGroup_{groupName}");
                groupObj.transform.SetParent(toolbarContainer);

                // RectTransform 설정 (크기가 0이 되도록 하여 레이아웃에 영향 최소화)
                RectTransform groupRect = groupObj.AddComponent<RectTransform>();
                groupRect.sizeDelta = new Vector2(0, 0); // 크기는 필요에 따라 조정
                groupRect.anchoredPosition = Vector2.zero;
                groupRect.sizeDelta = Vector2.zero;
                groupRect.anchorMin = Vector2.zero;
                groupRect.anchorMax = Vector2.one;

                group = groupObj.AddComponent<ToggleGroup>();
                group.allowSwitchOff = false; // 라디오 버튼 그룹은 일반적으로 하나는 선택되어 있도록 함

                LayoutElement element = groupObj.AddComponent<LayoutElement>();
                element.ignoreLayout = true; // 레이아웃 그룹에서 무시하도록 설정

                _toggleGroups.Add(groupName, group);
            }
            return group;
        }

        /// <summary>
        /// 현재 열려있는 하위 메뉴 UI GameObject입니다. 없으면 null입니다.
        /// </summary>
        protected GameObject currentSubMenu = null;

        /// <summary>
        /// 확장 가능한 버튼(ToolbarExpandableButton)에 대한 하위 메뉴 UI를 토글합니다.
        /// 이미 열려있으면 닫고, 닫혀있으면 엽니다.
        /// 하위 메뉴는 subMenuPanelPrefab을 사용하여 생성되며, expandableButtonObj의 위치를 기준으로 표시됩니다.
        /// </summary>
        /// <param name="expandableButtonModel">하위 버튼 목록을 가진 확장 버튼 모델입니다.</param>
        /// <param name="expandableButtonObj">주 확장 버튼의 UI GameObject로, 하위 메뉴 위치 결정에 사용됩니다.</param>
        protected void ToggleSubMenu(ToolbarExpandableButton expandableButtonModel, GameObject expandableButtonObj)
        {
            // 이미 다른 하위 메뉴가 열려있거나, 현재 클릭한 버튼의 하위 메뉴가 열려있다면 닫습니다.
            if (currentSubMenu != null)
            {
                Destroy(currentSubMenu);
                currentSubMenu = null;
                // 만약 현재 클릭한 버튼의 하위 메뉴가 이미 열려있어서 닫는 경우라면, 여기서 함수 종료
                // (다시 열리지 않도록). 이 로직은 currentSubMenu가 어떤 버튼에 의해 열렸는지 알아야 함.
                // 간단하게는, 어떤 확장 버튼이든 클릭하면 기존 서브메뉴는 닫고, 필요하면 새로 연다.
                // 지금은 그냥 닫고, 아래 로직에서 새로 열 조건이 되면 열도록 함.
                // 만약 클릭한 버튼이 이미 열린 메뉴의 주인이면, 그냥 닫기만 하고 리턴하는게 자연스러울 수 있음.
                // 이 부분은 UI/UX 정책에 따라 상세 조정 필요. 현재는 "토글"이므로, 다시 누르면 닫히고, 없으면 연다.
                // 즉, 아래 로직에서 currentSubMenu가 null이 되었으므로, 다시 열릴 수 있음.
                // 만약 "닫기만" 하고 싶다면, 여기서 return 해야 함.
                // 현재 로직: 이미 열려있으면 무조건 닫고, 아래에서 다시 열지 결정.
                // 수정 제안: 만약 currentSubMenu가 이 expandableButtonModel에 의해 열린 것이라면, 닫고 return.
                // (이를 위해서는 currentSubMenu가 어떤 모델에 연결되었는지 정보가 필요)
                // 현재는 간단히 토글로 동작: 열려있으면 닫고, 닫혀있으면 연다.
                // 즉, if (currentSubMenu != null) { Destroy; currentSubMenu = null; return; } 이면 닫기만 하고 끝.
                // 지금은 닫고, 아래에서 다시 열 수 있게 함.
            }

            // 새 하위 메뉴를 열 조건 확인 (닫혀 있었고, 프리팹과 하위 버튼이 있는 경우)
            if (subMenuPanelPrefab == null)
            {
                Debug.LogError("ToolbarView: subMenuPanelPrefab이 할당되지 않아 하위 메뉴를 열 수 없습니다.", this);
                return;
            }
            if (expandableButtonModel.SubButtons == null || expandableButtonModel.SubButtons.Count == 0)
            {
                // Debug.LogWarning($"ToolbarView: 확장 버튼 '{expandableButtonModel.Text}'에 하위 버튼이 없어 메뉴를 열지 않습니다.", this);
                return; // 하위 버튼 없으면 메뉴 열지 않음
            }

            // 하위 메뉴 패널 UI 생성
            // 생성 위치는 일단 ToolbarView의 자식으로 하고, 이후 위치 조정
            currentSubMenu = Instantiate(subMenuPanelPrefab, transform);
            currentSubMenu.name = $"SubMenu_{expandableButtonModel.Text}";

            RectTransform panelRect = currentSubMenu.GetComponent<RectTransform>();
            if (panelRect == null)
            {
                Debug.LogError("ToolbarView: subMenuPanelPrefab에 RectTransform이 없습니다.", currentSubMenu);
                Destroy(currentSubMenu); currentSubMenu = null;
                return;
            }

            // 하위 메뉴 패널 위치 설정 (확장 버튼 UI 오른쪽 또는 아래 등)
            // 이 로직은 툴바의 방향(수평/수직)과 UI 디자인에 따라 매우 달라질 수 있습니다.
            // 여기서는 간단한 예시로, 확장 버튼의 오른쪽에 표시한다고 가정합니다.
            RectTransform expandableButtonRect = expandableButtonObj.GetComponent<RectTransform>();

            // panelRect의 앵커 및 피벗 설정 (예: 좌상단 기준)
            panelRect.anchorMin = new Vector2(0, 1);
            panelRect.anchorMax = new Vector2(0, 1);
            panelRect.pivot = new Vector2(0, 1); // 좌상단 피벗
            currentSubMenu.SetActive(true);

            // 부모 내에서 가장 마지막 자식으로 만들어 최상단에 표시되도록 합니다.
            if (panelRect.parent != null) panelRect.SetAsLastSibling();

            LayoutGroup subMenuLayoutGroup = currentSubMenu.GetComponent<LayoutGroup>();
            if (subMenuLayoutGroup == null)
            {
                // 하위 메뉴 패널에 LayoutGroup이 없다면 추가합니다.
                subMenuLayoutGroup = currentSubMenu.AddComponent<VerticalLayoutGroup>();
            }

            // 패널 위치를 확장 버튼의 위치에 맞춥니다.
            Vector2 offset = new Vector2(expandableButtonRect.anchoredPosition.x, expandableButtonRect.anchoredPosition.y);
            if(layoutGroup is VerticalLayoutGroup)
            {
                offset.x += expandableButtonRect.rect.width; // 수직 레이아웃인 경우 버튼 오른쪽에 표시 되도록
            }
            else
            {   
                if(subMenuLayoutGroup != null) offset.x -= subMenuLayoutGroup.padding.left; // 수평 레이아웃인 경우 패딩을 고려
                offset.y -= expandableButtonRect.rect.height; // 수평 레이아웃인 경우 버튼 아래에 표시 되도록
            }
            panelRect.anchoredPosition = offset; // 위치 조정

            // 하위 버튼들 생성. 하위 메뉴 패널에 LayoutGroup이 있다면 자식 버튼들이 자동으로 정렬됩니다.
            foreach (var subItemBase in expandableButtonModel.SubButtons)
            {
                if (subItemBase is ToolbarButtonBase subItemModel) // 모든 하위 아이템은 ToolbarButtonBase라고 가정
                {
                    // 하위 버튼도 적절한 프리팹을 사용해야 합니다.
                    // 여기서는 모든 하위 버튼이 standardButtonPrefab을 사용한다고 가정합니다.
                    // 실제로는 subItemModel의 타입에 따라 다른 프리팹을 선택할 수 있습니다.
                    GameObject subButtonPrefabToUse = standardButtonPrefab; // 기본값
                    if (subItemModel is ToolbarToggleButton) subButtonPrefabToUse = toggleButtonPrefab;
                    // ... 다른 타입에 대한 처리 ...

                    if (subButtonPrefabToUse == null)
                    {
                        Debug.LogError($"ToolbarView: 하위 버튼 '{subItemModel.Text}'에 대한 프리팹을 결정할 수 없습니다 (standardButtonPrefab 사용 시도).", this);
                        continue;
                    }

                    GameObject subButtonObj = Instantiate(subButtonPrefabToUse, panelRect); // 하위 메뉴 패널의 자식으로 생성
                    subButtonObj.name = $"SubItem_{subItemModel.Text}";

                    // 하위 버튼의 시각적 요소 설정 및 상호작용 연결
                    UpdateCommonButtonVisuals(subItemModel, subButtonObj); // 공통 UI 업데이트

                    // 하위 버튼 클릭 이벤트 연결
                    Button subUiButton = subButtonObj.GetComponent<Button>(); // 또는 Toggle 등 타입에 맞는 컴포넌트
                    if (subUiButton != null)
                    {
                        subUiButton.interactable = subItemModel.IsEnabled; // 상호작용 상태 설정
                        subUiButton.onClick.AddListener(() =>
                        {
                            // 1. 주 확장 버튼 모델에 하위 버튼 선택 알림 (주 버튼 모양 업데이트 등)
                            // SelectSubButton의 두 번째 파라미터(GameObject)는 제거되었으므로, 모델만 전달
                            expandableButtonModel.SelectSubButton(subItemModel); // 모델 업데이트 및 주 버튼 외형 변경 요청

                            // 2. 선택된 하위 버튼 자체의 커맨드 실행
                            subItemModel.ExecuteClick(subItemModel.Text); // 하위 버튼의 Command 실행

                            // 3. 하위 메뉴 닫기
                            Destroy(currentSubMenu);
                            currentSubMenu = null;

                            // 4. 툴팁 숨기기 (하위 메뉴가 닫힐 때 관련 툴팁도 숨김)
                            if (TooltipManager.Instance != null && TooltipManager.Instance.IsInitialized) TooltipManager.Instance.HandlePointerExit();
                        });
                    }

                    // 하위 버튼 툴팁 처리
                    if (!string.IsNullOrEmpty(subItemModel.TooltipKey))
                    {
                        TooltipHandler tooltipHandler = subButtonObj.GetComponent<TooltipHandler>();
                        if (tooltipHandler == null) tooltipHandler = subButtonObj.AddComponent<TooltipHandler>();

                        tooltipHandler.Tooltip = subItemModel.TooltipKey;
                        tooltipHandler.OnPointerEnterAction = TooltipManager.Instance.HandlePointerEnter;
                        tooltipHandler.OnPointerExitAction = TooltipManager.Instance.HandlePointerExit;
                    }

                    // 하위 버튼 모델의 상태 변경도 구독하여 UI 업데이트 (선택적 확장)
                    // subItemModel.OnStateChanged += () => UpdateCommonButtonVisuals(subItemModel, subButtonObj);
                    // 이 경우, _modelToGameObjectMap에 하위 버튼도 추가하고 ClearToolbar에서 정리해야 함.
                }
            }

            // 하위 메뉴 레이아웃 그룹 크기 맞춤
            if (subMenuLayoutGroup != null)
            {
                subMenuLayoutGroup.FitToChildren(); // UVC.Extension 필요 가정
            }
        }

        /// <summary>
        /// 지정된 경로에서 Sprite를 로드합니다. Sprite 파일은 Resources 폴더 또는 그 하위 폴더에 있어야 합니다.
        /// </summary>
        /// <param name="spritePath">Resources 폴더 기준의 Sprite 경로입니다 (확장자 제외).</param>
        /// <returns>로드된 Sprite 객체. 실패 시 null을 반환합니다.</returns>
        protected Sprite LoadSpriteFromResources(string spritePath)
        {
            if (string.IsNullOrEmpty(spritePath))
            {
                Debug.LogWarning("LoadSpriteFromResources: spritePath가 null이거나 비어있습니다.");
                return null;
            }
            Sprite loadedSprite = Resources.Load<Sprite>(spritePath);
            if (loadedSprite == null)
            {
                // 경로에 파일이 없을 경우 오류 로깅. 게임 빌드 시 Resources 폴더 내용이 포함되는지 확인 필요.
                Debug.LogError($"ToolbarView: Resources 폴더에서 '{spritePath}' 경로의 Sprite를 로드할 수 없습니다. 경로 및 파일 존재 여부를 확인하세요.", this);
            }
            return loadedSprite;
        }

        /// <summary>
        /// MonoBehaviour의 Update 메서드입니다. 매 프레임 호출됩니다.
        /// 여기서는 열려있는 하위 메뉴(currentSubMenu) 외부를 클릭했을 때 메뉴를 닫는 로직을 처리합니다.
        /// </summary>
        protected virtual void Update()
        {
            // 마우스 왼쪽 버튼이 클릭되었고, 현재 열려있는 하위 메뉴가 있으며, 루트 캔버스가 존재하는 경우
            if (Input.GetMouseButtonDown(0) && currentSubMenu != null && currentSubMenu.activeSelf && rootCanvas != null)
            {
                RectTransform subMenuRect = currentSubMenu.GetComponent<RectTransform>();
                if (subMenuRect == null) return; // 하위 메뉴에 RectTransform이 없는 경우 (비정상)

                // 마우스 포인터가 하위 메뉴 영역(RectTransform) 내에 있는지 확인
                // 이를 위해 RectTransformUtility.RectangleContainsScreenPoint 사용
                Camera eventCamera = null; // 스크린 스페이스 오버레이 캔버스인 경우 null
                if (rootCanvas.renderMode == RenderMode.ScreenSpaceCamera || rootCanvas.renderMode == RenderMode.WorldSpace)
                {
                    eventCamera = rootCanvas.worldCamera; // 캔버스에 할당된 카메라 사용
                }

                // 마우스 포인터가 하위 메뉴 영역 밖에 있는지 확인
                if (!RectTransformUtility.RectangleContainsScreenPoint(subMenuRect, Input.mousePosition, eventCamera))
                {
                    // 하위 메뉴 영역 바깥을 클릭한 경우, 하위 메뉴를 닫습니다.
                    Destroy(currentSubMenu);
                    currentSubMenu = null;
                    if (TooltipManager.Instance != null && TooltipManager.Instance.IsInitialized) TooltipManager.Instance.HideTooltip();
                }
            }
        }

        /// <summary>
        /// MonoBehaviour의 OnDestroy 메서드입니다. 이 컴포넌트 또는 GameObject가 파괴될 때 호출됩니다.
        /// 툴바 UI를 정리(ClearToolbar)하고, TooltipManager 등의 리소스를 해제(Dispose)합니다.
        /// </summary>
        protected virtual void OnDestroy()
        {
            ClearToolbar(); // 모든 UI 요소 및 이벤트 구독 해제

            // TooltipManager가 싱글톤이고 다른 곳에서도 사용된다면, 여기서 Dispose 호출은 신중해야 합니다.
            // 만약 이 ToolbarView가 TooltipManager의 유일한 사용자이거나, 
            // 씬 전환 등으로 모든 관련 UI가 사라지는 상황이라면 적절할 수 있습니다.
            // 현재 TooltipManager.Instance.Dispose()는 TooltipVisualManager의 내용을 정리하는 것으로 보입니다.
            if (TooltipManager.Instance != null && TooltipManager.Instance.IsInitialized)
            {
                // TooltipManager.Instance.Dispose(); // 주석 처리된 기존 코드. 필요시 활성화.
                // Dispose의 구체적인 내용에 따라 호출 여부 결정.
                // 만약 TooltipManager가 전역적이고 계속 사용되어야 한다면, 여기서 Dispose하면 안됨.
                // HideTooltip 정도가 적당할 수 있음.
            }
        }
    }
}