using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.MessageQueue.Models;
using Dpz.Core.MessageQueue.RabbitMQ;
using Medallion.Threading.FileSystem;
using Microsoft.Extensions.Logging.Abstractions;
using ZiggyCreatures.Caching.Fusion;

namespace Dpz.Core.MessageQueue.Test.RabbitMQ;

public class MessageOutboxRetryBackgroundServiceTests
{
    private const string StateCacheKey = "Dpz.Core.MessageQueue.OutboxRetry.LastState";

    [Fact]
    public async Task ExecuteAsync_ShouldThrottle_WhenNoMessagesNeedRetry()
    {
        var cache = new FusionCache(new FusionCacheOptions());
        var retryService = new CountingRetryService(new MessageOutboxRetryResult(0, 0, 0, 0));
        var tempDir = CreateTempDir();
        var lockProvider = new FileDistributedSynchronizationProvider(new DirectoryInfo(tempDir));
        var sut = CreateService(retryService, cache, lockProvider);

        try
        {
            await sut.StartAsync(CancellationToken.None);
            await WaitUntilAsync(async () =>
            {
                var state = await cache.TryGetAsync<MessageOutboxRetryState>(StateCacheKey);
                return retryService.CallCount == 1 && state.HasValue;
            });

            await Task.Delay(TimeSpan.FromMilliseconds(200));

            Assert.Equal(1, retryService.CallCount);
        }
        finally
        {
            await sut.StopAsync(CancellationToken.None);
            sut.Dispose();
            CleanupTempDir(tempDir);
        }
    }

    [Fact]
    public async Task ExecuteAsync_ShouldRunOnce_WhenTwoWorkersStartTogether()
    {
        var cache = new FusionCache(new FusionCacheOptions());
        var retryService = new CountingRetryService(
            new MessageOutboxRetryResult(1, 0, 0, 0),
            TimeSpan.FromMilliseconds(150)
        );
        var tempDir = CreateTempDir();
        var lockProvider = new FileDistributedSynchronizationProvider(new DirectoryInfo(tempDir));
        var first = CreateService(retryService, cache, lockProvider);
        var second = CreateService(retryService, cache, lockProvider);

        try
        {
            await first.StartAsync(CancellationToken.None);
            await second.StartAsync(CancellationToken.None);

            await WaitUntilAsync(async () =>
            {
                var state = await cache.TryGetAsync<MessageOutboxRetryState>(StateCacheKey);
                return retryService.CallCount == 1 && state.HasValue;
            });

            await Task.Delay(TimeSpan.FromMilliseconds(300));

            Assert.Equal(1, retryService.CallCount);
        }
        finally
        {
            await first.StopAsync(CancellationToken.None);
            await second.StopAsync(CancellationToken.None);
            first.Dispose();
            second.Dispose();
            CleanupTempDir(tempDir);
        }
    }

    private static MessageOutboxRetryBackgroundService CreateService(
        IMessageOutboxRetryService retryService,
        IFusionCache cache,
        FileDistributedSynchronizationProvider lockProvider
    )
    {
        return new MessageOutboxRetryBackgroundService(
            retryService,
            cache,
            lockProvider,
            NullLogger<MessageOutboxRetryBackgroundService>.Instance
        );
    }

    private static string CreateTempDir()
    {
        var tempDir = Path.Combine(
            Path.GetTempPath(),
            "dpz.core.mq.retry.test",
            Guid.NewGuid().ToString("N")
        );
        Directory.CreateDirectory(tempDir);
        return tempDir;
    }

    private static async Task WaitUntilAsync(Func<Task<bool>> predicate)
    {
        using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
        while (!timeout.IsCancellationRequested)
        {
            if (await predicate())
            {
                return;
            }

            await Task.Delay(TimeSpan.FromMilliseconds(25), timeout.Token);
        }

        throw new TimeoutException("The expected background service state was not reached.");
    }

    private static void CleanupTempDir(string tempDir)
    {
        if (Directory.Exists(tempDir))
        {
            Directory.Delete(tempDir, true);
        }
    }

    private sealed class CountingRetryService(
        MessageOutboxRetryResult result,
        TimeSpan? delay = null
    ) : IMessageOutboxRetryService
    {
        private int _callCount;

        public int CallCount => _callCount;

        public Task<MessageOutboxRetryResult> RetryAsync(
            int batchSize,
            CancellationToken cancellationToken = default
        )
        {
            Interlocked.Increment(ref _callCount);
            if (delay.HasValue)
            {
                return DelayAndReturnAsync(delay.Value, result, cancellationToken);
            }

            return Task.FromResult(result);
        }

        private static async Task<MessageOutboxRetryResult> DelayAndReturnAsync(
            TimeSpan delay,
            MessageOutboxRetryResult result,
            CancellationToken cancellationToken
        )
        {
            await Task.Delay(delay, cancellationToken);
            return result;
        }
    }
}