using EventSubscriber.Application;

namespace EventSubscriber.Tests;

/// <summary>Behaviour of the projector that turns NRC notifications into projection rows.
/// The walking skeleton reacts only to a zaak being created (status INGEDIEND) and must
/// tolerate duplicate and out-of-order deliveries (CLAUDE.md §8.6).</summary>
public sealed class NotificationProjectorTests
{
    private const string ZaakUrl = "http://openzaak:8000/zaken/api/v1/zaken/11111111-1111-1111-1111-111111111111";
    private const string StatusUrl = "http://openzaak:8000/zaken/api/v1/statussen/22222222-2222-2222-2222-222222222222";

    private readonly InMemoryNotificationLog _log = new();
    private readonly InMemoryProjectionStore _store = new();

    private NotificationProjector Projector() => new(_log, _store);

    private static Notification ZaakCreated(string url = ZaakUrl)
        => new("zaken", "zaak", "create", new Uri(url));

    // A status-set notification: resourceUrl is the status resource, hoofdObject is the zaak it belongs to.
    private static Notification StatusSet(string zaakUrl = ZaakUrl, string statusUrl = StatusUrl)
        => new("zaken", "status", "create", new Uri(statusUrl), new Uri(zaakUrl));

    [Fact]
    public async Task creating_a_zaak_writes_one_row_with_status_ingediend()
    {
        await Projector().HandleAsync(ZaakCreated());

        var entry = Assert.Single(await _store.AllAsync());
        Assert.Equal("11111111-1111-1111-1111-111111111111", entry.Id);
        Assert.Equal(RegistrationStatus.Ingediend, entry.Status);
    }

    [Fact]
    public async Task replaying_the_same_notification_keeps_a_single_row()
    {
        var projector = Projector();
        await projector.HandleAsync(ZaakCreated());
        await projector.HandleAsync(ZaakCreated());

        Assert.Single(await _store.AllAsync());
    }

    [Fact]
    public async Task a_replayed_notification_never_reaches_the_projection_store()
    {
        var projector = Projector();
        await projector.HandleAsync(ZaakCreated());
        await projector.HandleAsync(ZaakCreated());

        // The duplicate is dropped at the log, before the (idempotent) upsert — so the store
        // is written exactly once. Row count alone can't see this; the upsert count can.
        Assert.Equal(1, _store.UpsertCount);
    }

    [Fact]
    public async Task two_different_zaken_each_get_their_own_row()
    {
        var projector = Projector();
        await projector.HandleAsync(ZaakCreated());
        await projector.HandleAsync(ZaakCreated(ZaakUrl[..^1] + "2")); // a distinct zaak url

        Assert.Equal(2, (await _store.AllAsync()).Count);
    }

    [Theory]
    [InlineData("documenten", "enkelvoudiginformatieobject", "create")] // wrong kanaal + resource
    [InlineData("documenten", "zaak", "create")]                        // wrong kanaal only
    [InlineData("zaken", "zaak", "update")]                             // wrong actie
    [InlineData("zaken", "zaak", "destroy")]                            // wrong actie
    [InlineData("zaken", "status", "update")]                           // a status change we ignore
    [InlineData("zaken", "resultaat", "create")]                        // not a status we project
    public async Task an_unrelated_notification_is_not_projected(string kanaal, string resource, string actie)
    {
        await Projector().HandleAsync(new Notification(kanaal, resource, actie, new Uri(ZaakUrl)));

        Assert.Empty(await _store.AllAsync());
    }

    [Fact]
    public async Task setting_a_status_projects_ingeschreven_keyed_on_the_zaak_not_the_status()
    {
        await Projector().HandleAsync(StatusSet());

        var entry = Assert.Single(await _store.AllAsync());
        // Keyed on the zaak (hoofdObject), not the status resource URL.
        Assert.Equal("11111111-1111-1111-1111-111111111111", entry.Id);
        Assert.Equal(RegistrationStatus.Ingeschreven, entry.Status);
    }

    [Fact]
    public async Task approving_updates_the_existing_zaak_row_from_ingediend_to_ingeschreven()
    {
        var projector = Projector();
        await projector.HandleAsync(ZaakCreated());
        await projector.HandleAsync(StatusSet());

        var entry = Assert.Single(await _store.AllAsync());
        Assert.Equal("11111111-1111-1111-1111-111111111111", entry.Id);
        Assert.Equal(RegistrationStatus.Ingeschreven, entry.Status);
    }

    [Fact]
    public async Task rebuild_reproduces_the_approved_status()
    {
        var projector = Projector();
        await projector.HandleAsync(ZaakCreated());
        await projector.HandleAsync(StatusSet());

        await projector.RebuildAsync();

        var entry = Assert.Single(await _store.AllAsync());
        Assert.Equal(RegistrationStatus.Ingeschreven, entry.Status);
    }

    [Fact]
    public async Task rebuild_clears_stale_rows_and_repopulates_from_the_notification_log()
    {
        var projector = Projector();
        await projector.HandleAsync(ZaakCreated());
        // A stale row that is not backed by any logged notification must not survive a rebuild.
        await _store.UpsertAsync(new RegisterEntry("stale-9999", RegistrationStatus.Ingediend));

        await projector.RebuildAsync();

        var entry = Assert.Single(await _store.AllAsync());
        Assert.Equal("11111111-1111-1111-1111-111111111111", entry.Id);
        Assert.Equal(RegistrationStatus.Ingediend, entry.Status);
    }
}