Gen_Hack-and-Slash-Roguelite/Client/Assets/Scripts/Base/UIInputControl.cs

using System.Collections.Generic;
using System.Linq;
using UI;
using UnityEngine;
using UnityEngine.SceneManagement;

namespace Base
{
    /// <summary>
    /// UI窗口输入控制和管理类。
    /// 负责根据输入显示/隐藏UI，并根据UI状态管理游戏暂停。
    /// </summary>
    public class UIInputControl : Utils.MonoSingleton<UIInputControl>, ITickUI
    {
        // 存储场景中所有UIBase的实例
        private List<UIBase> _allWindows = new List<UIBase>();
        // 缓存当前可见的窗口
        private readonly List<UIBase> _visibleWindows = new List<UIBase>();

        private bool needUpdate = false;

        /// <summary>
        /// 获取所有已注册的UI窗口的总数量。
        /// </summary>
        public int AllWindowCount => _allWindows.Count;

        /// <summary>
        /// 获取当前可见的UI窗口的数量。
        /// </summary>
        public int VisibleWindowCount => _visibleWindows.Count;

        /// <summary>
        /// 查询指定名称的UI窗口是否当前可见。
        /// </summary>
        /// <param name="uiName">UI窗口的名称。</param>
        /// <returns>如果窗口可见则返回true，否则返回false。</returns>
        public bool IsWindowVisible(string uiName)
        {
            // 使用 Any() 方法检查 _visibleWindows 列表中是否存在名称匹配且可见的窗口
            return _visibleWindows.Any(window => window != null && window.name == uiName && window.IsVisible);
        }

        /// <summary>
        /// 查询指定名称的UI窗口是否当前处于可见状态且占用了输入。
        /// </summary>
        /// <param name="uiName">UI窗口的名称。</param>
        /// <returns>如果窗口可见且占用了输入则返回true，否则返回false。</returns>
        public bool IsWindowInputOccupied(string uiName)
        {
            // 检查 _visibleWindows 列表中是否存在名称匹配且同时占用输入的窗口
            return _visibleWindows.Any(window => window != null && window.name == uiName && window.IsVisible && window.isInputOccupied);
        }

        /// <summary>
        /// 根据名称获取已注册的UI窗口实例。
        /// </summary>
        /// <param name="uiName">UI窗口的名称。</param>
        /// <returns>匹配的UIBase实例，如果未找到则返回null。</returns>
        public UIBase GetWindow(string uiName)
        {
            // 从 _allWindows 列表中查找第一个名称匹配的窗口
            return _allWindows.FirstOrDefault(window => window != null && window.name == uiName);
        }

        /// <summary>
        /// 查找并注册场景中所有的UI窗口，包括非激活状态的。
        /// </summary>
        private void RegisterAllWindows()
        {
            _allWindows.Clear();

            // 获取当前活动场景中的所有 GameObject
            var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
            if (!activeScene.isLoaded)
            {
                Debug.LogWarning("[UIInputControl] 当前场景未加载，无法注册窗口！");
                return;
            }

            // 遍历场景中的所有根对象，并查找其子对象中的 UIBase
            foreach (var rootGameObject in activeScene.GetRootGameObjects())
            {
                var windows = rootGameObject.GetComponentsInChildren<UIBase>(true);
                _allWindows.AddRange(windows);
            }

            // 去重（如果有重复的窗口）
            _allWindows = _allWindows.Distinct().ToList();

            // 初始化所有窗口为隐藏状态
            foreach (var window in _allWindows)
            {
                // 确保窗口不为空且其GameObject未被销毁
                if (window != null && window.gameObject != null)
                {
                    window.Hide();
                }
            }

            needUpdate = true;
        }

        /// <summary>
        /// UI逻辑更新循环，需要被外部的某个管理器在Update中调用。
        /// </summary>
        public void TickUI()
        {
            // 使用这个是为了让输入独占窗口关闭自己后不会立即激活其他窗口的按键，延迟一帧
            if (needUpdate)
            {
                // 更新可见窗口缓存和暂停状态
                UpdateVisibleWindowsCache();
                UpdatePauseState();
                needUpdate = false;
                return;
            }
            
            // 如果有任何可见窗口占用了输入，则阻止其他窗口通过按键进行操作
            if(_visibleWindows.Any(window => window && window.isInputOccupied)) 
                return;

            foreach (var window in _allWindows)
            {
                // 确保窗口不为空且其GameObject未被销毁
                if (!window || !window.gameObject) continue;

                // 检查窗口是否设置了有效的激活按键，并且该按键在本帧被按下
                if (window.actionButton == KeyCode.None || !Input.GetKeyDown(window.actionButton)) continue;
                
                if (window.IsVisible)
                {
                    // 如果窗口当前是可见的，且未占用输入，则通过按键隐藏它
                    if (!window.isInputOccupied)
                    {
                        Hide(window);
                    }
                }
                else
                {
                    // 如果窗口当前是隐藏的，则显示它
                    Show(window);
                }
            }
        }

        /// <summary>
        /// 公开的显示窗口方法。
        /// </summary>
        /// <param name="windowToShow">要显示的窗口。</param>
        public void Show(UIBase windowToShow)
        {
            // 确保窗口不为空且未被销毁，并且当前不可见
            if (!windowToShow || !windowToShow.gameObject || windowToShow.IsVisible) return;

            // 如果窗口是独占的，隐藏所有其他窗口
            if (windowToShow.exclusive)
            {
                // 创建一个副本进行迭代，防止在 Hide() 调用中修改 _visibleWindows 导致迭代器失效
                var windowsToHide = _visibleWindows.ToList(); 
                foreach (var visibleWindow in windowsToHide)
                {
                    // 确保窗口不是要显示的窗口本身，且仍然可见
                    if (visibleWindow && visibleWindow != windowToShow && visibleWindow.IsVisible)
                    {
                        Hide(visibleWindow);
                    }
                }
            }

            // 显示目标窗口并更新缓存与暂停状态
            windowToShow.Show();
            var itick = windowToShow as ITickUI;
            if (itick != null)
                Base.Clock.AddTickUI(itick);
            
            needUpdate = true;
        }

        /// <summary>
        /// 根据名称显示UI窗口。
        /// </summary>
        /// <param name="uiName">要显示的UI窗口名称。</param>
        public void Show(string uiName)
        {
            // 使用 GetWindow 方法获取窗口实例
            var window = GetWindow(uiName);
            if (window != null)
            {
                Show(window);
                return;
            }
            Debug.LogWarning($"[UIInputControl] 未找到名称为 '{uiName}' 的窗口来显示。");
        }

        
        /// <summary>
        /// 公开的隐藏窗口方法。
        /// </summary>
        /// <param name="windowToHide">要隐藏的窗口。</param>
        public void Hide(UIBase windowToHide)
        {
            // 确保窗口不为空且未被销毁，并且当前可见
            if (!windowToHide || !windowToHide.gameObject || !windowToHide.IsVisible) return;

            // 隐藏目标窗口
            windowToHide.Hide();
            // 当UI窗口被隐藏时，如果它实现了ITickUI接口，则必须将其从Clock中移除。
            // 这防止了隐藏窗口继续被Tick，避免性能开销和潜在的NullReferenceException。
            if (windowToHide is ITickUI iTick)
                Base.Clock.RemoveTickUI(iTick);
    
            needUpdate = true;
        }

        /// <summary>
        /// 根据名称隐藏UI窗口。
        /// </summary>
        /// <param name="uiName">要隐藏的UI窗口名称。</param>
        public void Hide(string uiName)
        {
            // 仅在可见窗口中查找并隐藏，更符合HideByName的即时操作期望
            // 如果需要隐藏所有名称匹配的窗口（包括隐藏的），则需要遍历 _allWindows
            var visibleWindowToHide = _visibleWindows.FirstOrDefault(window => window != null && window.name == uiName && window.IsVisible);
            if (visibleWindowToHide != null)
            {
                Hide(visibleWindowToHide);
                return;
            }
            Debug.LogWarning($"[UIInputControl] 未找到名称为 '{uiName}' 且当前可见的窗口来隐藏。");
        }

        /// <summary>
        /// 隐藏所有当前可见的UI窗口。
        /// </summary>
        public void HideAll()
        {
            // 创建 _visibleWindows 的一个副本进行迭代，以避免在循环中修改原列表导致迭代器失效
            var windowsToHide = _visibleWindows.ToList(); 
            foreach (var visibleWindow in windowsToHide)
            {
                // 再次检查窗口是否仍然可见，因为其他操作可能已经隐藏了它
                if (visibleWindow != null && visibleWindow.IsVisible)
                {
                    Hide(visibleWindow);
                }
            }
        }

        /// <summary>
        /// 根据当前所有可见窗口的 needPause 属性来更新游戏时钟的暂停状态。
        /// </summary>
        private void UpdatePauseState()
        {
            // 确保 _visibleWindows 中的窗口都有效
            var shouldPause = _visibleWindows.Any(w => w && w.needPause);
            if (Base.Clock.Instance.Pause != shouldPause)
            {
                Base.Clock.Instance.Pause = shouldPause;
            }
        }

        /// <summary>
        /// 更新当前可见窗口的缓存列表。
        /// </summary>
        private void UpdateVisibleWindowsCache()
        {
            _visibleWindows.Clear();
            foreach (var window in _allWindows)
            {
                if (window && window.IsVisible) // 确保窗口有效且可见
                {
                    _visibleWindows.Add(window);
                }
            }
        }

        /// <summary>
        /// 当脚本实例被销毁时调用。
        /// 用于在销毁时取消订阅场景加载事件，防止内存泄漏。
        /// </summary>
        private void OnDestroy()
        {
            SceneManager.sceneLoaded -= OnSceneLoaded;
        }

        /// <summary>
        /// MonoSingleton 的 OnStart 方法，在单例首次创建并激活时调用，早于普通的 Start 方法。
        /// 用于订阅场景加载事件并在首次启动时注册UI窗口。
        /// </summary>
        protected override void OnStart()
        {
            // 订阅场景加载事件，以便在新场景加载后重新注册UI窗口
            SceneManager.sceneLoaded += OnSceneLoaded;
            // 首次启动时也注册一次窗口（例如在进入第一个场景时）。
            RegisterAllWindows();
        }

        /// <summary>
        /// 当场景加载完成时调用。
        /// 用于在场景加载后重新查找并注册所有UI窗口。
        /// </summary>
        /// <param name="scene">已加载的场景。</param>
        /// <param name="mode">场景加载模式。</param>
        private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
        {
            // 当场景加载时，重新查找并注册所有UI窗口
            RegisterAllWindows();
        }
    }
}