using ClawdDotNet.Core.Storage;
using ClawdDotNet.Core.Tasks;
using Shouldly;

namespace ClawdDotNet.Core.Tests.Tasks;

/// <summary>
/// A1 Taskboard: der Ausführungszustand. Getestet gegen eine echte SQLite-Datei, weil es
/// gerade um Schema, Sperrverhalten und atomares Claiming geht — eine Attrappe würde
/// genau das verstecken, worauf es ankommt.
///
/// Die drei Invarianten aus dem Taskboard-Konzept stehen im Mittelpunkt: nie zwei Claims
/// auf einen Termin, kein Dispatch bei offenem Blocker, doppelter Tick = ein Lauf.
/// </summary>
public sealed class TaskRepositoryTests : IDisposable
{
    private readonly string _directory;
    private readonly SqliteStorage _storage;
    private readonly SqliteTaskRepository _repo;

    public TaskRepositoryTests()
    {
        _directory = Path.Combine(Path.GetTempPath(), "clawd-tests", Guid.NewGuid().ToString("N"));
        _storage = new SqliteStorage(Path.Combine(_directory, "state.db"));
        _repo = new SqliteTaskRepository(_storage);
    }

    public void Dispose()
    {
        Microsoft.Data.Sqlite.SqliteConnection.ClearAllPools();
        try { Directory.Delete(_directory, recursive: true); }
        catch { /* Aufräumen ist Nebensache */ }
    }

    private Task<TaskItem> Seed(
        string id, TaskItemStatus status = TaskItemStatus.Todo,
        string assignee = "@new", int priority = 3,
        string title = "Aufgabe", IReadOnlyList<string>? blockedBy = null)
        => _repo.UpsertAsync(new TaskItem
        {
            Id = id,
            Title = title,
            Status = status,
            Assignee = assignee,
            Priority = priority,
            BlockedBy = blockedBy ?? []
        }, default);

    private static string Occ(DateTime t) => t.ToUniversalTime().ToString("O");
    private static readonly DateTime T0 = new(2026, 7, 31, 7, 0, 0, DateTimeKind.Utc);
    private static DateTime Now => DateTime.UtcNow;
    private static DateTime NoStaleClaims => Now.AddHours(-1); // Lease-Cutoff weit in der Vergangenheit

    // ═══════════════════════════════════════════════════════════
    //  Grundfunktionen: Import (Upsert), Lesen, Auflisten
    // ═══════════════════════════════════════════════════════════

    [Fact]
    public async Task Eine_Aufgabe_wird_angelegt_und_wiedergefunden()
    {
        await Seed("t-1", title: "Recherche");

        var found = await _repo.GetAsync("t-1", default);

        found.ShouldNotBeNull();
        found!.Title.ShouldBe("Recherche");
        found.Status.ShouldBe(TaskItemStatus.Todo);
    }

    [Fact]
    public async Task Der_Import_ist_idempotent_und_erzeugt_keine_Dublette()
    {
        await Seed("t-1", title: "Erste Fassung");
        await Seed("t-1", title: "Zweite Fassung");

        (await _repo.CountAsync(default)).ShouldBe(1);
        (await _repo.GetAsync("t-1", default))!.Title.ShouldBe("Zweite Fassung");
    }

    [Fact]
    public async Task Ein_Re_Import_laesst_den_Ausfuehrungszustand_unangetastet()
    {
        // Der springende Punkt der Wahrheitsaufteilung: Die Datei ist Wahrheit über die
        // Definition, die DB über den Ausführungszustand. Ein erneuter Import darf einen
        // laufenden oder abgeschlossenen Zustand nicht zurücksetzen.
        await Seed("t-1");
        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok", Now, NoStaleClaims, default)).ShouldBeTrue();
        await _repo.CompleteClaimAsync("t-1", "tok", TaskItemStatus.Done, Now, default);

        // Datei wird erneut importiert (Titel geändert, Status im Frontmatter noch "todo").
        await _repo.UpsertAsync(new TaskItem { Id = "t-1", Title = "geändert", Status = TaskItemStatus.Todo }, default);

        var after = await _repo.GetAsync("t-1", default);
        after!.Title.ShouldBe("geändert", "die Definition wird übernommen");
        after.Status.ShouldBe(TaskItemStatus.Done, "der Ausführungszustand bleibt");
        after.LastOccurrence.ShouldBe(Occ(T0), "der Marker bleibt erhalten");
    }

    [Fact]
    public async Task Die_Liste_filtert_nach_Status_und_blendet_Archiviertes_aus()
    {
        await Seed("t-1", TaskItemStatus.Todo);
        await Seed("t-2", TaskItemStatus.Done);
        await Seed("t-3", TaskItemStatus.Archived);

        (await _repo.ListAsync(new TaskQuery { Status = TaskItemStatus.Todo }, default)).Count.ShouldBe(1);
        (await _repo.ListAsync(new TaskQuery(), default)).Count.ShouldBe(2, "Archiviertes ist standardmäßig ausgeblendet");
        (await _repo.ListAsync(new TaskQuery { IncludeArchived = true }, default)).Count.ShouldBe(3);
    }

    [Fact]
    public async Task Die_Liste_ordnet_nach_Prioritaet()
    {
        await Seed("t-low", priority: 1, title: "nebensächlich");
        await Seed("t-high", priority: 5, title: "dringend");
        await Seed("t-mid", priority: 3, title: "mittel");

        var list = await _repo.ListAsync(new TaskQuery(), default);

        list[0].Title.ShouldBe("dringend");
        list[^1].Title.ShouldBe("nebensächlich");
    }

    [Fact]
    public async Task Die_Liste_filtert_nach_Assignee_und_Freitext()
    {
        await Seed("t-1", assignee: "@crawler", title: "NVDA Zahlen");
        await Seed("t-2", assignee: "@analyst", title: "TSLA Bericht");

        (await _repo.ListAsync(new TaskQuery { Assignee = "@crawler" }, default)).Count.ShouldBe(1);
        (await _repo.ListAsync(new TaskQuery { Search = "nvda" }, default)).Count.ShouldBe(1);
    }

    // ═══════════════════════════════════════════════════════════
    //  Invariante 1 & 3: nie zwei Claims, doppelter Tick = ein Lauf
    // ═══════════════════════════════════════════════════════════

    [Fact]
    public async Task Ein_Termin_laesst_sich_genau_einmal_beanspruchen()
    {
        await Seed("t-1");

        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok-a", Now, NoStaleClaims, default)).ShouldBeTrue();
        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok-b", Now, NoStaleClaims, default))
            .ShouldBeFalse("der Termin ist bereits beansprucht");
    }

    [Fact]
    public async Task Gleichzeitige_Claims_auf_denselben_Termin_ergeben_genau_einen_Gewinner()
    {
        // Die Kern-Invariante. Mehrfach wiederholt, weil ein Race sporadisch auftritt.
        for (var round = 0; round < 25; round++)
        {
            var id = $"t-race-{round}";
            await Seed(id);

            var attempts = Enumerable.Range(0, 32)
                .Select(i => _repo.TryClaimAsync(id, Occ(T0), $"tok-{i}", Now, NoStaleClaims, default));

            var results = await Task.WhenAll(attempts);

            results.Count(won => won).ShouldBe(1, $"Runde {round}: genau ein Lauf darf den Termin ziehen");
        }
    }

    [Fact]
    public async Task Ein_zweiter_Tick_auf_denselben_Termin_loest_keinen_zweiten_Lauf_aus()
    {
        await Seed("t-1");

        // Erster Tick beansprucht und schließt ab.
        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok", Now, NoStaleClaims, default)).ShouldBeTrue();
        await _repo.CompleteClaimAsync("t-1", "tok", TaskItemStatus.Todo, Now, default);

        // Zweiter Tick im selben Terminfenster: derselbe Occurrence-Key.
        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok2", Now, NoStaleClaims, default))
            .ShouldBeFalse("derselbe Termin darf nach Abschluss nicht erneut laufen");
    }

    [Fact]
    public async Task Ein_gescheiterter_Lauf_wird_nicht_automatisch_wiederholt()
    {
        // Kein Retry-Sturm: Der Marker steht schon beim Claim, nicht erst beim Erfolg.
        await Seed("t-1");
        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok", Now, NoStaleClaims, default)).ShouldBeTrue();

        // Lauf scheitert → zurück auf todo, aber derselbe Termin bleibt verbraucht.
        await _repo.CompleteClaimAsync("t-1", "tok", TaskItemStatus.Todo, Now, default);

        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok2", Now, NoStaleClaims, default))
            .ShouldBeFalse("derselbe Termin wird nicht erneut versucht");
    }

    [Fact]
    public async Task Der_naechste_planmaessige_Termin_laesst_sich_wieder_beanspruchen()
    {
        await Seed("t-1");
        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok", Now, NoStaleClaims, default)).ShouldBeTrue();
        await _repo.CompleteClaimAsync("t-1", "tok", TaskItemStatus.Todo, Now, default);

        // Ein späterer Occurrence-Key liegt über dem Marker → wieder fällig.
        var later = Occ(T0.AddDays(1));
        (await _repo.TryClaimAsync("t-1", later, "tok3", Now, NoStaleClaims, default))
            .ShouldBeTrue("ein neuer Termin darf laufen");
    }

    // ═══════════════════════════════════════════════════════════
    //  Invariante 2: kein Dispatch bei offenem Blocker
    // ═══════════════════════════════════════════════════════════

    [Fact]
    public async Task Eine_blockierte_Aufgabe_laesst_sich_nicht_beanspruchen()
    {
        await Seed("t-1", TaskItemStatus.Blocked, blockedBy: ["t-0"]);

        (await _repo.TryClaimAsync("t-1", Occ(T0), "tok", Now, NoStaleClaims, default))
            .ShouldBeFalse("solange der Blocker offen ist, läuft nichts");
    }

    [Fact]
    public async Task Wartende_Aufgaben_lassen_sich_ueber_ihren_Blocker_finden()
    {
        await Seed("t-a", blockedBy: ["t-blocker"]);
        await Seed("t-b", blockedBy: ["t-blocker", "t-anderer"]);
        await Seed("t-c", blockedBy: ["t-blocker10"]);

        var waiting = await _repo.ListBlockedByAsync("t-blocker", default);

        waiting.Select(t => t.Id).OrderBy(x => x).ShouldBe(["t-a", "t-b"]);
        waiting.ShouldNotContain(t => t.Id == "t-c", "t-blocker darf nicht t-blocker10 treffen");
    }

    // ═══════════════════════════════════════════════════════════
    //  Claim-Abschluss, Lease und Reconciliation
    // ═══════════════════════════════════════════════════════════

    [Fact]
    public async Task Ein_Lauf_ohne_gueltigen_Claim_kann_nichts_ueberschreiben()
    {
        await Seed("t-1");
        (await _repo.TryClaimAsync("t-1", Occ(T0), "echt", Now, NoStaleClaims, default)).ShouldBeTrue();

        (await _repo.CompleteClaimAsync("t-1", "falsch", TaskItemStatus.Done, Now, default))
            .ShouldBeFalse("ein fremdes Token darf den Abschluss nicht setzen");
        (await _repo.CompleteClaimAsync("t-1", "echt", TaskItemStatus.Done, Now, default))
            .ShouldBeTrue();

        (await _repo.GetAsync("t-1", default))!.Status.ShouldBe(TaskItemStatus.Done);
    }

    [Fact]
    public async Task Verwaiste_Claims_werden_beim_Start_zurueckgesetzt()
    {
        await Seed("t-stuck");
        // Claim mit einem Zeitpunkt, der bereits weit zurückliegt (abgestürzter Lauf).
        var longAgo = Now.AddMinutes(-30);
        (await _repo.TryClaimAsync("t-stuck", Occ(T0), "tok", longAgo, longAgo.AddMinutes(-1), default)).ShouldBeTrue();

        // Reconciliation: Claims älter als 5 Minuten gelten als verwaist.
        var reset = await _repo.ReleaseStaleClaimsAsync(Now.AddMinutes(-5), Now, default);

        reset.ShouldBe(1);
        var after = await _repo.GetAsync("t-stuck", default);
        after!.Status.ShouldBe(TaskItemStatus.Todo);
        after.ClaimToken.ShouldBeNull();
    }

    [Fact]
    public async Task Ein_frischer_Claim_wird_bei_der_Reconciliation_nicht_angetastet()
    {
        await Seed("t-live");
        (await _repo.TryClaimAsync("t-live", Occ(T0), "tok", Now, NoStaleClaims, default)).ShouldBeTrue();

        var reset = await _repo.ReleaseStaleClaimsAsync(Now.AddMinutes(-5), Now, default);

        reset.ShouldBe(0, "ein laufender Lauf darf nicht abgeräumt werden");
        (await _repo.GetAsync("t-live", default))!.Status.ShouldBe(TaskItemStatus.InProgress);
    }

    [Fact]
    public async Task Der_Status_laesst_sich_direkt_setzen()
    {
        await Seed("t-1");
        (await _repo.SetStatusAsync("t-1", TaskItemStatus.Canceled, Now, default)).ShouldBeTrue();
        (await _repo.GetAsync("t-1", default))!.Status.ShouldBe(TaskItemStatus.Canceled);
    }

    // ═══════════════════════════════════════════════════════════
    //  Nebenläufigkeit und Persistenz
    // ═══════════════════════════════════════════════════════════

    [Fact]
    public async Task Viele_Aufgaben_lassen_sich_gleichzeitig_importieren()
    {
        var imports = Enumerable.Range(0, 60).Select(i => Seed($"t-{i}"));
        await Task.WhenAll(imports);

        (await _repo.CountAsync(default)).ShouldBe(60);
    }

    [Fact]
    public async Task Aufgaben_ueberdauern_das_Schliessen_der_Datenbank()
    {
        await Seed("t-1", title: "muss einen Neustart überleben");

        var reopened = new SqliteTaskRepository(new SqliteStorage(Path.Combine(_directory, "state.db")));

        (await reopened.GetAsync("t-1", default))!.Title.ShouldBe("muss einen Neustart überleben");
    }
}