using ItWorx.KnowledgeHub.Domain.Decisions;

namespace ItWorx.KnowledgeHub.Domain.Tests;

public sealed class DecisionRecordTests
{
    private static readonly DateTimeOffset Now = new(2026, 8, 1, 12, 0, 0, TimeSpan.Zero);
    private static readonly DateOnly Today = DateOnly.FromDateTime(Now.UtcDateTime);

    private static DecisionRecord CreateProposed(Guid? supersedes = null) =>
        DecisionRecord.Create(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), 1, Today, "Samenvatting", supersedes, Guid.NewGuid(), Now);

    [Fact]
    public void Create_starts_proposed()
    {
        var decision = CreateProposed();

        Assert.Equal(DecisionStatus.Proposed, decision.Status);
        Assert.Null(decision.SupersededByDecisionId);
    }

    [Fact]
    public void Accept_transitions_from_proposed_to_accepted()
    {
        var decision = CreateProposed();

        decision.Accept(Now);

        Assert.Equal(DecisionStatus.Accepted, decision.Status);
    }

    [Fact]
    public void Accept_a_non_proposed_decision_throws()
    {
        var decision = CreateProposed();
        decision.Accept(Now);

        var exception = Record.Exception(() => decision.Accept(Now));

        Assert.IsType<InvalidOperationException>(exception);
    }

    [Fact]
    public void Reject_transitions_from_proposed_to_rejected()
    {
        var decision = CreateProposed();

        decision.Reject(Now);

        Assert.Equal(DecisionStatus.Rejected, decision.Status);
    }

    [Theory]
    [InlineData(DecisionStatus.Proposed)]
    [InlineData(DecisionStatus.Accepted)]
    public void Withdraw_is_allowed_from_proposed_or_accepted(DecisionStatus initial)
    {
        var decision = CreateProposed();
        if (initial == DecisionStatus.Accepted)
        {
            decision.Accept(Now);
        }

        decision.Withdraw(Now);

        Assert.Equal(DecisionStatus.Withdrawn, decision.Status);
    }

    [Fact]
    public void Withdraw_a_rejected_decision_throws()
    {
        var decision = CreateProposed();
        decision.Reject(Now);

        var exception = Record.Exception(() => decision.Withdraw(Now));

        Assert.IsType<InvalidOperationException>(exception);
    }

    [Fact]
    public void MarkSupersededBy_requires_the_decision_to_currently_be_accepted()
    {
        var decision = CreateProposed();

        var exception = Record.Exception(() => decision.MarkSupersededBy(Guid.NewGuid(), Now));

        Assert.IsType<InvalidOperationException>(exception);
    }

    [Fact]
    public void MarkSupersededBy_records_the_replacement_and_flips_status()
    {
        var decision = CreateProposed();
        decision.Accept(Now);
        var replacementId = Guid.NewGuid();

        decision.MarkSupersededBy(replacementId, Now);

        Assert.Equal(DecisionStatus.Superseded, decision.Status);
        Assert.Equal(replacementId, decision.SupersededByDecisionId);
    }
}