SVSimServer/SVSim.BattleNode/Sessions/BattleSession.cs

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 + noStock
/// flag) and dispatches via <see cref="IBattleParticipant.PushAsync"/>.
/// </summary>
/// <remarks>
/// Phase 1 wires this for <see cref="BattleType.Scripted"/> only — the dispatch logic
/// preserves v1.2 behaviour. Phase 2 wires Pvp (broadcast Matched/BattleStart per-perspective,
/// forward gameplay frames between participants). Phase 3 wires Bot (ack-only).
/// </remarks>
public sealed class BattleSession
{
    private readonly ILogger<BattleSession> _log;

    private readonly BattleSessionState _state = new();

    public string BattleId { get; }
    public BattleType Type { get; }
    public IBattleParticipant A { get; }
    public IBattleParticipant B { get; }
    public BattleSessionPhase Phase => _state.SessionPhase;

    // 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] = forwardWhenReady,
            [NetworkBattleUri.Echo] = forwardWhenReady,
            [NetworkBattleUri.TurnEndActions] = forwardWhenReady,
            [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, Type = Type, BattleId = BattleId, State = _state,
        };

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

        // 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.
            // ScriptedBotParticipant.RunAsync also returns immediately; that's not used
            // here (Pvp has two RealParticipants), but we'd still want a synthesized
            // 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 (Phase != BattleSessionPhase.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), noStock: true, 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.SessionPhase = BattleSessionPhase.Terminal;
            }

            cts.Cancel(); // unblock the survivor's RunAsync read loop
            try { await Task.WhenAll(aTask, bTask).ConfigureAwait(false); }
            catch { /* swallow cancellation / WS exceptions */ }
        }
        else
        {
            // Phase 1 semantics for Scripted/Bot: wait for ALL participants. The bot's
            // RunAsync returns immediately; the session keeps running for the real one.
            try { await Task.WhenAll(aTask, bTask).ConfigureAwait(false); }
            catch { /* swallow */ }
        }

        // Audit Md11 — release per-participant outbound archives at battle-end
        // (only RealParticipant has one; bots don't archive). Heavy state is
        // dropped synchronously here so the participant's TerminateAsync doesn't
        // need to keep the dict alive through its disposal handshake.
        if (A is RealParticipant rpA) rpA.Outbound.Clear();
        if (B is RealParticipant rpB) rpB.Outbound.Clear();

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

    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)
    {
        try
        {
            var routes = ComputeFrames(from, env);
            foreach (var (target, frame, noStock) in routes)
            {
                await target.PushAsync(frame, noStock, ct);
            }
        }
        catch (Exception ex)
        {
            _log.LogError(ex, "BattleSession {Bid}: unhandled in HandleFrameAsync", BattleId);
        }
    }

    /// <summary>
    /// Pure-logic dispatch: given an inbound frame from one participant, return the list
    /// of (target, frame, noStock) tuples 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)
    {
        if (Handlers.TryGetValue(env.Uri, out var handler))
            return handler.Handle(BuildContext(from, env));

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

}