SVSimServer/SVSim.BattleNode/Sessions/BattleSession.cs

using System.Net.WebSockets;
using Microsoft.Extensions.Logging;
using SVSim.BattleNode.Protocol;
using SVSim.BattleNode.Sessions.Dispatch;
using SVSim.BattleNode.Sessions.Dispatch.Handlers;
using SVSim.BattleNode.Sessions.Participants;

namespace SVSim.BattleNode.Sessions;

/// <summary>
/// v2 broker session. Holds two participants and brokers between them. Subscribes
/// to each participant's <see cref="IBattleParticipant.FrameEmitted"/>; on each frame,
/// runs <see cref="ComputeFrames"/> to determine the routing (target + frame + <see cref="Stock"/>
/// flag) and dispatches via <see cref="IBattleParticipant.PushAsync"/>.
/// </summary>
/// <remarks>
/// Wires both battle modes: Pvp (broadcast Matched/BattleStart per-perspective, forward
/// gameplay frames between the two real participants) and Bot (ack-only, NoOp opponent).
/// </remarks>
public sealed class BattleSession
{
    private readonly ILogger<BattleSession> _log;

    private readonly BattleSessionState _state = new();

    /// <summary>One authoritative shadow engine per session (design ND2). Fed both clients' frames in
    /// pure shadow (N1): it tracks state but emits nothing and changes no route. N2+ flips outbound
    /// fields to engine reads. Constructed unconditionally; <see cref="EnsureEngineSetup"/> seats it
    /// once both decks are known, and every interaction is guarded so a shadow failure can never break
    /// live dispatch (ND6: log, never throw into the relay).</summary>
    private readonly Engine.SessionBattleEngine _engine = new();

    /// <summary>Setup is attempted exactly once. A shadow engine that can't seat headless in this host
    /// (e.g. engine global state not initialized) stays not-ready and the shadow silently no-ops —
    /// never retried, never fatal.</summary>
    private bool _engineSetupAttempted;

    /// <summary>True once this session has acquired the process-wide <see cref="Engine.EngineSessionGate"/>
    /// (and is therefore the single active engine owner). Drives the matching <c>Release</c> at battle
    /// end so the next session can take the engine.</summary>
    private bool _engineOwned;

    /// <summary>Serializes dispatch. Both participants' read loops raise FrameEmitted on their own
    /// threads, and a dispatch (<see cref="ComputeFrames"/> + the relay <c>PushAsync</c> calls) mutates
    /// shared, non-thread-safe state — the <see cref="BattleSessionState"/> dictionaries and each
    /// participant's <c>OutboundSequencer</c>. This gate funnels both threads through one critical
    /// section so concurrent frames can't corrupt that state.</summary>
    private readonly SemaphoreSlim _dispatchGate = new(1, 1);

    /// <summary>The per-battle master seed (see <see cref="BattleSessionState.MasterSeed"/>).
    /// Exposed for logging + future replay persistence.</summary>
    public int MasterSeed => _state.MasterSeed;

    public string BattleId { get; }
    public BattleType Type { get; }
    public IBattleParticipant A { get; }
    public IBattleParticipant B { get; }
    public SessionLifecycle Lifecycle => _state.Lifecycle;

    // Per-URI dispatch table. All 14 inbound URIs are registered (Tasks 5-14); unknown
    // URIs are dropped with a LogDebug in ComputeFrames.
    private static readonly IReadOnlyDictionary<NetworkBattleUri, IFrameHandler> Handlers = BuildHandlers();

    private static IReadOnlyDictionary<NetworkBattleUri, IFrameHandler> BuildHandlers()
    {
        var retireKill = new RetireKillHandler();
        var forwardWhenReady = new ForwardWhenBothReadyHandler();
        return new Dictionary<NetworkBattleUri, IFrameHandler>
        {
            [NetworkBattleUri.InitNetwork] = new InitNetworkHandler(),
            [NetworkBattleUri.InitBattle] = new InitBattleHandler(),
            [NetworkBattleUri.Loaded] = new LoadedHandler(),
            [NetworkBattleUri.Swap] = new SwapHandler(),
            [NetworkBattleUri.TurnEnd] = new TurnEndHandler(),
            [NetworkBattleUri.TurnEndFinal] = new TurnEndFinalHandler(),
            [NetworkBattleUri.Retire] = retireKill,
            [NetworkBattleUri.Kill] = retireKill,
            [NetworkBattleUri.TurnStart] = new TurnStartHandler(),
            [NetworkBattleUri.Judge] = new JudgeHandler(),
            [NetworkBattleUri.PlayActions] = new PlayActionsHandler(),
            [NetworkBattleUri.Echo] = new EchoHandler(),
            [NetworkBattleUri.TurnEndActions] = new TurnEndActionsHandler(),
            [NetworkBattleUri.JudgeResult] = forwardWhenReady,
        };
    }

    private FrameDispatchContext BuildContext(IBattleParticipant from, MsgEnvelope env) =>
        new()
        {
            A = A, B = B, From = from, Other = ReferenceEquals(from, A) ? B : A,
            Env = env, BattleId = BattleId, State = _state, Engine = _engine,
        };

    public BattleSession(string battleId, BattleType type, IBattleParticipant a, IBattleParticipant b,
        ILogger<BattleSession> log)
    {
        BattleId = battleId;
        Type = type;
        A = a;
        B = b;
        _log = log;

        _log.LogInformation("BattleSession {Bid}: master seed {Seed}", BattleId, _state.MasterSeed);

        // Subscribe to both participants' emissions.
        A.FrameEmitted += OnFrameFromA;
        B.FrameEmitted += OnFrameFromB;
    }

    public async Task RunAsync(CancellationToken cancellation)
    {
        using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellation);
        var aTask = A.RunAsync(cts.Token);
        var bTask = B.RunAsync(cts.Token);

        if (Type == BattleType.Pvp)
        {
            // WhenAny: first WS drop / first graceful close triggers cascade. Pvp has two
            // RealParticipants; we synthesize a BattleFinish for the survivor if either side
            // terminates first.
            var first = await Task.WhenAny(aTask, bTask).ConfigureAwait(false);
            var survivor = first == aTask ? B : A;

            if (Lifecycle != SessionLifecycle.Terminal)
            {
                // Involuntary drop (no graceful Retire): synthesize BattleFinish(DisconnectWin)
                // to survivor. DisconnectWin=201 → client renders "opponent disconnected" →
                // WIN UI; the legacy Win=1 used here previously rendered "no contest".
                try
                {
                    await survivor.PushAsync(
                        BattleFrames.BuildBattleFinish(BattleResult.DisconnectWin), Stock.Bypass, cancellation)
                        .ConfigureAwait(false);
                }
                catch (Exception ex)
                {
                    _log.LogWarning(ex,
                        "BattleSession {Bid}: failed to push BattleFinish to survivor (their WS may also be closed)",
                        BattleId);
                }
                _state.Lifecycle = SessionLifecycle.Terminal;
            }

            cts.Cancel(); // unblock the survivor's RunAsync read loop
            try { await Task.WhenAll(aTask, bTask).ConfigureAwait(false); }
            catch (Exception ex) when (ex is OperationCanceledException or WebSocketException) { }
            catch (AggregateException ex) when (ex.Flatten().InnerExceptions.All(
                e => e is OperationCanceledException or WebSocketException)) { }
            catch (Exception ex)
            {
                _log.LogWarning(ex, "BattleSession {Bid}: unexpected exception from WhenAll (PvP drain)", BattleId);
            }
        }
        else
        {
            // Bot mode: the NoOp opponent's RunAsync returns immediately; wait for the real
            // participant. The session keeps running for the real one.
            try { await Task.WhenAll(aTask, bTask).ConfigureAwait(false); }
            catch (Exception ex) when (ex is OperationCanceledException or WebSocketException) { }
            catch (AggregateException ex) when (ex.Flatten().InnerExceptions.All(
                e => e is OperationCanceledException or WebSocketException)) { }
            catch (Exception ex)
            {
                _log.LogWarning(ex, "BattleSession {Bid}: unexpected exception from WhenAll (Bot drain)", BattleId);
            }
        }

        // Unsubscribe event handlers so the session + state aren't pinned by live delegates.
        A.FrameEmitted -= OnFrameFromA;
        B.FrameEmitted -= OnFrameFromB;

        // Release per-participant outbound archives at battle-end
        // (only RealParticipant has one; bots don't archive).
        if (A is RealParticipant rpA) rpA.Outbound.Clear();
        if (B is RealParticipant rpB) rpB.Outbound.Clear();

        try
        {
            await Task.WhenAll(
                A.TerminateAsync(BattleFinishReason.NormalFinish),
                B.TerminateAsync(BattleFinishReason.NormalFinish))
                .ConfigureAwait(false);

            await A.DisposeAsync().ConfigureAwait(false);
            await B.DisposeAsync().ConfigureAwait(false);
            _dispatchGate.Dispose();
        }
        finally
        {
            // Release the single-active-engine gate exactly once, in a finally so a throw from the
            // terminate/dispose teardown above can never leak it to the next session (the gate is a
            // process-global static shared across all sessions, incl. across tests in one process).
            if (_engineOwned) Engine.EngineSessionGate.Release();
        }
    }

    private Task OnFrameFromA(MsgEnvelope env, CancellationToken ct) => HandleFrameAsync(A, env, ct);
    private Task OnFrameFromB(MsgEnvelope env, CancellationToken ct) => HandleFrameAsync(B, env, ct);

    private async Task HandleFrameAsync(IBattleParticipant from, MsgEnvelope env, CancellationToken ct)
    {
        await _dispatchGate.WaitAsync(ct).ConfigureAwait(false);
        try
        {
            var routes = ComputeFrames(from, env);
            foreach (var (target, frame, stock) in routes)
            {
                await target.PushAsync(frame, stock, ct);
            }
        }
        catch (Exception ex)
        {
            _log.LogError(ex, "BattleSession {Bid}: unhandled in HandleFrameAsync", BattleId);
        }
        finally
        {
            _dispatchGate.Release();
        }
    }

    /// <summary>
    /// Pure-logic dispatch: given an inbound frame from one participant, return the list
    /// of (target, frame, stock) routes the session should dispatch. Transitions
    /// <see cref="Phase"/>. Extracted so unit tests can drive the dispatch without
    /// standing up real participants.
    /// </summary>
    internal IReadOnlyList<DispatchRoute> ComputeFrames(IBattleParticipant from, MsgEnvelope env)
    {
        // Shadow engine (N1): seat-once then ingest this frame, fully isolated from dispatch. The
        // wire output below is byte-for-byte unchanged — routes still come from the existing handlers;
        // the engine only observes (ND1). A shadow failure is logged and swallowed (ND6), never thrown
        // into the relay.
        try
        {
            EnsureEngineSetup();
            ShadowIngest(from, env);
        }
        catch (Exception ex)
        {
            _log.LogWarning(ex, "BattleSession {Bid}: shadow engine error (ignored)", BattleId);
        }

        if (Handlers.TryGetValue(env.Uri, out var handler))
            return handler.Handle(BuildContext(from, env));

        _log.LogDebug("BattleSession {Bid}: dropping uri={Uri} in lifecycle={Lifecycle} from vid={Vid}",
            BattleId, env.Uri, Lifecycle, from.ViewerId);
        return Array.Empty<DispatchRoute>();
    }

    /// <summary>Seat the shadow engine once, from the master seed + both deterministically-shuffled
    /// decks the node already computed (F-N-5). Attempted a single time; if the host can't seat the
    /// engine headless, it stays not-ready and the shadow no-ops for the rest of the battle.</summary>
    private void EnsureEngineSetup()
    {
        if (_engineSetupAttempted) return;
        _engineSetupAttempted = true;

        // Single-active-engine gate: the engine's process-global turn state can't back two concurrent
        // battles, so only one session may own it (carried-risk B). On failure we DON'T set the engine
        // up — it stays not-ready and ShadowIngest no-ops on !IsReady — and log the limitation loudly
        // (not a silent fallback). Per-session isolation (dropping the gate) is the tracked follow-up.
        if (!Engine.EngineSessionGate.TryAcquire())
        {
            _log.LogWarning("BattleSession {Bid}: another battle owns the engine; this battle runs " +
                "WITHOUT engine-sourced fields (single-active-engine limitation — per-session isolation pending)",
                BattleId);
            return;
        }
        _engineOwned = true;
        _engine.Setup(_state.MasterSeed,
            _state.GetShuffledDeck(A), _state.GetShuffledDeck(B),
            (int)A.Context.ClassId, (int)B.Context.ClassId);
    }

    private void ShadowIngest(IBattleParticipant from, MsgEnvelope env)
    {
        if (!_engine.IsReady) return;
        bool isPlayerSeat = ReferenceEquals(from, A);
        var r = _engine.Receive(env, isPlayerSeat);
        if (r.Diverged)
            _log.LogInformation("BattleSession {Bid}: shadow engine diverged on {Uri}: {Reason}",
                BattleId, env.Uri, r.RejectReason);
    }

}