using MeterVault.Core.Analysis;
using MeterVault.Core.Analysis.Coverage;
using static MeterVault.Core.Tests.Analysis.AnalysisTestTime;

namespace MeterVault.Core.Tests.Analysis;

/// <summary>
/// The resolution classes of D-13, at their exact limits: an hour and a minute, 25 hours, seven days and
/// an hour, 31 days and two hours. The slack is what keeps real intervals — a late poll, a DST day, a
/// month with a DST hour — in the class they belong to. There is one classifier (A-09); the bucket side of
/// the same scale — which class a bucket size needs — is pinned here too.
/// </summary>
public sealed class ResolutionClassifierTests
{
    public static TheoryData<TimeSpan, ResolutionClass> Limits => new()
    {
        { TimeSpan.Zero, ResolutionClass.Hour },
        { TimeSpan.FromMinutes(5), ResolutionClass.Hour },
        { TimeSpan.FromMinutes(60), ResolutionClass.Hour },
        { TimeSpan.FromMinutes(61), ResolutionClass.Hour },
        { TimeSpan.FromMinutes(61) + TimeSpan.FromTicks(1), ResolutionClass.Day },
        { TimeSpan.FromHours(23), ResolutionClass.Day },
        { TimeSpan.FromHours(25), ResolutionClass.Day },
        { TimeSpan.FromHours(25) + TimeSpan.FromSeconds(1), ResolutionClass.Week },
        { TimeSpan.FromDays(7) + TimeSpan.FromHours(1), ResolutionClass.Week },
        { TimeSpan.FromDays(7) + TimeSpan.FromHours(1) + TimeSpan.FromSeconds(1), ResolutionClass.Month },
        { TimeSpan.FromDays(31) + TimeSpan.FromHours(1), ResolutionClass.Month },
        { TimeSpan.FromDays(31) + TimeSpan.FromHours(2), ResolutionClass.Month },
        { TimeSpan.FromDays(31) + TimeSpan.FromHours(2) + TimeSpan.FromSeconds(1), ResolutionClass.Coarse },
        { TimeSpan.FromDays(365 * 12), ResolutionClass.Coarse },
    };

    [Theory]
    [MemberData(nameof(Limits))]
    public void An_interval_is_classified_by_its_length_up_to_each_limit_inclusive(TimeSpan length, ResolutionClass expected)
    {
        Assert.Equal(expected, ResolutionClassifier.Classify(length));
    }

    [Fact]
    public void A_negative_length_claims_no_time_and_is_the_finest_class()
    {
        Assert.Equal(ResolutionClass.Hour, ResolutionClassifier.Classify(TimeSpan.FromHours(-3)));
    }

    [Fact]
    public void The_long_autumn_day_is_still_a_day_and_october_with_its_extra_hour_still_a_month()
    {
        Assert.Equal(TimeSpan.FromHours(25), InBerlin(2026, 10, 26) - InBerlin(2026, 10, 25));
        Assert.Equal(ResolutionClass.Day, ResolutionClassifier.Classify(InBerlin(2026, 10, 25), InBerlin(2026, 10, 26)));
        Assert.Equal(ResolutionClass.Month, ResolutionClassifier.Classify(InBerlin(2026, 10, 1), InBerlin(2026, 11, 1)));
        Assert.Equal(ResolutionClass.Month, ResolutionClassifier.Classify(InBerlin(2027, 2, 1), InBerlin(2027, 3, 1)));
    }

    [Fact]
    public void A_week_read_an_hour_late_is_still_a_week_but_two_weeks_are_not()
    {
        Assert.Equal(ResolutionClass.Week, ResolutionClassifier.Classify(InBerlin(2026, 9, 7, 10), InBerlin(2026, 9, 14, 11)));
        Assert.Equal(ResolutionClass.Month, ResolutionClassifier.Classify(InBerlin(2026, 9, 7, 10), InBerlin(2026, 9, 21, 10)));
    }

    [Theory]
    [InlineData(ResolutionClass.Hour, 61)]
    [InlineData(ResolutionClass.Day, 25 * 60)]
    [InlineData(ResolutionClass.Week, (7 * 24 * 60) + 60)]
    [InlineData(ResolutionClass.Month, (31 * 24 * 60) + 120)]
    public void Each_class_admits_intervals_up_to_its_own_limit(ResolutionClass resolution, int minutes)
    {
        Assert.Equal(TimeSpan.FromMinutes(minutes), ResolutionClassifier.LimitOf(resolution));
        Assert.Equal(resolution, ResolutionClassifier.Classify(ResolutionClassifier.LimitOf(resolution)));
    }

    [Fact]
    public void Data_coarser_than_a_month_has_no_limit()
    {
        Assert.Equal(TimeSpan.MaxValue, ResolutionClassifier.LimitOf(ResolutionClass.Coarse));
    }

    [Theory]
    [InlineData(BucketSize.Day, ResolutionClass.Day)]
    [InlineData(BucketSize.Week, ResolutionClass.Week)]
    [InlineData(BucketSize.Month, ResolutionClass.Month)]
    [InlineData(BucketSize.Year, ResolutionClass.Month)]
    public void A_bucket_size_names_the_coarsest_class_that_resolves_it_outright(BucketSize size, ResolutionClass expected)
    {
        Assert.Equal(expected, ResolutionClassifier.CoarsestResolving(size));
    }

    [Fact]
    public void Auto_has_no_class_because_it_is_resolved_before_any_bucket_exists()
    {
        Assert.Throws<ArgumentOutOfRangeException>(() => ResolutionClassifier.CoarsestResolving(BucketSize.Auto));
    }

    [Fact]
    public void The_coarsest_of_two_classes_is_the_resolution_of_a_combined_value()
    {
        Assert.Equal(ResolutionClass.Month, ResolutionClassifier.Coarsest(ResolutionClass.Hour, ResolutionClass.Month));
        Assert.Equal(ResolutionClass.Coarse, ResolutionClassifier.Coarsest(ResolutionClass.Coarse, ResolutionClass.Day));
    }
}