using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;
using DG.Tweening;
using Cysharp.Threading.Tasks;
using UnityEngine.EventSystems;

/// <summary>
/// UI管理器 - 负责管理所有UI界面的显示、隐藏和层级
/// </summary>
public class UIManager : ManagerBase<UIManager>
{
    #region 常量和枚举
    
    // 基础排序顺序
    private const int BASE_SORTING_ORDER = 10;
    
    #endregion

    #region 字段和属性
    
    // UI根节点
    private Transform uiRoot;
    
    // 各层级的Transform
    private Transform staticTrans;
    private Transform bottomTrans;
    private Transform midTrans;
    private Transform systemTrans;
    private Transform loadingTrans;

    // UI字典，存储所有已加载的UI，键为UI名称，值为UI实例
#if UNITY_EDITOR
    public
#else
    private
#endif 
    Dictionary<string, List<UIBase>> uiDict = new Dictionary<string, List<UIBase>>();

    // 存储关闭但未销毁的UI，键为UI名称，值为UI实例
    private Dictionary<string, List<UIBase>> closedUIDict = new Dictionary<string, List<UIBase>>();

    // UI栈，用于管理UI的显示顺序
    private Stack<UIBase> uiStack = new Stack<UIBase>();
    
    // 当前最高的排序顺序
    private int currentHighestSortingOrder = 0;
    
    // 排序缓存，避免每次UpdateUISortingOrder分配
    private List<UIBase> _sortTempList = new List<UIBase>(32);
    private Dictionary<UIBase, int> _sortOrderDict = new Dictionary<UIBase, int>(32);
    
    // 当前回合数，用于记录UI的使用情况
    private int currentRound = 0;
    
    // 缓存层级对应的排序顺序
    private static Dictionary<UILayer, int> layerSortingOrderCache = new Dictionary<UILayer, int>();
    
    // 缓存层级对应的Transform
    private Dictionary<UILayer, Transform> layerTransformCache = new Dictionary<UILayer, Transform>();
    
    // UI实例计数器，用于为同类型UI生成唯一标识
    private Dictionary<string, int> uiInstanceCounter = new Dictionary<string, int>();
    
    // 上次检查时间
    private float lastCheckTime = 0f;
    // 检查间隔（秒）
    private const float CHECK_INTERVAL = 5f;
    
    public Action<UIBase> OnOpenWindow;

    public Action<UIBase> OnCloseWindow;

    public Action OnAfterSortWinLayer;

    #endregion

    #region 初始化

    /// <summary>
    /// 初始化UI管理器
    /// </summary>
    public override async UniTask Init()
    {
        await InitUIRoot();
        // 初始化缓存
        layerSortingOrderCache.Clear();
        layerTransformCache.Clear();
        uiInstanceCounter.Clear();
        DOTween.SetTweensCapacity(500, 50);
        Debug.Log("UI管理器初始化完成");
    }
    
    /// <summary>
    /// 初始化UI根节点
    /// </summary>
    private async UniTask InitUIRoot()
    {
        // 查找UI根节点
        GameObject root = GameObject.Find("UIRoot");
        
        // 如果场景中没有UI根节点，则创建一个
        if (root == null)
        {
            var prefab = await BuiltInLoader.LoadPrefabAsync("UIRoot");
            root = GameObject.Instantiate(prefab);
            root.name = "UIRoot";
            if (root == null)
            {
                Debug.LogError("无法找到UI根节点");
                return;
            }
        }

        // 无论是从场景找到还是新实例化的，都确保跨场景不被销毁
        GameObject.DontDestroyOnLoad(root);

        uiRoot = root.transform;
        uiRoot.position = Vector3.zero;

        staticTrans = uiRoot.Find("Static");
        bottomTrans = uiRoot.Find("Bottom");
        midTrans = uiRoot.Find("Middle");
        loadingTrans = uiRoot.Find("Loading");
        systemTrans = uiRoot.Find("System");

        layerTransformCache.Clear();
        layerTransformCache.Add(UILayer.Static, staticTrans);
        layerTransformCache.Add(UILayer.Bottom, bottomTrans);
        layerTransformCache.Add(UILayer.Mid, midTrans);
        layerTransformCache.Add(UILayer.System, systemTrans);
        layerTransformCache.Add(UILayer.Loading, loadingTrans);

        LogUIRootEventSystemState("InitUIRoot");
    }
    
    public Transform GetUIRoot()
    {
        return uiRoot;
    }
    
    #endregion

    #region 辅助方法

    // 获取UI层级对应的基础排序顺序
    public static int GetBaseSortingOrderForLayer(UILayer layer)
    {
        // 尝试从缓存中获取排序顺序
        if (layerSortingOrderCache.TryGetValue(layer, out int order))
            return order;

        // 如果缓存中没有，使用原来的方法计算并缓存结果
        int result;
        switch (layer)
        {
            case UILayer.Static:
                result = BASE_SORTING_ORDER;
                break;
            case UILayer.Bottom:
                result = BASE_SORTING_ORDER * 100;
                break;
            case UILayer.Mid:
                result = BASE_SORTING_ORDER * 1000;
                break;
            case UILayer.System:
                result = BASE_SORTING_ORDER * 2000;
                break;
            case UILayer.Loading:
                result = BASE_SORTING_ORDER * 3000;
                break;
            default:
                result = BASE_SORTING_ORDER * 10;
                break;
        }

        // 将结果存入缓存
        layerSortingOrderCache[layer] = result;
        return result;
    }

    // 获取层级对应的Transform
    public Transform GetTransForLayer(UILayer layer)
    {
        // 尝试从缓存中获取Transform
        if (layerTransformCache.TryGetValue(layer, out Transform trans))
            return trans;
            
        // 如果缓存中没有，使用原来的方法获取并缓存结果
        Transform result;
        switch (layer)
        {
            case UILayer.Static:
                result = staticTrans;
                break;
            case UILayer.Bottom:
                result = bottomTrans;
                break;
            case UILayer.Mid:
                result = midTrans;
                break;
            case UILayer.System:
                result = systemTrans;
                break;
            case UILayer.Loading:
                result = loadingTrans;
                break;
            default:
                result = bottomTrans;
                break;
        }
        
        // 将结果存入缓存
        layerTransformCache[layer] = result;
        return result;
    }
    
    // 获取UI实例，如果不存在则返回null
    public T GetUI<T>() where T : UIBase
    {
        // 获取UI类型名称
        string uiName = typeof(T).Name;
        if (string.IsNullOrEmpty(uiName))
        {
            // 记录错误日志
            Debug.LogError("UI名称为空");
            return null;
        }

        // 尝试从字典中获取UI实例列表
        if (uiDict.TryGetValue(uiName, out List<UIBase> uiList) && uiList.Count > 0)
        {
            // 返回第一个实例
            return uiList[0] as T;
        }

        // 如果不存在，返回null
        return null;
    }

    public UIBase GetUI(string uiName)
    {
        if (string.IsNullOrEmpty(uiName))
        {
            // 记录错误日志
            Debug.LogError("UI名称为空");
            return null;
        }

        // 尝试从字典中获取UI实例列表
        if (uiDict.TryGetValue(uiName, out List<UIBase> uiList) && uiList.Count > 0)
        {
            // 返回第一个实例
            return uiList[0];
        }

        // 如果不存在，返回null
        return null;
    }

    public List<T> GetUIList<T>() where T : UIBase
    {
        List<T> uiList = new List<T>();

        // 获取UI类型名称
        string uiName = typeof(T).Name;
        if (string.IsNullOrEmpty(uiName))
        {
            // 记录错误日志
            Debug.LogError("UI名称为空");
            return uiList;
        }

        // 尝试从字典中获取UI实例列表
        List<UIBase> tempList = null;
        uiDict.TryGetValue(uiName, out tempList);

        if (tempList != null)
        {
            for (int i = 0; i < tempList.Count; i++)
            {
                UIBase ui = tempList[i];
                if (null != ui)
                {
                    uiList.Add(ui as T);
                }
            }
        }

        return uiList;
    }

    public bool IsOpenedInList<T>() where T : UIBase
    {
        List<T> uiList = GetUIList<T>();

        foreach (T ui in uiList)
        {
            if (ui.IsActive())
            {
                return true;
            }
        }

        return false;
    }

    public bool IsOpened<T>() where T : UIBase
    {
        T ui = GetUI<T>();

        if (null != ui)
        {
            return ui.IsActive();
        }

        return false;
    }

    public bool IsOpened(string uiName)
    {
        UIBase ui = GetUI(uiName);

        if (null != ui)
        {
            return ui.IsActive();
        }

        return false;
    }

    // 检查是否存在任何全屏或遮罩窗口, 有screenMask 即可代表全屏
    public bool ExistAnyFullScreenOrMaskWin(string excludeUIName)
    {
        var exist = false;
        foreach (var uiList in uiDict.Values)
        {
            // 遍历该类型的所有UI实例
            foreach (var ui in uiList)
            {
                // 刷新UI
                if (ui.IsActive() && ui.name != excludeUIName)
                {
                    if (ui.screenMask != null)
                    {
                        exist = true;
                        break;
                    }
                }
            }
        }

        return exist;
    }
    
    //在此界面上有没任何全屏或遮罩窗口
    public bool ExistAnyFullScreenOrMaskWinAbove(string uiName)
    {
        var ui = GetUI(uiName);
        if (ui == null || !ui.IsActive())
        {
            // 如果UI不存在或未打开，默认为有被挡住 
            return true;
        }

        foreach (var uiBase in uiStack)
        {
            if (uiBase == null)
            {
                continue;
            }
            if (uiBase.name == uiName)
            {
                break;
            }
            if (uiBase.IsActive() && uiBase.screenMask != null)
            {
                return true;
            }
        }

        return false;
    }

    // 检查是否存在任何同层级sortingOrde大于我的窗口
    public bool ExistAnySameLevelWinHigherSortingOrder(UILayer uiLayer, string excludeUIName)
    {
        int mySortingOrder = 0;
        if (uiDict.TryGetValue(excludeUIName, out List<UIBase> excludeList) && excludeList.Count > 0)
        {
            foreach (var ui in excludeList)
            {
                if (ui.IsActive())
                {
                    mySortingOrder = ui.GetSortingOrder();
                    break;
                }
            }
        }

        if (mySortingOrder == 0)
            return false;

        foreach (var uiList in uiDict.Values)
        {
            foreach (var ui in uiList)
            {
                if (!ui.IsActive())
                    continue;
                if (ui.uiName == excludeUIName)
                    continue;
                if (ui.uiLayer != uiLayer)
                    continue;
                if (ui.GetSortingOrder() > mySortingOrder)
                    return true;
            }
        }

        return false;
    }


    // 获取指定类型的所有UI实例
    public List<T> GetAllUI<T>() where T : UIBase
    {
        // 获取UI类型名称
        string uiName = typeof(T).Name;
        if (string.IsNullOrEmpty(uiName))
        {
            // 记录错误日志
            Debug.LogError("UI名称为空");
            return new List<T>();
        }

        // 尝试从字典中获取UI实例列表
        if (uiDict.TryGetValue(uiName, out List<UIBase> uiList) && uiList.Count > 0)
        {
            // 将列表中的所有实例转换为指定类型并返回
            return uiList.Cast<T>().ToList();
        }

        // 如果不存在，返回空列表
        return new List<T>();
    }
    
    // 更新父级UI的回合数
    private void UpdateParentUIRounds(UIBase ui)
    {
        // 如果UI为空或不支持父子关系，直接返回
        if (ui == null || !ui.supportParentChildRelation)
            return;
            
        // 获取父级UI
        UIBase parentUI = ui.parentUI;
        // 遍历所有父级UI，更新回合数
        while (parentUI != null)
        {
            // 更新父级UI的最后使用回合数
            parentUI.lastUsedRound = currentRound;
            // 继续向上查找父级UI
            parentUI = parentUI.parentUI;
        }
    }
    
    // 递归收集所有子UI
    private void CollectChildrenUI(UIBase ui, List<UIBase> result)
    {
        // 如果UI为空或没有子UI或不支持父子关系，直接返回
        if (ui == null || !ui.supportParentChildRelation || ui.childrenUI == null || ui.childrenUI.Count == 0)
            return;
        
        // 遍历所有子UI
        foreach (var childUI in ui.childrenUI)
        {
            // 如果结果列表中不包含当前子UI，则添加
            if (!result.Contains(childUI))
            {
                // 添加到结果列表
                result.Add(childUI);
                // 递归收集子UI的子UI
                CollectChildrenUI(childUI, result);
            }
        }
    }
    
    /// <summary>
    /// 检查并关闭长时间未使用的UI
    /// </summary>
    public void CheckAndCloseIdleUI()
    {
        // 如果没有UI，直接返回
        if (uiDict.Count == 0 && closedUIDict.Count == 0)
            return;
            
        // 创建需要关闭的UI列表
        List<UIBase> uiToClose = new List<UIBase>();
        
        // 遍历所有活跃UI
        foreach (var uiList in uiDict.Values)
        {
            foreach (var ui in uiList)
            {
                // 如果UI是持久化的，跳过
                if (ui.isPersistent)
                    continue;
                    
                if (ui.IsActive())
                    continue;

                // 计算UI空闲的回合数
                int idleRounds = currentRound - ui.lastUsedRound;
                
                // 如果空闲回合数超过最大空闲回合数，添加到关闭列表
                if (idleRounds > ui.maxIdleRounds)
                {
                    uiToClose.Add(ui);
                }
            }
        }
        
        // 遍历所有关闭的UI
        List<string> emptyKeys = new List<string>();
        foreach (var kvp in closedUIDict)
        {
            string uiName = kvp.Key;
            List<UIBase> uiList = kvp.Value;
            List<UIBase> uiToRemove = new List<UIBase>();
            
            foreach (var ui in uiList)
            {
                // 计算UI空闲的回合数
                int idleRounds = currentRound - ui.lastUsedRound;
                
                // 如果空闲回合数超过最大空闲回合数，添加到关闭列表
                //  2025 11/13 修复 持久化UI被销毁的问题
                if (idleRounds > ui.maxIdleRounds && !ui.isPersistent)
                {
                    uiToClose.Add(ui);
                    uiToRemove.Add(ui);
                }
            }
            
            // 从关闭列表中移除需要销毁的UI
            foreach (var ui in uiToRemove)
            {
                uiList.Remove(ui);
            }
            
            // 如果列表为空，记录需要从字典中移除的键
            if (uiList.Count == 0)
            {
                emptyKeys.Add(uiName);
            }
        }
        
        // 从字典中移除空列表
        foreach (var key in emptyKeys)
        {
            closedUIDict.Remove(key);
        }
        
        // 销毁所有需要关闭的UI
        foreach (var ui in uiToClose)
        {
            // 记录日志
#if UNITY_EDITOR
            Debug.Log($"销毁长时间未使用的UI: {ui.uiName}, 空闲回合数: {currentRound - ui.lastUsedRound}");
#endif
            // 销毁UI对象
            GameObject.Destroy(ui.gameObject);
        }
    }
    
    // // 生成UI实例的唯一标识
    // private string GenerateUIInstanceID(string uiName)
    // {
    //     // 如果计数器中不存在该UI类型，初始化为0
    //     if (!uiInstanceCounter.ContainsKey(uiName))
    //     {
    //         uiInstanceCounter[uiName] = 0;
    //     }
        
    //     // 递增计数器
    //     uiInstanceCounter[uiName]++;
        
    //     // 返回带有计数的唯一标识
    //     return $"{uiName}_{uiInstanceCounter[uiName]}";
    // }
    
    #endregion

    #region UI资源管理

    // private UIBase LoadUIResource(string uiName)
    // {
        
    //     // 从资源管理器加载UI预制体
    //     GameObject prefab;
    //     if (uiName == "LaunchWin" || uiName == "DownLoadWin" || uiName == "RequestSecretWin" || uiName == "GameAgeWarnWin")
    //     {
    //         prefab = await BuiltInLoader.LoadPrefabAsync(uiName);
    //     }
    //     else
    //     {
    //         prefab = await ResManager.Instance.LoadAssetAsync<GameObject>("UI", uiName);
    //     }

    //     // 检查预制体是否加载成功
    //     if (prefab == null)
    //     {
    //         // 记录错误日志
    //         Debug.LogError($"加载UI预制体失败: {uiName}");
    //         return null;
    //     }

    //     // 实例化UI对象
    //     GameObject uiObject = GameObject.Instantiate(prefab);
    //     // 设置对象名称
    //     uiObject.name = uiName;

    //     // 通过uiName映射Type
    //     Type uiType = Type.GetType(uiName);
    //     if (uiType == null)
    //     {
    //         Debug.LogError($"找不到UI类型: {uiName}");
    //         return null;
    //     }

    //     // 获取UI基类组件
    //     UIBase uiBase = uiObject.GetComponent(uiType) as UIBase;

    //     // 检查UI基类组件是否存在
    //     if (uiBase == null)
    //     {
    //         // 记录错误日志
    //         Debug.LogError($"UI预制体 {uiName} 没有 UIBase 组件或类型不匹配");
    //         return null;
    //     }

    //     // 设置UI名称
    //     uiBase.uiName = uiName;

    //     // 设置父节点为UI根节点
    //     Transform parentTrans = GetTransForLayer(uiBase.uiLayer);

    //     uiObject.transform.SetParent(parentTrans, false);

    //     // 设置排序顺序
    //     int baseSortingOrder = GetBaseSortingOrderForLayer(uiBase.uiLayer);
    //     uiBase.SetSortingOrder(baseSortingOrder);

    //     return uiBase;
    // }

    // 加载UI预制体
    private async UniTask<T> LoadUIResource<T>(string uiName) where T : UIBase
    {
        return await LoadUIResourceAsync(uiName) as T;
    }

    // ====================================================================
    // US2: Async variants — InitUIRootAsync, LoadUIResourceAsync, OpenWindowAsync
    // ====================================================================

    /// <summary>
    /// US2: 异步初始化 UI 根节点。
    /// </summary>
    public async UniTask InitUIRootAsync()
    {
        GameObject root = GameObject.Find("UIRoot");
        if (root == null)
        {
            var prefab = await BuiltInLoader.LoadPrefabAsync("UIRoot"); // 已异步，无需修改
            root = GameObject.Instantiate(prefab);
            root.name = "UIRoot";
            if (root == null)
            {
                Debug.LogError("无法加载UI根节点");
                return;
            }
        }

        // 无论是从场景找到还是新实例化的，都确保跨场景不被销毁
        GameObject.DontDestroyOnLoad(root);
    }

    /// <summary>
    /// US2: 异步加载 UI 资源。
    /// </summary>
    private async UniTask<UIBase> LoadUIResourceAsync(string uiName)
    {
        GameObject prefab;
        if (uiName == "LaunchWin" || uiName == "DownLoadWin" || uiName == "RequestSecretWin" || uiName == "GameAgeWarnWin")
        {
            prefab = await BuiltInLoader.LoadPrefabAsync(uiName);
        }
        else
        {
            prefab = await ResManager.Instance.LoadAssetAsync<GameObject>("UI", uiName, true);
        }

        if (prefab == null)
        {
            Debug.LogError($"加载UI预制体失败: {uiName}");
            return null;
        }

        GameObject uiObject = GameObject.Instantiate(prefab);
        uiObject.name = uiName;

        Type uiType = Type.GetType(uiName);
        if (uiType == null)
        {
            Debug.LogError($"找不到UI类型: {uiName}");
            return null;
        }

        UIBase uiBase = uiObject.GetComponent(uiType) as UIBase;
        if (uiBase == null)
        {
            Debug.LogError($"UI预制体 {uiName} 没有 UIBase 组件或类型不匹配");
            return null;
        }

        uiBase.uiName = uiName;

        Transform parentTrans = GetTransForLayer(uiBase.uiLayer);
        uiObject.transform.SetParent(parentTrans, false);

        int baseSortingOrder = GetBaseSortingOrderForLayer(uiBase.uiLayer);
        uiBase.SetSortingOrder(baseSortingOrder);

        return uiBase;
    }

    /// <summary>
    /// US2: 异步打开窗口。
    /// </summary>
    public async UniTask<UIBase> OpenWindowAsync(string uiName, int functionOrder = 0)
    {
        UIBase returnValue = null;
        UIBase parentUI = null;

        // Check closed cache
        if (closedUIDict.TryGetValue(uiName, out var closedUIList) && closedUIList.Count > 0)
        {
            returnValue = closedUIList[0] as UIBase;
            closedUIList.RemoveAt(0);
            if (closedUIList.Count == 0)
            {
                closedUIDict.Remove(uiName);
            }
        }
        else
        {
            // US3: Show loading indicator while loading UI prefab (auto-hide after load)
            ShowLoadingIndicator();
            try
            {
                returnValue = await LoadUIResourceAsync(uiName);
            }
            finally
            {
                HideLoadingIndicator();
            }

            if (returnValue == null)
            {
                Debug.LogError($"打开UI失败: {uiName}");
                return null;
            }
        }

        returnValue.gameObject.SetActive(true);

        if (returnValue.supportParentChildRelation && uiStack.Count > 0 && !returnValue.isMainUI)
        {
            parentUI = GetLastSupportParentChildRelationUI();
        }

        if (parentUI != null)
        {
            returnValue.parentUI = parentUI;
            if (parentUI.childrenUI == null)
            {
                parentUI.childrenUI = new List<UIBase>();
            }
            parentUI.childrenUI.Add(returnValue);
        }

        currentRound++;
        returnValue.lastUsedRound = currentRound;
        UpdateParentUIRounds(returnValue);

        if (!uiDict.ContainsKey(uiName))
        {
            uiDict[uiName] = new List<UIBase>();
        }
        uiDict[uiName].Add(returnValue);

        uiStack.Push(returnValue);
        UpdateUISortingOrder();

        returnValue.functionOrder = functionOrder;
        returnValue.HandleOpen();
        OnOpenWindow?.Invoke(returnValue);
        CheckAndCloseIdleUI();

        return returnValue;
    }

    /// <summary>
    /// US2: 泛型 异步打开窗口。
    /// </summary>
    public async UniTask<T> OpenWindowAsync<T>(int functionOrder = 0) where T : UIBase
    {
        if (typeof(T).Name == "MainWin")
        {
            //MainWin 比较关键且唯一，做安全防范
            var ui = GetUI<MainWin>();
            if (ui != null)
            {
                ui.ClickFunc(0);
                return ui as T;
            }
        }
        string uiName = typeof(T).Name;
        var result = await OpenWindowAsync(uiName, functionOrder);
        return result as T;
    }

    // ====================================================================
    // US3: Loading indicator for async UI loading
    // ====================================================================

    private GameObject _loadingIndicatorGO;
    private int _loadingRefCount;

    /// <summary>
    /// US3: 显示加载指示器（引用计数，支持重入）。
    /// </summary>
    public void ShowLoadingIndicator()
    {
        _loadingRefCount++;
        if (_loadingRefCount == 1)
        {
            EnsureLoadingIndicator();
            if (_loadingIndicatorGO != null)
            {
                _loadingIndicatorGO.SetActive(true);
            }
        }
    }

    /// <summary>
    /// US3: 隐藏加载指示器。
    /// </summary>
    public void HideLoadingIndicator()
    {
        _loadingRefCount = Mathf.Max(0, _loadingRefCount - 1);
        if (_loadingRefCount == 0 && _loadingIndicatorGO != null)
        {
            _loadingIndicatorGO.SetActive(false);
        }
    }

    public void DumpUIDiagnostics(string context)
    {
        var eventSystem = EventSystem.current;
        Debug.Log($"[UIManager][Diag] {context} EventSystem={(eventSystem != null ? eventSystem.name : "<null>")} selected={(eventSystem != null && eventSystem.currentSelectedGameObject != null ? eventSystem.currentSelectedGameObject.name : "<null>")} loadingIndicatorActive={(_loadingIndicatorGO != null && _loadingIndicatorGO.activeSelf)} loadingRefCount={_loadingRefCount} uiStackCount={uiStack.Count}");
        LogUIRootEventSystemState(context);

        var uiArray = new UIBase[uiStack.Count];
        uiStack.CopyTo(uiArray, 0);
        foreach (var ui in uiArray)
        {
            if (ui == null)
            {
                continue;
            }

            var uiCanvas = ui.GetComponent<Canvas>();
            var uiCanvasGroup = ui.GetComponent<CanvasGroup>();
            Debug.Log($"[UIManager][Diag] {context} ui={ui.GetType().Name} active={ui.gameObject.activeInHierarchy} layer={ui.uiLayer} sortingOrder={(uiCanvas != null ? uiCanvas.sortingOrder : -1)} siblingIndex={ui.transform.GetSiblingIndex()} canvasGroup.blocksRaycasts={(uiCanvasGroup != null ? uiCanvasGroup.blocksRaycasts : false)} canvasGroup.interactable={(uiCanvasGroup != null ? uiCanvasGroup.interactable : false)}");
        }
    }

    private void LogUIRootEventSystemState(string context)
    {
        if (uiRoot == null)
        {
            Debug.Log($"[UIManager][Diag] {context} uiRoot=<null>");
            return;
        }

        var eventSystemTransform = uiRoot.Find("EventSystem");
        if (eventSystemTransform == null)
        {
            Debug.Log($"[UIManager][Diag] {context} uiRoot.EventSystem child=<null>");
            return;
        }

        var eventSystemComponent = eventSystemTransform.GetComponent<EventSystem>();
        var standaloneInputModule = eventSystemTransform.GetComponent<StandaloneInputModule>();
        var baseInputModule = eventSystemTransform.GetComponent<BaseInputModule>();
        Debug.Log($"[UIManager][Diag] {context} uiRoot.EventSystem childExists=true activeSelf={eventSystemTransform.gameObject.activeSelf} activeInHierarchy={eventSystemTransform.gameObject.activeInHierarchy} eventSystemComponent={(eventSystemComponent != null)} standaloneInputModule={(standaloneInputModule != null)} baseInputModuleType={(baseInputModule != null ? baseInputModule.GetType().Name : "<null>")} currentMatchesChild={(EventSystem.current == eventSystemComponent)}");
    }

    private void EnsureLoadingIndicator()
    {
        if (_loadingIndicatorGO != null) return;

        // 创建简易加载指示器: 半透明遮罩 + 旋转图标
        var canvas = uiRoot != null ? uiRoot.GetComponentInChildren<Canvas>() : null;
        if (canvas == null) return;

        _loadingIndicatorGO = new GameObject("UILoadingIndicator");
        _loadingIndicatorGO.transform.SetParent(canvas.transform, false);

        // 全屏半透明遮罩
        var maskRT = _loadingIndicatorGO.AddComponent<RectTransform>();
        maskRT.anchorMin = Vector2.zero;
        maskRT.anchorMax = Vector2.one;
        maskRT.offsetMin = Vector2.zero;
        maskRT.offsetMax = Vector2.zero;

        var maskImage = _loadingIndicatorGO.AddComponent<UnityEngine.UI.Image>();
        maskImage.color = new Color(0, 0, 0, 0.3f);
        maskImage.raycastTarget = true; // 拦截点击

        // 加载提示文字
        var textGO = new GameObject("LoadingText");
        textGO.transform.SetParent(_loadingIndicatorGO.transform, false);
        var textRT = textGO.AddComponent<RectTransform>();
        textRT.anchorMin = new Vector2(0.5f, 0.5f);
        textRT.anchorMax = new Vector2(0.5f, 0.5f);
        textRT.sizeDelta = new Vector2(300, 60);

        var text = textGO.AddComponent<UnityEngine.UI.Text>();
        text.text = "Loading...";
        text.alignment = TextAnchor.MiddleCenter;
        text.fontSize = 28;
        text.color = Color.white;
        text.font = UnityEngine.Font.CreateDynamicFontFromOSFont("Arial", 28);

        // 确保在最上层
        var sortCanvas = _loadingIndicatorGO.AddComponent<Canvas>();
        sortCanvas.overrideSorting = true;
        sortCanvas.sortingOrder = 30000;
        _loadingIndicatorGO.AddComponent<UnityEngine.UI.GraphicRaycaster>();

        _loadingIndicatorGO.SetActive(false);
    }
    
    #endregion

    #region UI排序管理
    
    // 更新UI排序顺序
    private void UpdateUISortingOrder()
    {
        // 重置当前最高排序顺序
        currentHighestSortingOrder = 0;
        
        // 复用临时列表，避免每次分配数组
        _sortTempList.Clear();
        _sortOrderDict.Clear();
        
        int index = 0;
        foreach (var ui in uiStack)
        {
            if (ui != null)
            {
                _sortTempList.Add(ui);
                _sortOrderDict[ui] = index;
                index++;
            }
        }

        _sortTempList.Sort((a, b) =>
        {
            if (a == null || b == null) return 0;
            int layerCompare = a.uiLayer.CompareTo(b.uiLayer);
            if (layerCompare != 0)
                return layerCompare;

            return _sortOrderDict[b].CompareTo(_sortOrderDict[a]);
        });

        // 遍历排序后的UI列表，设置排序顺序
        for (int i = 0; i < _sortTempList.Count; i++)
        {
            var ui = _sortTempList[i];
            if (ui == null) continue;
            // 获取基础排序顺序
            int baseSortingOrder = GetBaseSortingOrderForLayer(ui.uiLayer);
            // 计算当前UI的排序顺序
            int sortingOrder = baseSortingOrder + currentHighestSortingOrder;
            // 设置UI的排序顺序
            ui.SetSortingOrder(sortingOrder);
            // 更新当前最高排序顺序
            currentHighestSortingOrder += ui.uiLayer == UILayer.Static ? 155/*这里是角色+特效之上的层级*/ : 10;

            // Debug.Log(ui.uiName + " order is " + sortingOrder + " " + currentHighestSortingOrder);
        }
        OnAfterSortWinLayer?.Invoke();
    }
    
    #endregion

    #region UI操作



    private UIBase GetLastSupportParentChildRelationUI()
    {

        foreach (var uiBase in uiStack)
        {
            if (uiBase != null && uiBase.supportParentChildRelation)
            {
                return uiBase;
            }
        }

        return null;
    }

    /// <summary>
    /// 关闭UI
    /// </summary>
    public void CloseWindow<T>(bool destroy = false) where T : UIBase
    {
        // 获取UI类型名称
        string uiName = typeof(T).Name;
        
        CloseWindow(uiName, destroy);
        
    }

    public void CloseWindow(string uiName, bool destroy = false)
    {
        // 检查UI是否存在
        if (!uiDict.ContainsKey(uiName) || uiDict[uiName].Count == 0)
        {
            // 记录警告日志
            Debug.LogWarning($"尝试关闭不存在的UI: {uiName}");
            return;
        }
        
        // 获取第一个UI实例
        UIBase ui = uiDict[uiName][0];
        
        // 关闭UI
        CloseWindow(ui, destroy);
    }
    
    /// <summary>
    /// 关闭指定的UI实例
    /// </summary>
    public void CloseWindow(UIBase ui, bool destroy = false)
    {
        // 检查UI是否为空
        if (ui == null)
        {
            // 记录警告日志
            Debug.LogWarning("尝试关闭空UI");
            return;
        }

        if (!ui.IsActive())
        {
            return;
        }
        
        // 获取UI类型名称
        string uiName = ui.uiName;
#if UNITY_EDITOR
        Debug.Log("CloseWindow " + uiName + " destroy : " + destroy.ToString());
#endif

        // 收集所有子UI
        List<UIBase> childrenUI = new List<UIBase>();
        if (ui.supportParentChildRelation)
        {
            CollectChildrenUI(ui, childrenUI);
        }
        
        // 先关闭所有子UI
        foreach (var childUI in childrenUI)
        {
            // 关闭子UI
            CloseWindow(childUI, destroy);
        }
        
        // 从栈中移除UI
        Stack<UIBase> tempStack = new Stack<UIBase>();
        while (uiStack.Count > 0)
        {
            // 弹出栈顶UI
            UIBase tempUI = uiStack.Pop();
            // 如果不是要关闭的UI，则保存到临时栈中
            if (tempUI != ui)
            {
                tempStack.Push(tempUI);
            }
            else
            {
                break;
            }
        }
        
        // 将临时栈中的UI重新压入栈中
        while (tempStack.Count > 0)
        {
            uiStack.Push(tempStack.Pop());
        }
        
        // 从字典中移除UI
        if (uiDict.ContainsKey(uiName))
        {
            // 从UI列表中移除
            uiDict[uiName].Remove(ui);
            // 如果列表为空，从字典中移除该类型
            if (uiDict[uiName].Count == 0)
            {
                uiDict.Remove(uiName);
            }
        }
        
        // 从父级UI的子UI列表中移除
        if (ui.supportParentChildRelation && ui.parentUI != null && ui.parentUI.childrenUI != null)
        {
            // 从父级UI的子UI列表中移除
            ui.parentUI.childrenUI.Remove(ui);
        }
        
        // 关闭UI
        ui.HandleClose();
        OnCloseWindow?.Invoke(ui);

        if (destroy)
        {
            // 销毁UI对象
            GameObject.Destroy(ui.gameObject);
        }
        else
        {
            // 添加到closedUIDict
            if (!closedUIDict.ContainsKey(uiName))
            {
                closedUIDict[uiName] = new List<UIBase>();
            }
            closedUIDict[uiName].Add(ui);

#if UNITY_EDITOR
            Debug.Log("CloseWindow " + uiName + " destroy : " + destroy.ToString() + " push to closedUIDict");
#endif

            // 隐藏UI (交给handle close内部自己去做)
            // ui.gameObject.SetActive(false);
        }
        
        // 更新UI排序顺序
        UpdateUISortingOrder();
    }
    
    /// <summary>
    /// 关闭指定类型的所有UI实例
    /// </summary>
    public void CloseAllWindows<T>() where T : UIBase
    {
        // 获取UI类型名称
        string uiName = typeof(T).Name;
        
        // 检查UI是否存在
        if (!uiDict.ContainsKey(uiName) || uiDict[uiName].Count == 0)
        {
            // 记录警告日志
            Debug.LogWarning($"尝试关闭不存在的UI: {uiName}");
            return;
        }
        
        // 创建UI实例列表的副本，因为在关闭过程中会修改原列表
        List<UIBase> uiListCopy = new List<UIBase>(uiDict[uiName]);
        
        // 关闭所有UI实例
        foreach (var ui in uiListCopy)
        {
            // 关闭UI实例
            CloseWindow(ui, false);
        }
    }

    
    /// <summary>
    /// 关闭所有UI
    /// </summary>
    public void DestroyAllUI()
    {
        // 创建UI栈的副本，因为在关闭过程中会修改原栈
        UIBase[] uiArray = new UIBase[uiStack.Count];
        uiStack.CopyTo(uiArray, 0);
        
        // 关闭所有UI
        foreach (var ui in uiArray)
        {
            // 关闭UI
            CloseWindow(ui, true);
        }
        
        foreach (var uiList in closedUIDict.Values)
        {
            foreach (var ui in uiList)
            {
                GameObject.Destroy(ui.gameObject);
            }
        }

        // 清空UI字典和栈
        uiDict.Clear();
        uiStack.Clear();
        closedUIDict.Clear();
    }
    
    /// <summary>
    /// 刷新UI
    /// </summary>
    public void RefreshUI<T>() where T : UIBase
    {
        // 获取UI类型名称
        string uiName = typeof(T).Name;
        
        // 检查UI是否存在
        if (!uiDict.ContainsKey(uiName) || uiDict[uiName].Count == 0)
        {
            // 记录警告日志
            Debug.LogWarning($"尝试刷新不存在的UI: {uiName}");
            return;
        }
        
        // 刷新所有该类型的UI实例
        foreach (var ui in uiDict[uiName])
        {
            // 刷新UI
            ui.Refresh();
        }
    }
    
    /// <summary>
    /// 刷新所有UI
    /// </summary>
    public void RefreshAllUI()
    {
        // 遍历所有UI类型
        foreach (var uiList in uiDict.Values)
        {
            // 遍历该类型的所有UI实例
            foreach (var ui in uiList)
            {
                // 刷新UI
                ui.Refresh();
            }
        }
    }
    
    private void Update()
    {
        // 如果距离上次检查的时间超过了检查间隔
        if (Time.time - lastCheckTime > CHECK_INTERVAL)
        {
            // 更新上次检查时间
            lastCheckTime = Time.time;
            // 检查并关闭长时间未使用的UI
            CheckAndCloseIdleUI();
        }
    }
    
    #endregion

    #region 释放资源
    
    /// <summary>
    /// 释放资源
    /// </summary>
    public override void Release()
    {
        // 关闭所有UI
        DestroyAllUI();
        
        // 清空缓存
        layerSortingOrderCache.Clear();
        layerTransformCache.Clear();
        uiInstanceCounter.Clear();
        
        Debug.Log("UI管理器资源释放完成");
    }
    
    #endregion
}