using Big.Application;
using Big.Domain;

namespace Big.Tests;

public class WithdrawRegistrationTests
{
    private const string Bsn = "123456782";

    private static Registration Submitted(string processInstanceId = "proc-1")
    {
        var registration = Registration.Submit(Bsn);
        registration.RecordProcessStarted(processInstanceId);
        return registration;
    }

    private static WithdrawRegistrationCommand Command(RegistrationId id, string bsn = Bsn) => new(id, bsn);

    [Fact]
    public async Task Withdrawing_marks_the_registration_ingetrokken_and_persists_it()
    {
        var store = new FakeRegistrationStore();
        var registration = Submitted();
        store.Seed(registration);
        var handler = new WithdrawRegistration(store, new FakeWorkflowClient());

        var outcome = await handler.HandleAsync(Command(registration.Id));

        Assert.Equal(WithdrawOutcome.Withdrawn, outcome);
        var saved = await store.GetAsync(registration.Id);
        Assert.Equal(RegistrationStatus.Ingetrokken, saved!.Status);
        Assert.Equal(1, store.SaveCount);
    }

    [Fact]
    public async Task Withdrawing_cancels_the_running_process()
    {
        var store = new FakeRegistrationStore();
        var registration = Submitted("proc-42");
        store.Seed(registration);
        var workflow = new FakeWorkflowClient();
        var handler = new WithdrawRegistration(store, workflow);

        await handler.HandleAsync(Command(registration.Id));

        // The process the registration recorded at submit is cancelled (ADR-0014).
        Assert.Equal("proc-42", workflow.WithdrawnProcessInstanceId);
    }

    [Fact]
    public async Task Withdrawing_before_a_process_was_started_still_marks_ingetrokken()
    {
        var store = new FakeRegistrationStore();
        var registration = Registration.Submit(Bsn); // no RecordProcessStarted
        store.Seed(registration);
        var workflow = new FakeWorkflowClient();
        var handler = new WithdrawRegistration(store, workflow);

        await handler.HandleAsync(Command(registration.Id));

        Assert.Equal(RegistrationStatus.Ingetrokken, (await store.GetAsync(registration.Id))!.Status);
        Assert.Null(workflow.WithdrawnProcessInstanceId);
    }

    [Fact]
    public async Task A_different_bsn_cannot_withdraw_the_registration()
    {
        // Owner-scoping: only the zorgprofessional who submitted may withdraw. Another bsn is told
        // NotFound (we don't reveal the registration exists) and nothing is changed.
        var store = new FakeRegistrationStore();
        var registration = Submitted();
        store.Seed(registration);
        var workflow = new FakeWorkflowClient();
        var handler = new WithdrawRegistration(store, workflow);

        var outcome = await handler.HandleAsync(Command(registration.Id, bsn: "999999990"));

        Assert.Equal(WithdrawOutcome.NotFound, outcome);
        Assert.Equal(RegistrationStatus.Ingediend, (await store.GetAsync(registration.Id))!.Status);
        Assert.Equal(0, store.SaveCount);
        Assert.Null(workflow.WithdrawnProcessInstanceId);
    }

    [Fact]
    public async Task Rejects_a_null_command_without_touching_the_store()
    {
        var store = new FakeRegistrationStore();
        var handler = new WithdrawRegistration(store, new FakeWorkflowClient());

        await Assert.ThrowsAsync<ArgumentNullException>(() => handler.HandleAsync(null!));
        Assert.Equal(0, store.SaveCount);
    }

    [Fact]
    public async Task Withdrawing_an_unknown_registration_is_not_found()
    {
        var store = new FakeRegistrationStore();
        var handler = new WithdrawRegistration(store, new FakeWorkflowClient());

        var outcome = await handler.HandleAsync(Command(RegistrationId.New()));

        Assert.Equal(WithdrawOutcome.NotFound, outcome);
        Assert.Equal(0, store.SaveCount);
    }

    [Fact]
    public async Task Re_withdrawing_an_already_ingetrokken_registration_is_idempotent()
    {
        var store = new FakeRegistrationStore();
        var registration = Submitted();
        store.Seed(registration);
        var workflow = new FakeWorkflowClient();
        var handler = new WithdrawRegistration(store, workflow);

        await handler.HandleAsync(Command(registration.Id));
        var second = await handler.HandleAsync(Command(registration.Id));

        // The second withdrawal is a no-op: still Withdrawn, but the aggregate is not persisted again.
        Assert.Equal(WithdrawOutcome.Withdrawn, second);
        Assert.Equal(1, store.SaveCount);
        Assert.Equal(RegistrationStatus.Ingetrokken, (await store.GetAsync(registration.Id))!.Status);
    }
}