using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.MessageQueue.Models;
using Dpz.Core.MessageQueue.RabbitMQ;
using Microsoft.Extensions.Logging.Abstractions;

namespace Dpz.Core.MessageQueue.Test.RabbitMQ;

public class MessageOutboxRetryServiceTests
{
    [Fact]
    public async Task RetryAsync_ShouldRepublishPendingEntriesAndMarkSent()
    {
        var outboxStore = new InMemoryOutboxStore
        {
            PendingPublishEntries = [Entry("publish-1"), Entry("publish-2")],
            PendingConsumeEntries = [Entry("consume-1")],
        };
        var retryPublisher = new InMemoryRetryPublisher();
        var sut = new MessageOutboxRetryService(
            outboxStore,
            retryPublisher,
            NullLogger<MessageOutboxRetryService>.Instance
        );

        var result = await sut.RetryAsync(50);

        Assert.Equal(2, result.PublishRetryCount);
        Assert.Equal(0, result.PublishFailureCount);
        Assert.Equal(1, result.ConsumeRetryCount);
        Assert.Equal(0, result.ConsumeFailureCount);
        Assert.Equal(["publish-1", "publish-2", "consume-1"], outboxStore.SentMessageIds);
        Assert.Equal(["publish-1", "publish-2", "consume-1"], retryPublisher.PublishedMessageIds);
    }

    [Fact]
    public async Task RetryAsync_ShouldMarkPublishFailed_WhenPublishRetryThrows()
    {
        var outboxStore = new InMemoryOutboxStore { PendingPublishEntries = [Entry("publish-1")] };
        var retryPublisher = new InMemoryRetryPublisher { ThrowForMessageIds = ["publish-1"] };
        var sut = new MessageOutboxRetryService(
            outboxStore,
            retryPublisher,
            NullLogger<MessageOutboxRetryService>.Instance
        );

        var result = await sut.RetryAsync(50);

        Assert.Equal(1, result.PublishRetryCount);
        Assert.Equal(1, result.PublishFailureCount);
        Assert.Empty(outboxStore.SentMessageIds);
        Assert.Equal(["publish-1"], outboxStore.PublishFailedMessageIds);
    }

    [Fact]
    public async Task RetryAsync_ShouldMarkConsumeFailed_WhenConsumeRetryThrows()
    {
        var outboxStore = new InMemoryOutboxStore { PendingConsumeEntries = [Entry("consume-1")] };
        var retryPublisher = new InMemoryRetryPublisher { ThrowForMessageIds = ["consume-1"] };
        var sut = new MessageOutboxRetryService(
            outboxStore,
            retryPublisher,
            NullLogger<MessageOutboxRetryService>.Instance
        );

        var result = await sut.RetryAsync(50);

        Assert.Equal(1, result.ConsumeRetryCount);
        Assert.Equal(1, result.ConsumeFailureCount);
        Assert.Empty(outboxStore.SentMessageIds);
        Assert.Equal(["consume-1"], outboxStore.ConsumeFailedMessageIds);
    }

    private static MessageOutboxEntry Entry(string messageId) =>
        new(messageId, "test.exchange", "test.routing", "{}", 1, 1);

    private sealed class InMemoryRetryPublisher : IMessageOutboxRetryPublisher
    {
        public List<string> PublishedMessageIds { get; } = [];

        public HashSet<string> ThrowForMessageIds { get; init; } = [];

        public Task PublishRawAsync(
            string exchange,
            string routingKey,
            string messageId,
            string jsonPayload,
            CancellationToken cancellationToken = default
        )
        {
            if (ThrowForMessageIds.Contains(messageId))
            {
                throw new InvalidOperationException("retry failed");
            }

            PublishedMessageIds.Add(messageId);
            return Task.CompletedTask;
        }
    }

    private sealed class InMemoryOutboxStore : IMessageOutboxStore
    {
        public IReadOnlyList<MessageOutboxEntry> PendingPublishEntries { get; init; } = [];

        public IReadOnlyList<MessageOutboxEntry> PendingConsumeEntries { get; init; } = [];

        public List<string> SentMessageIds { get; } = [];

        public List<string> PublishFailedMessageIds { get; } = [];

        public List<string> ConsumeFailedMessageIds { get; } = [];

        public Task CreateAsync(
            string messageId,
            string messageType,
            string exchange,
            string routingKey,
            string payload,
            string? source,
            CancellationToken cancellationToken = default
        ) => Task.CompletedTask;

        public Task MarkSentAsync(string messageId, CancellationToken cancellationToken = default)
        {
            SentMessageIds.Add(messageId);
            return Task.CompletedTask;
        }

        public Task MarkPublishFailedAsync(
            string messageId,
            string error,
            CancellationToken cancellationToken = default
        )
        {
            PublishFailedMessageIds.Add(messageId);
            return Task.CompletedTask;
        }

        public Task MarkConsumedAsync(
            string messageId,
            CancellationToken cancellationToken = default
        ) => Task.CompletedTask;

        public Task RecordConsumeAttemptFailedAsync(
            string messageId,
            string error,
            CancellationToken cancellationToken = default
        ) => Task.CompletedTask;

        public Task MarkConsumeFailedAsync(
            string messageId,
            string error,
            CancellationToken cancellationToken = default
        )
        {
            ConsumeFailedMessageIds.Add(messageId);
            return Task.CompletedTask;
        }

        public Task<IReadOnlyList<MessageOutboxEntry>> GetPendingPublishRetryAsync(
            int batchSize,
            CancellationToken cancellationToken = default
        ) => Task.FromResult(PendingPublishEntries);

        public Task<IReadOnlyList<MessageOutboxEntry>> GetPendingConsumeRetryAsync(
            int batchSize,
            CancellationToken cancellationToken = default
        ) => Task.FromResult(PendingConsumeEntries);
    }
}