using Dpz.Core.Entity.Base;
using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.MessageQueue.Extensions;
using Dpz.Core.MessageQueue.RabbitMQ;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Moq;

namespace Dpz.Core.MessageQueue.Test.RabbitMQ;

public class RabbitMQPublisherRegistrationTests
{
    [Fact]
    public async Task AddRabbitMQ_ShouldResolveTypedPublisherFromDi()
    {
        var services = new ServiceCollection();
        services.AddLogging();

        var configuration = new ConfigurationBuilder()
            .AddInMemoryCollection(
                new Dictionary<string, string?>
                {
                    ["RabbitMQ:HostName"] = "host",
                    ["RabbitMQ:Port"] = "5672",
                    ["RabbitMQ:UserName"] = "guest",
                    ["RabbitMQ:Password"] = "guest",
                    ["RabbitMQ:VirtualHost"] = "/",
                }
            )
            .Build();

        services.AddRabbitMQ(configuration);

        await using var provider = services.BuildServiceProvider();

        var publisher = provider.GetRequiredService<IMessagePublisher<SampleMessage>>();

        Assert.IsType<RabbitMQPublisher<SampleMessage>>(publisher);
    }

    [Fact]
    public async Task PublisherCanBeConstructedUsingDiWithMockedDependencies()
    {
        var services = new ServiceCollection();

        var connectionFactory = new Mock<IRabbitMQConnectionFactory>();
        var routingConvention = new Mock<IMessageRoutingConvention>();
        routingConvention
            .Setup(x => x.GetExchangeName<SampleMessage>())
            .Returns("dpz.sample.exchange");
        routingConvention
            .Setup(x => x.GetExchangeType<SampleMessage>())
            .Returns(Enums.ExchangeType.Topic);
        routingConvention.Setup(x => x.GetRoutingKey<SampleMessage>()).Returns("sample.message.#");
        routingConvention
            .Setup(x => x.GetQueueName<SampleMessage>())
            .Returns("dpz.sample.message.queue");

        services.AddSingleton(connectionFactory.Object);
        services.AddSingleton(routingConvention.Object);
        services.AddSingleton<ILogger<RabbitMQPublisher<SampleMessage>>>(_ =>
            Microsoft
                .Extensions
                .Logging
                .Abstractions
                .NullLogger<RabbitMQPublisher<SampleMessage>>
                .Instance
        );
        services.AddSingleton<IMessagePublisher<SampleMessage>, RabbitMQPublisher<SampleMessage>>();

        await using var provider = services.BuildServiceProvider();

        var publisher = provider.GetRequiredService<IMessagePublisher<SampleMessage>>();
        Assert.NotNull(publisher);
    }

    private sealed class SampleMessage : MessageBase { }
}