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

namespace Dpz.Core.MessageQueue.RabbitMQ;

/// <summary>
/// Outbox 消息补发执行器，负责读取待重试记录并使用原始消息发布器重新投递。
/// </summary>
/// <param name="outboxStore">Outbox 存储接口。</param>
/// <param name="retryPublisher">绕过 Outbox 装饰器的原始消息发布器。</param>
/// <param name="logger">日志记录器。</param>
public sealed class MessageOutboxRetryService(
    IMessageOutboxStore outboxStore,
    IMessageOutboxRetryPublisher retryPublisher,
    ILogger<MessageOutboxRetryService> logger
) : IMessageOutboxRetryService
{
    /// <summary>
    /// 执行一轮 Outbox 补发，先处理发布失败消息，再处理消费失败消息。
    /// </summary>
    /// <param name="batchSize">本轮每类状态最多处理的消息数量。</param>
    /// <param name="cancellationToken">取消令牌。</param>
    /// <returns>本轮补发的处理结果。</returns>
    public async Task<MessageOutboxRetryResult> RetryAsync(
        int batchSize,
        CancellationToken cancellationToken = default
    )
    {
        var publishResult = await RetryPublishAsync(batchSize, cancellationToken);
        var consumeResult = await RetryConsumeAsync(batchSize, cancellationToken);

        return new MessageOutboxRetryResult(
            publishResult.TotalCount,
            publishResult.FailureCount,
            consumeResult.TotalCount,
            consumeResult.FailureCount
        );
    }

    private async Task<RetryCount> RetryPublishAsync(
        int batchSize,
        CancellationToken cancellationToken
    )
    {
        var entries = await outboxStore.GetPendingPublishRetryAsync(batchSize, cancellationToken);
        if (entries.Count == 0)
        {
            return RetryCount.Empty;
        }

        logger.LogInformation("Outbox 发布重试：共 {Count} 条", entries.Count);

        var failureCount = 0;
        foreach (var entry in entries)
        {
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                // 直接发布已持久化的 JSON 载荷，避免再次经过 Outbox 装饰器生成新记录。
                await retryPublisher.PublishRawAsync(
                    entry.Exchange,
                    entry.RoutingKey,
                    entry.MessageId,
                    entry.Payload,
                    cancellationToken
                );
                await outboxStore.MarkSentAsync(entry.MessageId, cancellationToken);
                logger.LogInformation(
                    "Outbox 发布重试成功: MessageId={MessageId}",
                    entry.MessageId
                );
            }
            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
            {
                throw;
            }
            catch (Exception ex)
            {
                failureCount++;
                logger.LogError(ex, "Outbox 发布重试失败: MessageId={MessageId}", entry.MessageId);
                await TryMarkPublishFailedAsync(entry.MessageId, ex.Message, cancellationToken);
            }
        }

        return new RetryCount(entries.Count, failureCount);
    }

    private async Task<RetryCount> RetryConsumeAsync(
        int batchSize,
        CancellationToken cancellationToken
    )
    {
        var entries = await outboxStore.GetPendingConsumeRetryAsync(batchSize, cancellationToken);
        if (entries.Count == 0)
        {
            return RetryCount.Empty;
        }

        logger.LogInformation("Outbox 消费重试：共 {Count} 条", entries.Count);

        var failureCount = 0;
        foreach (var entry in entries)
        {
            cancellationToken.ThrowIfCancellationRequested();

            try
            {
                // 消费失败的消息重新发布到原队列，由对应消费者按正常流程再次处理。
                await retryPublisher.PublishRawAsync(
                    entry.Exchange,
                    entry.RoutingKey,
                    entry.MessageId,
                    entry.Payload,
                    cancellationToken
                );
                await outboxStore.MarkSentAsync(entry.MessageId, cancellationToken);
                logger.LogInformation(
                    "Outbox 消费重试：消息已重新入队: MessageId={MessageId}",
                    entry.MessageId
                );
            }
            catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
            {
                throw;
            }
            catch (Exception ex)
            {
                failureCount++;
                logger.LogError(ex, "Outbox 消费重试失败: MessageId={MessageId}", entry.MessageId);
                await TryMarkConsumeFailedAsync(entry.MessageId, ex.Message, cancellationToken);
            }
        }

        return new RetryCount(entries.Count, failureCount);
    }

    private async Task TryMarkPublishFailedAsync(
        string messageId,
        string error,
        CancellationToken cancellationToken
    )
    {
        try
        {
            await outboxStore.MarkPublishFailedAsync(messageId, error, cancellationToken);
        }
        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
        {
            throw;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "更新Outbox发布失败状态失败: MessageId={MessageId}", messageId);
        }
    }

    private async Task TryMarkConsumeFailedAsync(
        string messageId,
        string error,
        CancellationToken cancellationToken
    )
    {
        try
        {
            await outboxStore.MarkConsumeFailedAsync(messageId, error, cancellationToken);
        }
        catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
        {
            throw;
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "更新Outbox消费失败状态失败: MessageId={MessageId}", messageId);
        }
    }

    private sealed record RetryCount(int TotalCount, int FailureCount)
    {
        public static RetryCount Empty { get; } = new(0, 0);
    }
}