VanguardReMaster/client/Assets/Vanguard/Runtime/App/LobbySceneController.cs

using UnityEngine;
using Vanguard.Api.Contracts;
using Vanguard.Auth;
using Vanguard.Battle;
using Vanguard.Meta;
using Vanguard.State;
using Vanguard.UI;

namespace Vanguard.App
{
    public sealed class LobbySceneController : SceneControllerBase
    {
        private AuthService _auth;
        private MetaService _meta;
        private PlayerState _player;
        private AppConfig _config;
        private LobbyView _lobby;
        private BattleEntryOverlay _battleEntry;
        private ComingSoonOverlay _rating;
        private OnboardingView _onboarding;
        private QueueView _queue;
        private StoreView _store;
        private HistoryView _history;

        private void Start()
        {
            _auth = Resolve<AuthService>();
            _meta = Resolve<MetaService>();
            _player = Resolve<PlayerState>();
            _config = Resolve<AppConfig>();

            var canvas = CreateCanvas("Lobby Canvas");
            LobbyBackdrop.Create(canvas.transform);

            _lobby = new LobbyView(
                canvas.transform,
                _config,
                _auth,
                _player,
                OnLogout,
                ShowBattleEntry,
                () => _ = Flow.LoadDeckBuilderAsync(),
                ShowStore,
                ShowHistory,
                ShowRating,
                ShowCommunity);

            _battleEntry = new BattleEntryOverlay(
                canvas.transform,
                _meta,
                _auth,
                OnRanked,
                OnPracticeStarted,
                () => _ = Flow.LoadDeckBuilderAsync());

            _rating = new ComingSoonOverlay(
                canvas.transform,
                "RatingOverlay",
                "Рейтинг",
                "Топ игроков по рейтингу появится позже: нужен серверный лидерборд.");

            _onboarding = new OnboardingView(
                canvas.transform, _auth, _meta, OnOnboarded, OnLogout);
            _queue = new QueueView(
                canvas.transform, _meta, _auth, OnQueueBack, OnMatched);
            _store = new StoreView(
                canvas.transform, _meta, _auth, _player, OnStoreBack);
            _history = new HistoryView(
                canvas.transform, _meta, _auth, OnHistoryBack);

            var hotkeys = canvas.gameObject.AddComponent<HotkeysDriver>();
            hotkeys.Cancel = CloseTopmost;

            ShowDefault();
        }

        private void ShowDefault()
        {
            var pendingDeck = Flow.ConsumePendingQueueDeck();
            if (pendingDeck != null)
            {
                HideAll();
                _queue.Show(pendingDeck);
                return;
            }

            HideAll();
            if (_player.OnboardingCompleted)
                _lobby.Show();
            else
                _onboarding.Show();
        }

        private void ShowBattleEntry()
        {
            _battleEntry.Show();
        }

        private void ShowRating()
        {
            _rating.Show();
        }

        private void ShowCommunity()
        {
            _ = Flow.LoadCommunityAsync();
        }

        private void ShowStore()
        {
            HideAll();
            _store.Show();
        }

        private void OnStoreBack()
        {
            _store.Hide();
            _lobby.Show();
        }

        private void ShowHistory()
        {
            HideAll();
            _history.Show();
        }

        private void OnHistoryBack()
        {
            _history.Hide();
            _lobby.Show();
        }

        private void OnOnboarded()
        {
            HideAll();
            _lobby.Show();
        }

        private void OnQueueBack()
        {
            _queue.Hide();
            _lobby.Show();
        }

        private void OnRanked(DeckDto deck)
        {
            HideAll();
            _queue.Show(deck);
        }

        private void OnPracticeStarted(MatchConnectionInfo info)
        {
            _ = Flow.LoadBattleAsync(info);
        }

        private void OnMatched(MatchConnectionInfo info)
        {
            _ = Flow.LoadBattleAsync(info);
        }

        private void OnLogout()
        {
            _ = Flow.LoadLoginAsync();
        }

        private void CloseTopmost()
        {
            if (_lobby != null && _lobby.IsMenuOpen)
            {
                _lobby.CloseMenu();
                return;
            }

            if (_battleEntry != null && _battleEntry.IsOpen)
            {
                _battleEntry.Close();
                return;
            }

            if (_rating != null && _rating.IsOpen)
                _rating.Close();
        }

        private void HideAll()
        {
            _lobby.Hide();
            _onboarding.Hide();
            _queue.Hide();
            _store.Hide();
            _history.Hide();
            _battleEntry.Close();
            _rating.Close();
        }

        private void OnDestroy()
        {
            _lobby?.Dispose();
            _store?.Dispose();
        }
    }
}