ClawdDotNet/tests/ClawdDotNet.Core.Tests/Tasks/TaskScheduleTests.cs

using ClawdDotNet.Core.Tasks;
using Shouldly;

namespace ClawdDotNet.Core.Tests.Tasks;

/// <summary>
/// Die Terminberechnung — Antwort auf B6 (keine Delays, nur „was ist jetzt fällig")
/// und B7 (jeder Termin wird explizit in seiner Zeitzone gedeutet). Reine Funktion,
/// deshalb ohne DB und ohne Uhr-Attrappe: „jetzt" wird direkt übergeben.
/// </summary>
public sealed class TaskScheduleTests
{
    private static DateTime Utc(int y, int mo, int d, int h, int mi)
        => new(y, mo, d, h, mi, 0, DateTimeKind.Utc);

    // ─── #597: ungültiger Cron-Ausdruck ───

    [Fact]
    public void Ungueltiger_Cron_Ausdruck_wird_benannt_statt_verschwiegen()
    {
        var task = new TaskItem
        {
            Id = "t-1", CreatedAt = Utc(2026, 9, 14, 6, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 7-22/x * * *", TimeZone = "Europe/Berlin" }
        };

        TaskSchedule.DueOccurrence(task, Utc(2026, 9, 14, 11, 0)).ShouldBeNull();
        TaskSchedule.InvalidCron(task).ShouldNotBeNull().ShouldContain("'x' ist keine Zahl");
    }

    [Fact]
    public void Nachrichten_Digest_aus_dem_Testbetrieb_ist_um_13_Uhr_faellig()
    {
        var task = new TaskItem
        {
            Id = "t-7e0bbe", CreatedAt = Utc(2026, 9, 14, 10, 30),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 7-22/3 * * *", TimeZone = "Europe/Berlin" }
        };

        TaskSchedule.InvalidCron(task).ShouldBeNull();
        // 13:00 Berlin (MESZ) = 11:00 UTC
        TaskSchedule.DueOccurrence(task, Utc(2026, 9, 14, 11, 0)).ShouldBe("2026-09-14T11:00:00.0000000Z");
    }

    [Fact]
    public void Andere_Terminarten_haben_keinen_Cron_Fehler()
        => TaskSchedule.InvalidCron(new TaskItem
        {
            Id = "t-1", When = new TaskWhen { Kind = TaskWhenKind.Every, Value = "kaputt" }
        }).ShouldBeNull();

    // ─── Einmalig, ohne Termin ───

    [Fact]
    public void Ohne_Termin_ist_die_Aufgabe_faellig_bis_sie_lief()
    {
        var task = new TaskItem { Id = "t-1", CreatedAt = Utc(2026, 7, 31, 6, 0) };

        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 7, 0)).ShouldNotBeNull();
        TaskSchedule.DueOccurrence(task with { LastOccurrence = "x" }, Utc(2026, 7, 31, 7, 0)).ShouldBeNull();
    }

    // ─── at: einmaliger Zeitpunkt ───

    [Fact]
    public void Ein_at_Termin_ist_erst_ab_dem_Zeitpunkt_faellig()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            When = new TaskWhen { Kind = TaskWhenKind.At, Value = "2026-07-31T09:00:00", TimeZone = "Europe/Berlin" }
        };

        // 09:00 Berlin (Sommerzeit) = 07:00 UTC
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 6, 59)).ShouldBeNull();
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 7, 0)).ShouldNotBeNull();
    }

    [Fact]
    public void Ein_at_Termin_feuert_genau_einmal()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            LastOccurrence = "2026-07-31T07:00:00.0000000Z",
            When = new TaskWhen { Kind = TaskWhenKind.At, Value = "2026-07-31T09:00:00", TimeZone = "Europe/Berlin" }
        };

        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 12, 0)).ShouldBeNull();
    }

    [Fact]
    public void Ein_at_Termin_mit_Z_wird_als_UTC_gedeutet()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            When = new TaskWhen { Kind = TaskWhenKind.At, Value = "2026-07-31T09:00:00Z", TimeZone = "Europe/Berlin" }
        };

        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 8, 59)).ShouldBeNull();
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 9, 0)).ShouldNotBeNull();
    }

    // ─── every: Intervall ───

    [Fact]
    public void Ein_Intervall_wird_erst_nach_Ablauf_faellig()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 7, 31, 7, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Every, Value = "30m", TimeZone = "UTC" }
        };

        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 7, 20)).ShouldBeNull();
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 7, 30)).ShouldNotBeNull();
    }

    [Fact]
    public void Nach_dem_Marker_zaehlt_das_Intervall_neu()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            LastOccurrence = "2026-07-31T07:30:00.0000000Z",
            When = new TaskWhen { Kind = TaskWhenKind.Every, Value = "30m", TimeZone = "UTC" }
        };

        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 7, 55)).ShouldBeNull();
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 8, 0)).ShouldNotBeNull();
    }

    // ─── cron: mit Zeitzone (der Kern von B7) ───

    [Fact]
    public void Ein_Cron_Termin_wird_in_seiner_Zeitzone_gedeutet_Sommer()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 7, 31, 0, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = "Europe/Berlin" }
        };

        // 09:00 Berlin im Sommer (CEST, UTC+2) = 07:00 UTC
        var occ = TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 7, 5));
        occ.ShouldBe("2026-07-31T07:00:00.0000000Z");
    }

    [Fact]
    public void Derselbe_Cron_liegt_im_Winter_auf_einer_anderen_UTC_Stunde()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 1, 15, 0, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = "Europe/Berlin" }
        };

        // 09:00 Berlin im Winter (CET, UTC+1) = 08:00 UTC — genau das, was B7 verlangt.
        var occ = TaskSchedule.DueOccurrence(task, Utc(2026, 1, 15, 8, 5));
        occ.ShouldBe("2026-01-15T08:00:00.0000000Z");
    }

    [Fact]
    public void Vor_der_geplanten_Zeit_ist_der_Cron_nicht_faellig()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 7, 31, 5, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = "Europe/Berlin" }
        };

        // 06:00 UTC = 08:00 Berlin, vor der 09:00-Marke
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 6, 0)).ShouldBeNull();
    }

    [Fact]
    public void Eine_frische_Cron_Aufgabe_holt_keinen_Termin_von_vor_ihrer_Anlage_nach()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 7, 31, 8, 0), // nach der heutigen 09:00-Berlin-Marke (07:00 UTC)
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = "Europe/Berlin" }
        };

        // Jetzt 10:00 UTC — die heutige 09:00-Marke lag vor der Anlage, also nicht nachholen.
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 10, 0)).ShouldBeNull();
    }

    [Fact]
    public void Derselbe_Cron_Termin_feuert_nicht_zweimal()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            LastOccurrence = "2026-07-31T07:00:00.0000000Z",
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = "Europe/Berlin" }
        };

        // Später am selben Tag: der 09:00-Termin ist schon abgehakt.
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 10, 0)).ShouldBeNull();

        // Der nächste Tag ist wieder fällig.
        TaskSchedule.DueOccurrence(task, Utc(2026, 8, 1, 7, 5)).ShouldBe("2026-08-01T07:00:00.0000000Z");
    }

    [Fact]
    public void Ein_kaputter_Cron_Ausdruck_kippt_den_Scanner_nicht()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "kein cron", TimeZone = "UTC" }
        };

        Should.NotThrow(() => TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 9, 0)))
            .ShouldBeNull();
    }

    /// <summary>
    /// Früher fiel eine unbekannte Zone still auf UTC zurück. Das ist der schlechtere
    /// Fehler: Ein Task für 09:00 Ortszeit lief im Sommer um 07:00, ohne dass irgendwo
    /// etwas auffiel. Jetzt feuert er gar nicht — und der Scanner meldet einmal, warum.
    /// </summary>
    [Fact]
    public void Eine_unbekannte_Zeitzone_laesst_den_Termin_nicht_faellig_werden()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 7, 31, 0, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = "Phantasie/Ort" }
        };

        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 9, 5)).ShouldBeNull();
        TaskSchedule.UnresolvableTimeZone(task).ShouldBe("Phantasie/Ort");
    }

    /// <summary>
    /// Der Kern der Portierung: Dieselbe Zeitzone, zwei Schreibweisen. Eine Task-Datei,
    /// die unter Windows entstanden ist, muss unter Linux dieselbe Feuerzeit ergeben —
    /// und umgekehrt.
    /// </summary>
    [Theory]
    [InlineData("Europe/Berlin")]
    [InlineData("W. Europe Standard Time")]
    public void Beide_Schreibweisen_derselben_Zone_ergeben_dieselbe_Feuerzeit(string tz)
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 7, 31, 0, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = tz }
        };

        TaskSchedule.UnresolvableTimeZone(task).ShouldBeNull();

        // 09:00 Ortszeit im Sommer (MESZ, UTC+2) = 07:00 UTC.
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 9, 5))
            .ShouldBe("2026-07-31T07:00:00.0000000Z");
    }

    [Fact]
    public void Keine_Zeitzonenangabe_bedeutet_weiterhin_UTC()
    {
        var task = new TaskItem
        {
            Id = "t-1",
            CreatedAt = Utc(2026, 7, 31, 0, 0),
            When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 9 * * *", TimeZone = "" }
        };

        TaskSchedule.UnresolvableTimeZone(task).ShouldBeNull();
        TaskSchedule.DueOccurrence(task, Utc(2026, 7, 31, 9, 5))
            .ShouldBe("2026-07-31T09:00:00.0000000Z");
    }

    // ═══════════════════════════════════════════════════════════
    //  Zeitumstellung — R4 und R5 der Teststrategie
    //
    //  Europe/Berlin 2026: Am 29. März springt die Uhr um 02:00 auf 03:00, am
    //  25. Oktober um 03:00 zurück auf 02:00. Ein täglicher Termin um 02:00 trifft
    //  also einmal im Jahr eine Uhrzeit, die es nicht gibt, und einmal eine, die es
    //  doppelt gibt.
    // ═══════════════════════════════════════════════════════════

    private static TaskItem TaeglichUmZwei(DateTime angelegt) => new()
    {
        Id = "t-dst",
        CreatedAt = angelegt,
        When = new TaskWhen { Kind = TaskWhenKind.Cron, Value = "0 2 * * *", TimeZone = "Europe/Berlin" }
    };

    /// <summary>R5 — der Fall, um den es in #235 geht.</summary>
    [Fact]
    public void Zeitumstellung_Maerz_wird_nicht_uebersprungen()
    {
        var task = TaeglichUmZwei(Utc(2026, 3, 28, 0, 0));

        // "02:00" existiert am 29. März nicht. Der Termin fällt trotzdem an, und zwar
        // auf dem ersten Zeitpunkt danach: 03:00 MESZ = 01:00 UTC.
        // Vorher kam hier null — die Aufgabe fiel an diesem Tag ersatzlos aus.
        TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 2, 0))
            .ShouldBe("2026-03-29T01:00:00.0000000Z");
    }

    [Fact]
    public void Der_verschobene_Termin_feuert_trotzdem_nur_einmal()
    {
        var task = TaeglichUmZwei(Utc(2026, 3, 28, 0, 0));

        var ersteFaelligkeit = TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 2, 0));
        ersteFaelligkeit.ShouldNotBeNull();

        TaskSchedule.DueOccurrence(task with { LastOccurrence = ersteFaelligkeit }, Utc(2026, 3, 29, 2, 30))
            .ShouldBeNull();
    }

    /// <summary>R4 — die andere Richtung.</summary>
    [Fact]
    public void Zeitumstellung_Oktober_feuert_genau_einmal()
    {
        var task = TaeglichUmZwei(Utc(2026, 10, 24, 0, 0));

        // 02:00 kommt am 25. Oktober zweimal vor: in Sommerzeit (00:00 UTC) und in
        // Normalzeit (01:00 UTC). Beide Durchläufe ergeben denselben Occurrence-Key —
        // der Marker fängt den zweiten ab.
        var ersterDurchlauf = TaskSchedule.DueOccurrence(task, Utc(2026, 10, 25, 0, 30));
        ersterDurchlauf.ShouldNotBeNull();

        var zweiterDurchlauf = TaskSchedule.DueOccurrence(
            task with { LastOccurrence = ersterDurchlauf }, Utc(2026, 10, 25, 1, 30));
        zweiterDurchlauf.ShouldBeNull();
    }

    [Fact]
    public void An_gewoehnlichen_Tagen_bleibt_es_bei_zwei_Uhr_Ortszeit()
    {
        // Die Gegenprobe: Die Verschiebung darf nur in der Lücke greifen.
        var task = TaeglichUmZwei(Utc(2026, 3, 21, 0, 0));

        // 02:00 MEZ = 01:00 UTC.
        TaskSchedule.DueOccurrence(task, Utc(2026, 3, 22, 2, 0))
            .ShouldBe("2026-03-22T01:00:00.0000000Z");
    }

    [Fact]
    public void Auch_ein_einmaliger_Termin_in_der_Luecke_faellt_nicht_aus()
    {
        // Derselbe Umgang auf dem at-Pfad — dort galt dieselbe Regel und dieselbe Lücke.
        var task = new TaskItem
        {
            Id = "t-1",
            When = new TaskWhen
            {
                Kind = TaskWhenKind.At,
                Value = "2026-03-29T02:30:00",
                TimeZone = "Europe/Berlin"
            }
        };

        // 02:30 gibt es nicht; es wird 03:00 MESZ = 01:00 UTC.
        TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 0, 59)).ShouldBeNull();
        TaskSchedule.DueOccurrence(task, Utc(2026, 3, 29, 1, 0))
            .ShouldBe("2026-03-29T01:00:00.0000000Z");
    }
}