using System.Text.Json;

using MultiversalDiplomacy.Adjudicate;
using MultiversalDiplomacy.Model;

using NUnit.Framework;

namespace MultiversalDiplomacyTests;

public class SerializationTest
{
    private JsonSerializerOptions Options = new(World.JsonOptions) {
        WriteIndented = true,
    };

    [Test]
    public void SerializeRoundTrip_NewGame()
    {
        World world = World.WithStandardMap();
        string serialized = JsonSerializer.Serialize(world, Options);
        World? deserialized = JsonSerializer.Deserialize<World>(serialized, Options);

        Assert.That(deserialized, Is.Not.Null, "Failed to deserialize");
        Assert.That(deserialized!.Map, Is.Not.Null, "Failed to deserialize map");
        Assert.That(deserialized!.Seasons, Is.Not.Null, "Failed to deserialize seasons");
        Assert.That(deserialized!.Units, Is.Not.Null, "Failed to deserialize units");
        Assert.That(deserialized!.RetreatingUnits, Is.Not.Null, "Failed to deserialize retreats");
        Assert.That(deserialized!.OrderHistory, Is.Not.Null, "Failed to deserialize history");
        Assert.That(deserialized!.Timelines, Is.Not.Null, "Failed to deserialize timelines");
        Assert.That(deserialized!.Options, Is.Not.Null, "Failed to deserialize options");
        Assert.That(deserialized.Timelines.nextTimeline, Is.EqualTo(world.Timelines.nextTimeline));

        JsonElement document = JsonSerializer.SerializeToDocument(world, Options).RootElement;
        Assert.That(
            document.EnumerateObject().Select(prop => prop.Name),
            Is.EquivalentTo(new List<string> {
                "mapType",
                "seasons",
                "units",
                "retreatingUnits",
                "orderHistory",
                "options",
                "timelines",
            }));
    }

    [Test]
    public void SerializeRoundTrip_MDATC_3_A_2()
    {
        // Set up MDATC 3.A.2
        TestCaseBuilder setup = new(World.WithStandardMap(), MovementPhaseAdjudicator.Instance);
        setup[("a", 0)]
            .GetReference(out Season s0)
            ["Germany"]
                .Army("Mun").MovesTo("Tyr").GetReference(out var mun0)
            ["Austria"]
                .Army("Tyr").Holds().GetReference(out var tyr0);

        setup.ValidateOrders();
        Assert.That(mun0, Is.Valid);
        Assert.That(tyr0, Is.Valid);
        setup.AdjudicateOrders();
        Assert.That(mun0, Is.Repelled);
        Assert.That(tyr0, Is.NotDislodged);
        setup.UpdateWorld();

        // Serialize the world
        string serialized = JsonSerializer.Serialize(setup.World, Options);

        // Deserialize the world
        Console.WriteLine(serialized);
        World reserialized = JsonSerializer.Deserialize<World>(serialized, Options)
            ?? throw new AssertionException("Failed to reserialize world");

        // Resume the test case
        setup = new(reserialized, MovementPhaseAdjudicator.Instance);
        setup[("a", 1)]
            ["Germany"]
                .Army("Mun").Supports.Army("Mun", season: reserialized.GetSeason("a0")).MoveTo("Tyr").GetReference(out var mun1)
            ["Austria"]
                .Army("Tyr").Holds();

        setup.ValidateOrders();
        Assert.That(mun1, Is.Valid);
        setup.AdjudicateOrders();
        Assert.That(mun1, Is.NotCut);
        Assert.That(mun0, Is.Victorious);
        Assert.That(tyr0, Is.Dislodged);

        // Confirm that an alternate future is created.
        World world = setup.UpdateWorld();
        Season fork = world.GetSeason("b1");
        Unit tyr1 = world.GetUnitAt("Tyr", fork);
        Assert.That(
            tyr1.Past,
            Is.EqualTo(mun0.Order.Unit.Designation),
            "Expected A Mun a0 to advance to Tyr b1");
        Assert.That(
            world.RetreatingUnits.Count,
            Is.EqualTo(1),
            "Expected A Tyr a0 to be in retreat");
        Assert.That(world.RetreatingUnits.First().Unit, Is.EqualTo(tyr0.Order.Unit));
    }
}