SVSimServer/SVSim.UnitTests/Controllers/RankBattleControllerTests.cs

using System.Net.Http.Json;
using System.Text.Json;
using Microsoft.Extensions.DependencyInjection;
using NUnit.Framework;
using SVSim.Database.Enums;
using SVSim.UnitTests.Infrastructure;

namespace SVSim.UnitTests.Controllers;

[TestFixture]
public class RankBattleControllerTests
{
    [Test]
    public async Task DoMatching_rotation_first_poll_returns_3002_RETRY_with_empty_node_server_url()
    {
        await using var factory = new SVSimTestFactory();
        var viewerId = await factory.SeedViewerAsync();
        await factory.SeedGlobalsAsync();
        await factory.SeedDeckAsync(viewerId, Format.Rotation, 1);
        var client = factory.CreateAuthenticatedClient(viewerId);

        var resp = await client.PostAsJsonAsync(
            "/rotation_rank_battle/do_matching",
            new { deck_no = 1, need_init = 1 });

        Assert.That(resp.IsSuccessStatusCode, Is.True, $"Expected 2xx, got {resp.StatusCode}");
        var raw = await resp.Content.ReadAsStringAsync();
        using var doc = JsonDocument.Parse(raw);
        var data = doc.RootElement;
        Assert.That(data.GetProperty("matching_state").GetInt32(), Is.EqualTo(3002));
        Assert.That(data.GetProperty("node_server_url").GetString(), Is.EqualTo(""),
            "Empty string, not absent — Phase 2 fix pattern.");
    }

    [Test]
    public async Task DoMatching_rotation_two_viewers_pair_PvP()
    {
        await using var factory = new SVSimTestFactory();
        var v1 = await factory.SeedViewerAsync(steamId: 76_561_198_000_000_001UL, displayName: "Alice");
        var v2 = await factory.SeedViewerAsync(steamId: 76_561_198_000_000_002UL, displayName: "Bob");
        await factory.SeedGlobalsAsync();
        await factory.SeedDeckAsync(v1, Format.Rotation, 1);
        await factory.SeedDeckAsync(v2, Format.Rotation, 1);

        // Alice polls first → parks.
        var c1 = factory.CreateAuthenticatedClient(v1);
        var r1 = await c1.PostAsJsonAsync(
            "/rotation_rank_battle/do_matching", new { deck_no = 1, need_init = 1 });
        var j1 = JsonDocument.Parse(await r1.Content.ReadAsStringAsync()).RootElement;
        Assert.That(j1.GetProperty("matching_state").GetInt32(), Is.EqualTo(3002));

        // Bob polls — pairs, returns joiner (3004).
        var c2 = factory.CreateAuthenticatedClient(v2);
        var r2 = await c2.PostAsJsonAsync(
            "/rotation_rank_battle/do_matching", new { deck_no = 1, need_init = 1 });
        var j2 = JsonDocument.Parse(await r2.Content.ReadAsStringAsync()).RootElement;
        Assert.That(j2.GetProperty("matching_state").GetInt32(), Is.EqualTo(3004), "Joiner = 3004.");
        Assert.That(j2.GetProperty("battle_id").GetString(), Is.Not.Null.And.Not.Empty);
        Assert.That(j2.GetProperty("node_server_url").GetString(), Is.Not.Empty);

        // Alice polls again — gets cached match, owner role (3007).
        var r3 = await c1.PostAsJsonAsync(
            "/rotation_rank_battle/do_matching", new { deck_no = 1, need_init = 0 });
        var j3 = JsonDocument.Parse(await r3.Content.ReadAsStringAsync()).RootElement;
        Assert.That(j3.GetProperty("matching_state").GetInt32(), Is.EqualTo(3007), "Owner = 3007.");
        Assert.That(j3.GetProperty("battle_id").GetString(), Is.EqualTo(j2.GetProperty("battle_id").GetString()));
    }

    [Test]
    public async Task AiStart_rotation_returns_ai_id_plus_self_oppo_info_camelCase_keys()
    {
        await using var factory = new SVSimTestFactory();
        var viewerId = await factory.SeedViewerAsync(displayName: "TestViewer");
        await factory.SeedGlobalsAsync();
        await factory.SeedDeckAsync(viewerId, Format.Rotation, 1);
        var client = factory.CreateAuthenticatedClient(viewerId);

        var resp = await client.PostAsJsonAsync("/ai_rotation_rank_battle/start", new { });
        var raw = await resp.Content.ReadAsStringAsync();

        using var doc = JsonDocument.Parse(raw);
        var data = doc.RootElement;
        Assert.That(data.GetProperty("ai_id").GetInt32(), Is.InRange(4001, 4008));
        Assert.That(data.GetProperty("turnState").GetInt32(), Is.EqualTo(0));

        // Literal camelCase wire-key checks — these MUST be present verbatim
        // (client uses JsonData.Keys.Contains).
        Assert.That(raw, Does.Contain("\"userName\""), "Wire key must be camelCase, not snake_case.");
        Assert.That(raw, Does.Contain("\"sleeveId\""));
        Assert.That(raw, Does.Contain("\"emblemId\""));
        Assert.That(raw, Does.Contain("\"degreeId\""));
        Assert.That(raw, Does.Contain("\"fieldId\""));
        Assert.That(raw, Does.Contain("\"isOfficial\""));
        Assert.That(raw, Does.Contain("\"classId\""));
        Assert.That(raw, Does.Contain("\"charaId\""));
        Assert.That(raw, Does.Contain("\"isMasterRank\""));
        Assert.That(raw, Does.Contain("\"battlePoint\""));
        Assert.That(raw, Does.Contain("\"masterPoint\""));
        // self_info / oppo_info / country_code stay snake_case (the outliers per ai-start.md).
        Assert.That(raw, Does.Contain("\"self_info\""));
        Assert.That(raw, Does.Contain("\"oppo_info\""));
        Assert.That(raw, Does.Contain("\"country_code\""));
    }

    [Test]
    public async Task AiStart_self_info_reflects_caller_user_name()
    {
        await using var factory = new SVSimTestFactory();
        var viewerId = await factory.SeedViewerAsync(displayName: "Alice");
        await factory.SeedGlobalsAsync();
        await factory.SeedDeckAsync(viewerId, Format.Rotation, 1);
        var client = factory.CreateAuthenticatedClient(viewerId);

        var resp = await client.PostAsJsonAsync("/ai_rotation_rank_battle/start", new { });
        using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
        var selfInfo = doc.RootElement.GetProperty("self_info");

        Assert.That(selfInfo.GetProperty("userName").GetString(), Is.EqualTo("Alice"));
    }

    [Test]
    public async Task AiStart_oppo_info_reflects_roster_pick()
    {
        await using var factory = new SVSimTestFactory();
        var viewerId = await factory.SeedViewerAsync(displayName: "PlayerA");
        await factory.SeedGlobalsAsync();
        await factory.SeedDeckAsync(viewerId, Format.Rotation, 1);
        var client = factory.CreateAuthenticatedClient(viewerId);

        var resp = await client.PostAsJsonAsync("/ai_rotation_rank_battle/start", new { });
        using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
        var oppoInfo = doc.RootElement.GetProperty("oppo_info");

        // BotRoster's stub names contain "AI" — verify the roster was consulted.
        Assert.That(oppoInfo.GetProperty("userName").GetString(), Does.Contain("AI"));
        Assert.That(oppoInfo.GetProperty("classId").GetInt32(), Is.InRange(1, 8));
    }

    [Test]
    public async Task Finish_emits_stubbed_zeros_with_battle_result_echo()
    {
        await using var factory = new SVSimTestFactory();
        var viewerId = await factory.SeedViewerAsync();
        var client = factory.CreateAuthenticatedClient(viewerId);

        var resp = await client.PostAsJsonAsync("/ai_rotation_rank_battle/finish", new
        {
            battle_result = 1, // win
            is_retire = 0,
            recovery_data = "{}",
            class_id = 3,
            total_turn = 5,
        });

        Assert.That(resp.IsSuccessStatusCode, Is.True);
        using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
        var data = doc.RootElement;
        Assert.That(data.GetProperty("battle_result").GetInt32(), Is.EqualTo(1));
        Assert.That(data.GetProperty("rank").GetInt32(), Is.EqualTo(0));
        Assert.That(data.GetProperty("after_battle_point").GetInt32(), Is.EqualTo(0));
        Assert.That(data.GetProperty("class_level").GetInt32(), Is.EqualTo(1));
    }

    [Test]
    public async Task Finish_with_consistency_result_echoes_2()
    {
        await using var factory = new SVSimTestFactory();
        var viewerId = await factory.SeedViewerAsync();
        var client = factory.CreateAuthenticatedClient(viewerId);

        var resp = await client.PostAsJsonAsync("/rotation_rank_battle/finish", new
        {
            battle_result = 2, // consistency error
            class_id = 3,
        });

        using var doc = JsonDocument.Parse(await resp.Content.ReadAsStringAsync());
        Assert.That(doc.RootElement.GetProperty("battle_result").GetInt32(), Is.EqualTo(2));
    }
}