using Microsoft.AspNetCore.Mvc.Testing;
using Microsoft.Extensions.DependencyInjection;
using NUnit.Framework;
using SVSim.BattleNode.Bridge;
using SVSim.BattleNode.Protocol;
using SVSim.BattleNode.Wire;
using SVSim.EmulatedEntrypoint;
using SVSim.UnitTests.Infrastructure;

namespace SVSim.UnitTests.BattleNode.Integration;

[TestFixture]
public class BattleNodeFlowTests
{
    /// <summary>
    /// End-to-end smoke for the v1 scripted lifecycle. Boots the EmulatedEntrypoint via
    /// SVSimTestFactory, mints a battle through IMatchingBridge with a fixture MatchContext,
    /// opens a raw Socket.IO v2 client against the in-process TestServer, and drives
    /// InitNetwork → Loaded → Swap, asserting the right scripted frames come back in order.
    /// </summary>
    [Test]
    [Timeout(30000)]
    public async Task ClientWalksHandshakeToReady_ReceivesAllScriptedFrames()
    {
        await using var factory = new SVSimTestFactory();
        var bridge = factory.Services.GetRequiredService<IMatchingBridge>();

        using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(15));
        var ct = cts.Token;
        var pending = bridge.RegisterPendingBattle(viewerId: 906243102, context: FixtureCtx());

        var key = MakeKey();
        var encryptedVid = NodeCrypto.EncryptForNode("906243102", key);
        var wsUri = new Uri($"ws://localhost/socket.io/?BattleId={pending.BattleId}&viewerId={Uri.EscapeDataString(encryptedVid)}&EIO=3&transport=websocket");

        var wsClient = factory.Server.CreateWebSocketClient();
        var ws = await wsClient.ConnectAsync(wsUri, ct);
        await using var client = new RawSocketIoTestClient(ws);
        await client.ConsumeHandshakeAsync(ct);

        await client.SendMsgAsync(MakeEnvelope(NetworkBattleUri.InitNetwork, pubSeq: 1), key, ct);
        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.InitNetwork));

        await client.SendMsgAsync(MakeEnvelope(NetworkBattleUri.InitBattle, pubSeq: 2), key, ct);
        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.Matched));

        await client.SendMsgAsync(MakeEnvelope(NetworkBattleUri.Loaded, pubSeq: 3), key, ct);
        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.BattleStart));
        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.Deal));

        await client.SendMsgAsync(MakeEnvelope(NetworkBattleUri.Swap, pubSeq: 4,
            body: new Dictionary<string, object?> { ["idxList"] = new List<object?>() }), key, ct);
        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.Swap));
        Assert.That((await client.ReceiveSynchronizeAsync(ct)).Uri, Is.EqualTo(NetworkBattleUri.Ready));
    }

    private static MsgEnvelope MakeEnvelope(NetworkBattleUri uri, long pubSeq, Dictionary<string, object?>? body = null) =>
        new(uri, ViewerId: 906243102, Uuid: "udid-test", Bid: null, Try: 0,
            Cat: uri == NetworkBattleUri.InitNetwork ? EmitCategory.General
                 : uri == NetworkBattleUri.InitBattle ? EmitCategory.Matching
                 : EmitCategory.Battle,
            PubSeq: pubSeq, PlaySeq: null, Body: new RawBody(body ?? new Dictionary<string, object?>()));

    private static string MakeKey()
    {
        var seq = 0;
        return NodeCrypto.GenerateKey(() => (seq++ * 13) % 16);
    }

    internal static MatchContext FixtureCtx(IReadOnlyList<long>? deck = null) => new(
        SelfDeckCardIds: deck ?? Enumerable.Range(1, 30).Select(i => 100_011_010L).ToList(),
        ClassId: "1", CharaId: "1", CardMasterName: "card_master_node_10015",
        CountryCode: "KOR", UserName: "Player", SleeveId: "3000011",
        EmblemId: "701441011", DegreeId: "300003", FieldId: 43, IsOfficial: 0,
        BattleType: 11);
}