aibis-dream/Assets/Scripts/UI/Terminal/TerminalPanel.cs

using System;
using System;
using System.Collections.Generic;
using UnityEngine;

namespace AibisDream.UI
{
    public enum TerminalPage
    {
        None,
        Start,
        Setting,
        Chapter,
    }

    /// <summary>
    /// 主菜单终端 Panel 壳：管理 Start / Chapter / Setting 三个 Page。
    /// </summary>
    public class TerminalPanel : MonoBehaviour, IUIPanel, ITerminalPanelHost
    {
        [SerializeField] private TerminalHeaderView header;
        [SerializeField] private TerminalStartPanel startPage;
        [SerializeField] private TerminalSettingPanel settingPage;
        [SerializeField] private TerminalChapterPanel chapterPage;

        private readonly Stack<TerminalPage> _backStack = new();
        private TerminalPage _currentPage = TerminalPage.None;

        public bool IsOpen => gameObject.activeSelf && _currentPage != TerminalPage.None;
        public bool IsCloseable => false;
        public TerminalPage CurrentPage => _currentPage;
        public bool IsInGameContext => false;

        public void Initialize()
        {
            var root = transform;
            startPage ??= root.GetComponentInChildren<TerminalStartPanel>(true);
            settingPage ??= root.GetComponentInChildren<TerminalSettingPanel>(true);
            chapterPage ??= root.GetComponentInChildren<TerminalChapterPanel>(true);

            startPage?.SetOwner(this);
            settingPage?.SetOwner(this);
            chapterPage?.SetOwner(this);
            Close();
        }

        public bool HasRequiredPages()
        {
            return startPage != null && settingPage != null && chapterPage != null;
        }

        public void Show()
        {
            Open(TerminalPage.Start);
        }

        public void Hide()
        {
            Close();
        }

        public void Open(TerminalPage page)
        {
            if (!HasRequiredPages() || page == TerminalPage.None)
            {
                return;
            }

            if (!IsOpen)
            {
                _backStack.Clear();
            }

            gameObject.SetActive(true);
            SwitchTo(page, pushCurrent: false);
        }

        public void SwitchTo(TerminalPage page, bool pushCurrent = true)
        {
            if (page == TerminalPage.None || page == _currentPage)
            {
                return;
            }

            if (pushCurrent && _currentPage != TerminalPage.None)
            {
                _backStack.Push(_currentPage);
            }

            var previous = _currentPage;
            _currentPage = page;

            if (previous == TerminalPage.None)
            {
                ShowPage(_currentPage);
                return;
            }

            HidePage(previous, () => ShowPage(_currentPage));
        }

        public void Back()
        {
            if (_backStack.Count > 0)
            {
                var previous = _backStack.Pop();
                var current = _currentPage;
                _currentPage = previous;
                HidePage(current, () => ShowPage(_currentPage));
                return;
            }

            if (_currentPage != TerminalPage.Start)
            {
                SwitchTo(TerminalPage.Start, pushCurrent: false);
            }
        }

        public bool HandleEscape()
        {
            if (!IsOpen)
            {
                return false;
            }

            if (_currentPage == TerminalPage.Start)
            {
                return true;
            }

            Back();
            return true;
        }

        public void CloseThen(Action action)
        {
            Close();
            action?.Invoke();
        }

        public void Close()
        {
            HideAllPages();
            _backStack.Clear();
            _currentPage = TerminalPage.None;
            gameObject.SetActive(false);
        }

        public void CloseToMainMenu()
        {
            Close();
            GameManager.Instance.QuitGame();
        }

        public void SetHeader(string title, string status = "")
        {
            header?.SetText(title, status);
        }

        private void ShowPage(TerminalPage page)
        {
            switch (page)
            {
                case TerminalPage.Start:
                    startPage?.Show();
                    break;
                case TerminalPage.Setting:
                    settingPage?.Show();
                    break;
                case TerminalPage.Chapter:
                    chapterPage?.Show();
                    break;
            }
        }

        private void HidePage(TerminalPage page, Action onComplete = null)
        {
            switch (page)
            {
                case TerminalPage.Start:
                    HidePage(startPage, onComplete);
                    break;
                case TerminalPage.Setting:
                    HidePage(settingPage, onComplete);
                    break;
                case TerminalPage.Chapter:
                    HidePage(chapterPage, onComplete);
                    break;
                default:
                    onComplete?.Invoke();
                    break;
            }
        }

        private static void HidePage(MonoBehaviour page, Action onComplete)
        {
            if (page == null)
            {
                onComplete?.Invoke();
                return;
            }

            switch (page)
            {
                case TerminalStartPanel startPanel:
                    startPanel.Hide(onComplete);
                    break;
                case TerminalSettingPanel settingPanel:
                    settingPanel.Hide(onComplete);
                    break;
                case TerminalChapterPanel chapterPanel:
                    chapterPanel.Hide(onComplete);
                    break;
                default:
                    page.gameObject.SetActive(false);
                    onComplete?.Invoke();
                    break;
            }
        }

        private void HideAllPages()
        {
            startPage?.Hide();
            settingPage?.Hide();
            chapterPage?.Hide();
        }
    }
}