using Acceptance.Support;
using Big.Application;
using Big.Domain;
using Reqnroll;
using Xunit;

namespace Acceptance.Steps;

/// <summary>Bindings for <c>EenRegistratieIntrekken.feature</c> (S-11). Submits a registration (which
/// records its process) and then applies the WithdrawRegistration use case against in-memory ports;
/// one instance per scenario. Scoped to this feature so its "the registration has status" step does
/// not clash with the identically phrased steps in the other features.</summary>
[Binding]
[Scope(Feature = "Een registratie intrekken")]
public sealed class EenRegistratieIntrekkenSteps
{
    private const string OwnerBsn = "123456782";

    private readonly InMemoryRegistrationStore _store = new();
    private readonly InMemoryWorkflowClient _workflow = new();
    private RegistrationId _id;
    private WithdrawOutcome _outcome;

    [Given("a submitted registration with a running process")]
    public async Task GivenASubmittedRegistrationWithARunningProcess()
        => _id = await new SubmitRegistration(_store, _workflow).HandleAsync(new SubmitRegistrationCommand(OwnerBsn));

    [When("the zorgprofessional withdraws it")]
    public async Task WhenTheZorgprofessionalWithdrawsIt()
        => _outcome = await new WithdrawRegistration(_store, _workflow).HandleAsync(
            new WithdrawRegistrationCommand(_id, OwnerBsn));

    [When("a different zorgprofessional tries to withdraw it")]
    public async Task WhenADifferentZorgprofessionalTriesToWithdrawIt()
        => _outcome = await new WithdrawRegistration(_store, _workflow).HandleAsync(
            new WithdrawRegistrationCommand(_id, "999999990"));

    [Then("the withdrawal succeeds")]
    public void ThenTheWithdrawalSucceeds() => Assert.Equal(WithdrawOutcome.Withdrawn, _outcome);

    [Then("the withdrawal is reported not found")]
    public void ThenTheWithdrawalIsReportedNotFound() => Assert.Equal(WithdrawOutcome.NotFound, _outcome);

    [Then("the registration has status \"(.*)\"")]
    public async Task ThenTheRegistrationHasStatus(string expected)
    {
        var registration = await _store.GetAsync(_id);
        Assert.NotNull(registration);
        Assert.Equal(expected, registration.Status.ToString().ToUpperInvariant());
    }

    [Then("the running process is cancelled")]
    public void ThenTheRunningProcessIsCancelled()
        => Assert.Equal(InMemoryWorkflowClient.StartedProcessInstanceId, _workflow.WithdrawnProcessInstanceId);

    [Then("the running process is not cancelled")]
    public void ThenTheRunningProcessIsNotCancelled()
        => Assert.Null(_workflow.WithdrawnProcessInstanceId);
}