SVSimServer/SVSim.EmulatedEntrypoint/Controllers/RankBattleController.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SVSim.BattleNode.Bridge;
using SVSim.Database.Enums;
using SVSim.EmulatedEntrypoint.Constants;
using SVSim.EmulatedEntrypoint.Matching;
using SVSim.EmulatedEntrypoint.Models.Dtos.RankBattle;
using SVSim.EmulatedEntrypoint.Security.SteamSessionAuthentication;
using SVSim.EmulatedEntrypoint.Services;

namespace SVSim.EmulatedEntrypoint.Controllers;

/// <summary>
/// Rank battle family — covers rotation/unlimited human PvP + AI variants. Crossover
/// is out of scope (no AI variant; human-only). Multi-prefix URLs (rotation_rank_battle/,
/// unlimited_rank_battle/, ai_*_rank_battle/, rank_battle/) require explicit absolute
/// route attributes on each action; the controller doesn't extend SVSimController's
/// [Route("[controller]")] convention.
/// </summary>
[ApiController]
[Authorize(AuthenticationSchemes = SteamAuthenticationConstants.SchemeName)]
public sealed class RankBattleController : ControllerBase
{
    private readonly IMatchingPairUpService _pairUp;
    private readonly IMatchingBridge _bridge;
    private readonly IMatchContextBuilder _ctxBuilder;
    private readonly IBotRoster _botRoster;
    private readonly ILogger<RankBattleController> _log;

    public RankBattleController(
        IMatchingPairUpService pairUp,
        IMatchingBridge bridge,
        IMatchContextBuilder ctxBuilder,
        IBotRoster botRoster,
        ILogger<RankBattleController> log)
    {
        _pairUp = pairUp;
        _bridge = bridge;
        _ctxBuilder = ctxBuilder;
        _botRoster = botRoster;
        _log = log;
    }

    private bool TryGetViewerId(out long viewerId)
    {
        viewerId = 0;
        var claim = User.Claims.FirstOrDefault(c => c.Type == ShadowverseClaimTypes.ViewerIdClaim)?.Value;
        return claim is not null && long.TryParse(claim, out viewerId);
    }

    [HttpPost("/rotation_rank_battle/do_matching")]
    public Task<IActionResult> DoMatchingRotation([FromBody] DoMatchingRequestDto req, CancellationToken ct)
        => DoMatchingInternal("rotation_rank_battle", Format.Rotation, req, ct);

    [HttpPost("/unlimited_rank_battle/do_matching")]
    public Task<IActionResult> DoMatchingUnlimited([FromBody] DoMatchingRequestDto req, CancellationToken ct)
        => DoMatchingInternal("unlimited_rank_battle", Format.Unlimited, req, ct);

    [HttpPost("/ai_rotation_rank_battle/start")]
    public Task<IActionResult> AiStartRotation(CancellationToken ct)
        => AiStartInternal(Format.Rotation, ct);

    [HttpPost("/ai_unlimited_rank_battle/start")]
    public Task<IActionResult> AiStartUnlimited(CancellationToken ct)
        => AiStartInternal(Format.Unlimited, ct);

    /// <summary>
    /// Shared finish handler — RankBattleFinishTask parses the same wire shape for
    /// all four URLs and routes server-side by URL (vs IsAINetwork flag in the client).
    /// Stubbed for Phase 3: echo battle_result, emit zeros elsewhere. Real rank
    /// progression math is a separate spec.
    /// </summary>
    [HttpPost("/rotation_rank_battle/finish")]
    [HttpPost("/unlimited_rank_battle/finish")]
    [HttpPost("/ai_rotation_rank_battle/finish")]
    [HttpPost("/ai_unlimited_rank_battle/finish")]
    public IActionResult Finish([FromBody] RankBattleFinishRequestDto req)
    {
        if (!TryGetViewerId(out var _)) return Unauthorized();
        return Ok(new RankBattleFinishResponseDto
        {
            BattleResult = req.BattleResult,
            // All other fields default to 0 in the DTO (ClassLevel defaults to 1).
        });
    }

    [HttpPost("/rank_battle/force_finish")]
    public IActionResult ForceFinish()
    {
        if (!TryGetViewerId(out var _)) return Unauthorized();
        return Ok(new { });
    }

    [HttpPost("/rank_battle/add_client_log")]
    [HttpPost("/rank_battle/add_all_client_log")]
    [HttpPost("/rank_battle/add_last_turn_log")]
    public IActionResult AddClientLog()
    {
        if (!TryGetViewerId(out var _)) return Unauthorized();
        return Ok(new { });
    }

    [HttpPost("/rank_battle/get_latest_master_point")]
    public IActionResult GetLatestMasterPoint()
    {
        if (!TryGetViewerId(out var _)) return Unauthorized();
        return Ok(new { });
    }

    private async Task<IActionResult> DoMatchingInternal(string mode, Format format, DoMatchingRequestDto req, CancellationToken ct)
    {
        if (!TryGetViewerId(out var vid)) return Unauthorized();

        MatchContext ctx;
        try
        {
            ctx = await _ctxBuilder.BuildForRankBattleAsync(vid, format);
        }
        catch (InvalidOperationException ex)
        {
            // Most likely cause: viewer has no deck for this format. Surface as 3001
            // RC_BATTLE_MATCHING_ILLEGAL — the client shows the standard matchmaking-error
            // dialog rather than retrying forever.
            _log.LogWarning(ex, "BuildForRankBattleAsync failed for viewer {Vid} format {Fmt}; returning 3001.", vid, format);
            return Ok(new DoMatchingResponseDto { MatchingState = 3001, NodeServerUrl = "" });
        }

        var paired = await _pairUp.TryPairAsync(mode, new BattlePlayer(vid, ctx), ct);

        if (paired is null)
        {
            // Parked. 3002 RETRY. node_server_url must be present as empty string —
            // client's DoMatchingBase parser calls .ToString() without a guard.
            return Ok(new DoMatchingResponseDto
            {
                MatchingState = 3002,
                NodeServerUrl = "",
            });
        }

        // Owner cache-pickup → 3007 (PvP) or 3011 (AI fallback).
        // Joiner (only PvP) → 3004.
        var state = paired switch
        {
            { IsAiFallback: true } => 3011,
            { IsOwner: true } => 3007,
            _ => 3004,
        };

        return Ok(new DoMatchingResponseDto
        {
            MatchingState = state,
            BattleId = paired.Match.BattleId,
            NodeServerUrl = paired.Match.NodeServerUrl,
            // Placeholder per spec § Out of scope — per-battle card-master split is deferred.
            CardMasterId = 0,
        });
    }

    // Filled in by Task 10.
    private Task<IActionResult> AiStartInternal(Format format, CancellationToken ct)
    {
        if (!TryGetViewerId(out var _)) return Task.FromResult<IActionResult>(Unauthorized());
        // Placeholder; real impl arrives in Task 10.
        return Task.FromResult<IActionResult>(Ok(new AiBattleStartResponseDto { AiId = -1 }));
    }
}