using Dpz.Core.Entity.Base;
using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.MessageQueue.Configuration;
using Dpz.Core.MessageQueue.Extensions;
using Dpz.Core.MessageQueue.Models;
using Dpz.Core.MessageQueue.RabbitMQ;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Options;

namespace Dpz.Core.MessageQueue.Test.Extensions;

public class MessageQueueServiceExtensionsTests
{
    [Fact]
    public async Task AddRabbitMQ_ShouldRegisterCoreServicesAndOptions()
    {
        var services = new ServiceCollection();
        services.AddLogging();
        var configuration = new ConfigurationBuilder()
            .AddInMemoryCollection(
                new Dictionary<string, string?>
                {
                    ["RabbitMQ:HostName"] = "mq.test.local",
                    ["RabbitMQ:Port"] = "5673",
                    ["RabbitMQ:UserName"] = "u",
                    ["RabbitMQ:Password"] = "p",
                    ["RabbitMQ:VirtualHost"] = "/v",
                }
            )
            .Build();

        services.AddRabbitMQ(configuration);

        await using var provider = services.BuildServiceProvider();

        var options = provider.GetRequiredService<IOptions<RabbitMQOptions>>().Value;
        Assert.Equal("mq.test.local", options.HostName);
        Assert.Equal(5673, options.Port);

        var routing = provider.GetRequiredService<IMessageRoutingConvention>();
        Assert.IsType<DefaultMessageRoutingConvention>(routing);

        var factory = provider.GetRequiredService<IRabbitMQConnectionFactory>();
        Assert.IsType<RabbitMQConnectionFactory>(factory);

        var publisher = provider.GetRequiredService<IMessagePublisher<TestMessage>>();
        Assert.IsType<RabbitMQPublisher<TestMessage>>(publisher);
    }

    [Fact]
    public void AddMessageConsumer_ShouldRegisterHandlerAndHostedService()
    {
        var services = new ServiceCollection();

        services.AddMessageConsumer<TestMessage, TestMessageHandler>();

        var handlerDescriptor = services.SingleOrDefault(x =>
            x.ServiceType == typeof(IMessageHandler<TestMessage>)
        );
        Assert.NotNull(handlerDescriptor);
        Assert.Equal(ServiceLifetime.Scoped, handlerDescriptor.Lifetime);
        Assert.Equal(typeof(TestMessageHandler), handlerDescriptor.ImplementationType);

        var hostedServiceDescriptor = services.LastOrDefault(x =>
            x.ServiceType == typeof(IHostedService)
        );
        Assert.NotNull(hostedServiceDescriptor);
        Assert.Equal(
            typeof(RabbitMQConsumerBackgroundService<TestMessage>),
            hostedServiceDescriptor.ImplementationType
        );
    }

    [Fact]
    public void AddMessageConsumerWithResult_ShouldRegisterHandlerAndHostedService()
    {
        var services = new ServiceCollection();

        services.AddMessageConsumer<
            TestMessage,
            TestMessageResultHandler,
            MessageHandlerResult<string>
        >();

        var handlerDescriptor = services.SingleOrDefault(x =>
            x.ServiceType == typeof(IMessageHandler<TestMessage, MessageHandlerResult<string>>)
        );
        Assert.NotNull(handlerDescriptor);
        Assert.Equal(ServiceLifetime.Scoped, handlerDescriptor.Lifetime);
        Assert.Equal(typeof(TestMessageResultHandler), handlerDescriptor.ImplementationType);

        var hostedServiceDescriptor = services.LastOrDefault(x =>
            x.ServiceType == typeof(IHostedService)
        );
        Assert.NotNull(hostedServiceDescriptor);
        Assert.Equal(
            typeof(RabbitMQConsumerBackgroundServiceWithResult<
                TestMessage,
                MessageHandlerResult<string>
            >),
            hostedServiceDescriptor.ImplementationType
        );
    }

    [Fact]
    public void AddCustomRoutingConvention_ShouldReplaceRoutingConvention()
    {
        var services = new ServiceCollection();

        services.AddCustomRoutingConvention<CustomRoutingConvention>();

        using var provider = services.BuildServiceProvider();
        var routing = provider.GetRequiredService<IMessageRoutingConvention>();

        Assert.IsType<CustomRoutingConvention>(routing);
    }

    [Fact]
    public async Task AddRabbitMQ_ShouldRegisterNullOutboxStoreAndRetryPublisherByDefault()
    {
        var services = new ServiceCollection();
        services.AddLogging();
        var configuration = new ConfigurationBuilder()
            .AddInMemoryCollection(new Dictionary<string, string?> { ["RabbitMQ:HostName"] = "h" })
            .Build();

        services.AddRabbitMQ(configuration);

        await using var provider = services.BuildServiceProvider();

        var store = provider.GetRequiredService<IMessageOutboxStore>();
        Assert.IsType<NullMessageOutboxStore>(store);

        var retryPublisher = provider.GetRequiredService<IMessageOutboxRetryPublisher>();
        // NullMessageOutboxRetryPublisher 是 internal，仅做不为 null 校验
        Assert.NotNull(retryPublisher);
        Assert.Equal(
            "Dpz.Core.MessageQueue.RabbitMQ.NullMessageOutboxRetryPublisher",
            retryPublisher.GetType().FullName
        );

        // 默认 Null 实现的重试发布也应保持空操作语义
        await retryPublisher.PublishRawAsync("ex", "rk", "id", "{}");
    }

    [Fact]
    public void AddBatchTracking_ShouldRegisterBatchTracker()
    {
        var services = new ServiceCollection();

        services.AddBatchTracking();

        var descriptor = services.SingleOrDefault(x => x.ServiceType == typeof(IBatchTracker));
        Assert.NotNull(descriptor);
        Assert.Equal(ServiceLifetime.Singleton, descriptor.Lifetime);
        Assert.Equal(typeof(DistributedBatchTracker), descriptor.ImplementationType);
    }

    [Fact]
    public void AddMessageOutboxRetryWorker_ShouldRegisterRetryServiceAndHostedService()
    {
        var services = new ServiceCollection();

        services.AddMessageOutboxRetryWorker();

        var retryServiceDescriptor = services.SingleOrDefault(x =>
            x.ServiceType == typeof(IMessageOutboxRetryService)
        );
        Assert.NotNull(retryServiceDescriptor);
        Assert.Equal(ServiceLifetime.Singleton, retryServiceDescriptor.Lifetime);
        Assert.Equal(typeof(MessageOutboxRetryService), retryServiceDescriptor.ImplementationType);

        var hostedServiceDescriptor = services.LastOrDefault(x =>
            x.ServiceType == typeof(IHostedService)
        );
        Assert.NotNull(hostedServiceDescriptor);
        Assert.Equal(
            typeof(MessageOutboxRetryBackgroundService),
            hostedServiceDescriptor.ImplementationType
        );
    }

    private sealed class TestMessage : MessageBase { }

    private sealed class TestMessageHandler : IMessageHandler<TestMessage>
    {
        public Task<MessageHandlerResult> HandleAsync(
            TestMessage message,
            CancellationToken cancellationToken = default
        )
        {
            return Task.FromResult(MessageHandlerResult.Ok());
        }
    }

    private sealed class TestMessageResultHandler
        : IMessageHandler<TestMessage, MessageHandlerResult<string>>
    {
        public Task<MessageHandlerResult<string>> HandleAsync(
            TestMessage message,
            CancellationToken cancellationToken = default
        )
        {
            return Task.FromResult(MessageHandlerResult<string>.Ok("ok"));
        }
    }

    private sealed class CustomRoutingConvention : IMessageRoutingConvention
    {
        public string GetExchangeName<TMessage>() => "custom-exchange";

        public string GetQueueName<TMessage>() => "custom-queue";

        public string GetRoutingKey<TMessage>() => "custom.routing";

        public Enums.ExchangeType GetExchangeType<TMessage>() => Enums.ExchangeType.Fanout;
    }
}