using MultiversalDiplomacy.Model;

using NUnit.Framework;

namespace MultiversalDiplomacyTests;

public class TimelinesTest
{
    [TestCase(0, "a")]
    [TestCase(1, "b")]
    [TestCase(25, "z")]
    [TestCase(26, "aa")]
    [TestCase(27, "ab")]
    [TestCase(51, "az")]
    [TestCase(52, "ba")]
    [TestCase(53, "bb")]
    [TestCase(77, "bz")]
    [TestCase(78, "ca")]
    public void RoundTripTimelineKeys(int number, string designation)
    {
        Assert.That(Timelines.IntToString(number), Is.EqualTo(designation), "Incorrect string");
        Assert.That(Timelines.StringToInt(designation), Is.EqualTo(number), "Incorrect number");
    }

    [TestCase("a0", "a", 0)]
    [TestCase("a1", "a", 1)]
    [TestCase("a10", "a", 10)]
    [TestCase("aa2", "aa", 2)]
    [TestCase("aa22", "aa", 22)]
    public void SeasonKeySplit(string key, string timeline, int turn)
    {
        Assert.That(Timelines.SplitKey(key), Is.EqualTo((timeline, turn)), "Failed to split key");
    }

    [Test]
    public void NoSharedFactoryState()
    {
        Timelines one = Timelines.Create()
            .WithNewSeason(Season.First, out var s1)
            .WithNewSeason(Season.First, out var s2)
            .WithNewSeason(Season.First, out var s3);
        Timelines two = Timelines.Create()
            .WithNewSeason(Season.First, out var s4)
            .WithNewSeason(Season.First, out var s5);

        Assert.That(s1.Timeline, Is.EqualTo("a"));
        Assert.That(s2.Timeline, Is.EqualTo("b"));
        Assert.That(s3.Timeline, Is.EqualTo("c"));
        Assert.That(s4.Timeline, Is.EqualTo("a"), "Unexpected first timeline");
        Assert.That(s5.Timeline, Is.EqualTo("b"), "Unexpected second timeline");
    }

    [Test]
    public void TimelineForking()
    {
        Timelines timelines = Timelines.Create()
            .WithNewSeason(Season.First, out var a1)
            .WithNewSeason(a1, out var a2)
            .WithNewSeason(a2, out var a3)
            .WithNewSeason(a1, out var b2)
            .WithNewSeason(b2, out var b3)
            .WithNewSeason(a1, out var c2)
            .WithNewSeason(a2, out var d3);
        Season a0 = Season.First;

        Assert.That(
            timelines.Pasts.Keys,
            Is.EquivalentTo(new List<string> { "a0", "a1", "a2", "a3", "b2", "b3", "c2", "d3" }),
            "Unexpected seasons");

        Assert.That(a1.Timeline, Is.EqualTo("a"), "Unexpected trunk timeline");
        Assert.That(a2.Timeline, Is.EqualTo("a"), "Unexpected trunk timeline");
        Assert.That(a3.Timeline, Is.EqualTo("a"), "Unexpected trunk timeline");
        Assert.That(b2.Timeline, Is.EqualTo("b"), "Unexpected first alt");
        Assert.That(b3.Timeline, Is.EqualTo("b"), "Unexpected first alt");
        Assert.That(c2.Timeline, Is.EqualTo("c"), "Unexpected second alt");
        Assert.That(d3.Timeline, Is.EqualTo("d"), "Unexpected third alt");

        Assert.That(a1.Turn, Is.EqualTo(Season.First.Turn + 1), "Unexpected a1 turn number");
        Assert.That(a2.Turn, Is.EqualTo(Season.First.Turn + 2), "Unexpected a2 turn number");
        Assert.That(a3.Turn, Is.EqualTo(Season.First.Turn + 3), "Unexpected a3 turn number");
        Assert.That(b2.Turn, Is.EqualTo(Season.First.Turn + 2), "Unexpected b2 turn number");
        Assert.That(b3.Turn, Is.EqualTo(Season.First.Turn + 3), "Unexpected b3 turn number");
        Assert.That(c2.Turn, Is.EqualTo(Season.First.Turn + 2), "Unexpected c2 turn number");
        Assert.That(d3.Turn, Is.EqualTo(Season.First.Turn + 3), "Unexpected d3 turn number");

        Assert.That(timelines.GetTimelineRoot(a0), Is.EqualTo(a0), "Expected timeline root to be reflexive");
        Assert.That(timelines.GetTimelineRoot(a3), Is.EqualTo(a0), "Expected trunk timeline to have root");
        Assert.That(timelines.GetTimelineRoot(b2), Is.EqualTo(b2), "Expected alt timeline root to be reflexive");
        Assert.That(timelines.GetTimelineRoot(b3), Is.EqualTo(b2), "Expected alt timeline to root at first fork");
        Assert.That(timelines.GetTimelineRoot(c2), Is.EqualTo(c2), "Expected alt timeline root to be reflexive");
        Assert.That(timelines.GetTimelineRoot(d3), Is.EqualTo(d3), "Expected alt timeline root to be reflexive");

        Assert.That(timelines.InAdjacentTimeline(b3, a3), Is.True, "Expected alts to be adjacent to origin");
        Assert.That(timelines.InAdjacentTimeline(b3, c2), Is.True, "Expected alts with common origin to be adjacent");
        Assert.That(timelines.InAdjacentTimeline(b3, d3), Is.False, "Expected alts from different origins not to be adjacent");

        Assert.That(timelines.GetFutures(a0), Is.EquivalentTo(new List<Season> { a1 }), "Unexpected futures");
        Assert.That(timelines.GetFutures(a1), Is.EquivalentTo(new List<Season> { a2, b2, c2 }), "Unexpected futures");
        Assert.That(timelines.GetFutures(a2), Is.EquivalentTo(new List<Season> { a3, d3 }), "Unexpected futures");
        Assert.That(timelines.GetFutures(b2), Is.EquivalentTo(new List<Season> { b3 }), "Unexpected futures");
    }
}