using TheLivingWorld.Core.Simulation;

namespace TheLivingWorld.Tests;

public sealed class GameTimeTests
{
    [Fact]
    public void Advance_at_x1_adds_five_game_minutes_per_real_second()
    {
        var start = GameTime.DefaultStart;
        var next = GameTime.Advance(start, TimeSpan.FromSeconds(1), timeScale: 1, paused: false);

        Assert.Equal(start.AddMinutes(5), next);
    }

    [Fact]
    public void Advance_scales_with_time_scale()
    {
        var start = GameTime.DefaultStart;

        Assert.Equal(start.AddMinutes(10), GameTime.Advance(start, TimeSpan.FromSeconds(1), 2, false));
        Assert.Equal(start.AddMinutes(20), GameTime.Advance(start, TimeSpan.FromSeconds(1), 4, false));
    }

    [Fact]
    public void Advance_does_nothing_when_paused_or_non_positive()
    {
        var start = GameTime.DefaultStart;

        Assert.Equal(start, GameTime.Advance(start, TimeSpan.FromSeconds(10), 4, paused: true));
        Assert.Equal(start, GameTime.Advance(start, TimeSpan.Zero, 1, paused: false));
        Assert.Equal(start, GameTime.Advance(start, TimeSpan.FromSeconds(-1), 1, paused: false));
    }

    [Fact]
    public void Advance_handles_a_large_wall_clock_gap()
    {
        var start = GameTime.DefaultStart;
        // One real hour at x1 → 5 * 3600 = 18_000 game minutes = 12.5 game days.
        var next = GameTime.Advance(start, TimeSpan.FromHours(1), timeScale: 1, paused: false);

        Assert.Equal(start.AddMinutes(5 * 3600), next);
        Assert.Equal(new DateTime(2012, 4, 24, 18, 0, 0, DateTimeKind.Unspecified), next);
    }

    [Fact]
    public void DefaultStart_is_morning_of_12_April_2012()
    {
        Assert.Equal(new DateTime(2012, 4, 12, 6, 0, 0, DateTimeKind.Unspecified), GameTime.DefaultStart);
    }

    [Theory]
    [InlineData(1, true)]
    [InlineData(4, true)]
    [InlineData(0, false)]
    [InlineData(5, false)]
    public void IsValidTimeScale_accepts_1_through_4(int scale, bool expected)
    {
        Assert.Equal(expected, GameTime.IsValidTimeScale(scale));
    }

    [Fact]
    public void ResolveStart_defaults_and_normalises()
    {
        Assert.Equal(GameTime.DefaultStart, GameTime.ResolveStart(null));
        Assert.Equal(
            new DateTime(1999, 12, 31, 23, 45, 0, DateTimeKind.Unspecified),
            GameTime.ResolveStart(new DateTime(1999, 12, 31, 23, 45, 59, DateTimeKind.Utc)));
    }

    [Fact]
    public void ResolveStart_rejects_out_of_range_years()
    {
        // Year 10000 cannot even be constructed, so this has to sit just past the accepted range to
        // actually exercise ResolveStart.
        Assert.Throws<ArgumentOutOfRangeException>(() =>
            GameTime.ResolveStart(new DateTime(9999, 1, 1, 0, 0, 0, DateTimeKind.Unspecified)));
    }

    [Fact]
    public void Advance_saturates_instead_of_running_off_the_end_of_the_calendar()
    {
        var nearTheEnd = new DateTime(9998, 12, 31, 23, 0, 0, DateTimeKind.Unspecified);

        // A day of real time at x4 is roughly 16 game years - far past DateTime.MaxValue from here.
        var next = GameTime.Advance(nearTheEnd, TimeSpan.FromDays(1), timeScale: 4, paused: false);

        Assert.Equal(DateTime.MaxValue, next);
        // Already saturated: the next tick must stay put rather than throw.
        Assert.Equal(DateTime.MaxValue, GameTime.Advance(next, TimeSpan.FromSeconds(1), 1, paused: false));
    }

    [Fact]
    public void Advance_survives_an_absurd_wall_clock_gap()
    {
        // The naive product realElapsed.Ticks * 1200 overflows a long well before TimeSpan.MaxValue.
        var next = GameTime.Advance(GameTime.DefaultStart, TimeSpan.MaxValue, timeScale: 4, paused: false);

        Assert.Equal(DateTime.MaxValue, next);
    }
}