using System.Text.Json;
using Dpz.Core.Entity.Base;
using Dpz.Core.MessageQueue.Abstractions;
using Microsoft.Extensions.Logging;

namespace Dpz.Core.MessageQueue.RabbitMQ;

public sealed class OutboxMessagePublisher<TMessage>(
    RabbitMQPublisher<TMessage> inner,
    IMessageOutboxStore outboxStore,
    IMessageRoutingConvention routingConvention,
    ILogger<OutboxMessagePublisher<TMessage>> logger
) : IMessagePublisher<TMessage>
    where TMessage : MessageBase
{
    private readonly string _exchangeName = routingConvention.GetExchangeName<TMessage>();
    private readonly string _defaultRoutingKey = routingConvention.GetRoutingKey<TMessage>();

    public async Task PublishAsync(
        TMessage message,
        string? routingKey = null,
        CancellationToken cancellationToken = default
    )
    {
        var actualRoutingKey = routingKey ?? _defaultRoutingKey;
        var payload = JsonSerializer.Serialize(message);

        await outboxStore.CreateAsync(
            message.MessageId,
            typeof(TMessage).FullName!,
            _exchangeName,
            actualRoutingKey,
            payload,
            message.Source,
            cancellationToken
        );

        try
        {
            await inner.PublishAsync(message, routingKey, cancellationToken);
            await outboxStore.MarkSentAsync(message.MessageId, cancellationToken);
        }
        catch (Exception ex)
        {
            logger.LogError(
                ex,
                "消息发布失败，已记录至Outbox: MessageId={MessageId}, Exchange={Exchange}",
                message.MessageId,
                _exchangeName
            );
            await outboxStore.MarkPublishFailedAsync(
                message.MessageId,
                ex.Message,
                cancellationToken
            );
            throw;
        }
    }

    public async Task PublishBatchAsync(
        IEnumerable<TMessage> messages,
        string? routingKey = null,
        CancellationToken cancellationToken = default
    )
    {
        var actualRoutingKey = routingKey ?? _defaultRoutingKey;
        var messageList = messages.ToList();

        foreach (var message in messageList)
        {
            var payload = JsonSerializer.Serialize(message);
            await outboxStore.CreateAsync(
                message.MessageId,
                typeof(TMessage).FullName!,
                _exchangeName,
                actualRoutingKey,
                payload,
                message.Source,
                cancellationToken
            );
        }

        try
        {
            await inner.PublishBatchAsync(messageList, routingKey, cancellationToken);
            foreach (var message in messageList)
            {
                await outboxStore.MarkSentAsync(message.MessageId, cancellationToken);
            }
        }
        catch (Exception ex)
        {
            logger.LogError(
                ex,
                "批量消息发布失败，已记录至Outbox: Count={Count}, Exchange={Exchange}",
                messageList.Count,
                _exchangeName
            );
            foreach (var message in messageList)
            {
                await outboxStore.MarkPublishFailedAsync(
                    message.MessageId,
                    ex.Message,
                    cancellationToken
                );
            }
            throw;
        }
    }
}