using BuildFlow.Shared.Domain.Errors;
using FluentAssertions;
using Microsoft.EntityFrameworkCore;
using Workflow.Application.Features.WorkflowTasks.Commands;
using Workflow.Application.Features.WorkflowTasks.Handlers;
using Workflow.Domain.Entities;
using Workflow.Domain.Enums;
using Xunit;

using TaskStatus = global::Workflow.Domain.Enums.TaskStatus;

namespace BuildFlow.Workflow.Tests.Handlers;

public class UrgeTaskCommandHandlerTests
{
    private static WorkflowDbContext CreateDbContext()
    {
        var options = new DbContextOptionsBuilder<WorkflowDbContext>()
            .UseInMemoryDatabase(Guid.NewGuid().ToString())
            .Options;
        var db = new WorkflowDbContext(options);
        db.SavingChanges += AuditStub.OnSave;
        return db;
    }

    private static WorkflowTask SeedTask(WorkflowDbContext db, TaskStatus status)
    {
        var task = new WorkflowTask
        {
            Id = Guid.NewGuid(),
            InstanceId = Guid.NewGuid(),
            TokenId = Guid.NewGuid(),
            NodeId = Guid.NewGuid(),
            Title = "Task",
            AssigneeId = Guid.NewGuid(),
            Status = status
        };
        db.WorkflowTasks.Add(task);
        return task;
    }

    [Fact]
    public async Task UrgeTask_PendingTask_Succeeds()
    {
        await using var db = CreateDbContext();
        var task = SeedTask(db, TaskStatus.Pending);
        await db.SaveChangesAsync();

        var handler = new UrgeTaskCommandHandler(db);
        var result = await handler.Handle(new UrgeTaskCommand(task.Id, Guid.NewGuid()), CancellationToken.None);

        result.Should().Be(MediatR.Unit.Value);
    }

    [Fact]
    public async Task UrgeTask_MissingTask_ThrowsNotFound()
    {
        await using var db = CreateDbContext();
        var handler = new UrgeTaskCommandHandler(db);

        var act = async () => await handler.Handle(new UrgeTaskCommand(Guid.NewGuid(), Guid.NewGuid()), CancellationToken.None);

        var ex = await act.Should().ThrowAsync<NotFoundException>();
        ex.Which.Code.Should().Be(ErrorCode.NotFound);
    }

    [Fact]
    public async Task UrgeTask_NonPendingTask_ThrowsInvalidState()
    {
        await using var db = CreateDbContext();
        var task = SeedTask(db, TaskStatus.Approved);
        await db.SaveChangesAsync();

        var handler = new UrgeTaskCommandHandler(db);

        var act = async () => await handler.Handle(new UrgeTaskCommand(task.Id, Guid.NewGuid()), CancellationToken.None);

        var ex = await act.Should().ThrowAsync<BusinessException>();
        ex.Which.Code.Should().Be(ErrorCode.InvalidState);
    }
}