public class ProcessedWebhook
{
    public Guid Id { get; set; }

    // Унікальний ідентифікатор webhook від PSP
    // Для LiqPay: transaction_id
    // Для Monobank: invoiceId + status
    // Для Stripe: event.Id
    public string EventId { get; set; } = null!;

    public string Provider { get; set; } = null!;
    public DateTimeOffset ProcessedAt { get; set; }
}

public class WebhookIdempotencyService
{
    private readonly AppDbContext _db;

    public WebhookIdempotencyService(AppDbContext db) => _db = db;

    /// <summary>
    /// Повертає true, якщо webhook вже оброблено. Інакше — записує та повертає false.
    /// </summary>
    public async Task<bool> IsAlreadyProcessedAsync(
        string eventId, string provider, CancellationToken ct = default)
    {
        // Атомарна операція: INSERT OR IGNORE
        var exists = await _db.ProcessedWebhooks
            .AnyAsync(w => w.EventId == eventId && w.Provider == provider, ct);

        if (exists) return true;

        _db.ProcessedWebhooks.Add(new ProcessedWebhook
        {
            Id = Guid.NewGuid(),
            EventId = eventId,
            Provider = provider,
            ProcessedAt = DateTimeOffset.UtcNow
        });

        await _db.SaveChangesAsync(ct);
        return false;
    }
}

public record WebhookEvent(
    string Provider,
    string EventId,
    string RawPayload,
    DateTimeOffset ReceivedAt
);

public class WebhookChannel
{
    private readonly Channel<WebhookEvent> _channel =
        Channel.CreateBounded<WebhookEvent>(new BoundedChannelOptions(100)
        {
            FullMode = BoundedChannelFullMode.Wait
        });

    public ChannelWriter<WebhookEvent> Writer => _channel.Writer;
    public ChannelReader<WebhookEvent> Reader => _channel.Reader;
}

public class WebhookProcessorService : BackgroundService
{
    private readonly WebhookChannel _channel;
    private readonly IServiceProvider _services;
    private readonly ILogger<WebhookProcessorService> _logger;

    public WebhookProcessorService(
        WebhookChannel channel,
        IServiceProvider services,
        ILogger<WebhookProcessorService> logger)
    {
        _channel = channel;
        _services = services;
        _logger = logger;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        await foreach (var evt in _channel.Reader.ReadAllAsync(stoppingToken))
        {
            try
            {
                await using var scope = _services.CreateAsyncScope();
                var paymentService = scope.ServiceProvider
                    .GetRequiredService<PaymentService>();

                await paymentService.ProcessWebhookEventAsync(evt);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "Error processing webhook event {EventId} from {Provider}",
                    evt.EventId, evt.Provider);
                // Не перекидуємо — продовжуємо читати з Channel
            }
        }
    }
}

builder.Services.AddSingleton<WebhookChannel>();
builder.Services.AddHostedService<WebhookProcessorService>();

private static async Task<IResult> HandleLiqPayWebhook(
    HttpRequest request,
    WebhookChannel channel,
    IOptions<LiqPayOptions> options,
    ILogger<Program> logger,
    CancellationToken ct)
{
    var form = await request.ReadFormAsync(ct);
    var data = form["data"].ToString();
    var signature = form["signature"].ToString();

    if (!LiqPaySignatureHelper.VerifySignature(data, signature, options.Value.PrivateKey))
    {
        logger.LogWarning("Invalid LiqPay webhook signature");
        return Results.Ok(); // Не 400 — щоб LiqPay не retry
    }

    // Публікуємо подію → Background Service обробить
    await channel.Writer.WriteAsync(new WebhookEvent(
        Provider: "liqpay",
        EventId: data, // тимчасово data як ID; краще — transaction_id після decode
        RawPayload: data,
        ReceivedAt: DateTimeOffset.UtcNow
    ), ct);

    // Відповідаємо негайно — важка логіка відбудеться асинхронно
    return Results.Ok();
}

[Fact]
public async Task LiqPay_Webhook_Should_Update_Payment_Status()
{
    var factory = new WebApplicationFactory<Program>();
    var client = factory.CreateClient();

    // Формуємо валідний LiqPay webhook payload
    var payload = new { order_id = "test-payment-id", status = "success" };
    var data = LiqPaySignatureHelper.EncodeData(payload);
    var signature = LiqPaySignatureHelper.GenerateSignature(data, "test_private_key");

    var content = new FormUrlEncodedContent([
        new("data", data),
        new("signature", signature)
    ]);

    var response = await client.PostAsync("/webhooks/liqpay", content);

    response.StatusCode.Should().Be(HttpStatusCode.OK);
    // Перевіряємо, що статус платежу у БД оновився
}