using EnvelopeGenerator.Application;
using EnvelopeGenerator.Application.Histories.Commands;
using EnvelopeGenerator.Application.Histories.Queries;
using EnvelopeGenerator.Domain;
using EnvelopeGenerator.Infrastructure;
using MediatR;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

namespace EnvelopeGenerator.Tests.Application;

[TestFixture]
public class HistoryTests
{
    private IHost _host;

    private IServiceProvider Provider => _host.Services;

    [SetUp]
    public void Setup()
    {
        _host = Host.CreateDefaultBuilder()
            .ConfigureAppConfiguration((context, config) =>
            {
                // add appsettings.json
                config.SetBasePath(Directory.GetCurrentDirectory());
                config.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true);
            })
            .ConfigureServices((context, services) =>
            {
                IConfiguration configuration = context.Configuration;

                // add Application and Infrastructure services
#pragma warning disable CS0618
                services.AddEnvelopeGeneratorServices(configuration);
                services.AddEnvelopeGeneratorInfrastructureServices(
                    (sp, options) => options.UseInMemoryDatabase("EnvelopeGeneratorTestDb"),
                    context.Configuration
                );
#pragma warning restore CS0618
            })
            .Build();
    }

    [TearDown]
    public void TearDown()
    {
        _host.Dispose();
    }

    private async Task<TResponse> Send<TResponse>(IRequest<TResponse> request)
    {
        var mediator = Provider.GetRequiredService<IMediator>();
        return await mediator.Send(request);
    }

    [Test]
    public async Task CreateHistory_And_ReadHistory_Should_Work()
    {
        // Arrange
        var createCmd = new CreateHistoryCommand
        {
            EnvelopeId = 1,
            UserReference = "UserA",
            Status = Constants.EnvelopeStatus.EnvelopeCreated,
            Comment = "First create"
        };

        // Act
        var id = await Send(createCmd);

        // Assert
        Assert.That(id, Is.Not.Null);

        // ReadHistory sorgusu
        var query = new ReadHistoryQuery(1);
        var result = await Send(query);

        Assert.That(result, Is.Not.Empty);
    }

    [Test]
    public async Task ReadHistory_Should_Filter_By_Status()
    {
        // Arrange
        var createCmd1 = new CreateHistoryCommand
        {
            EnvelopeId = 2,
            UserReference = "UserX",
            Status = Constants.EnvelopeStatus.EnvelopeCreated
        };

        var createCmd2 = new CreateHistoryCommand
        {
            EnvelopeId = 2,
            UserReference = "UserX",
            Status = Constants.EnvelopeStatus.EnvelopePartlySigned
        };

        await Send(createCmd1);
        await Send(createCmd2);

        // Act
        var result = await Send(new ReadHistoryQuery(2, Constants.EnvelopeStatus.EnvelopePartlySigned));

        // Assert
        Assert.That(result, Has.Exactly(1).Items);
        Assert.That(result, Has.All.Matches<EnvelopeGenerator.Application.Dto.EnvelopeHistory.EnvelopeHistoryDto>(
            r => r.Status == Constants.EnvelopeStatus.EnvelopePartlySigned));
    }

    [Test]
    public async Task ReadHistory_Should_Return_Empty_When_No_Record()
    {
        // Act
        var result = await Send(new ReadHistoryQuery(999));

        // Assert
        Assert.That(result, Is.Empty);
    }
}