{
  "Stripe": {
    "SecretKey": "sk_test_...",
    "PublishableKey": "pk_test_...",
    "WebhookSecret": "whsec_...",
    "Currency": "uah"
  }
}

public class StripeOptions
{
    public string SecretKey { get; set; } = null!;
    public string PublishableKey { get; set; } = null!;
    public string WebhookSecret { get; set; } = null!;
    public string Currency { get; set; } = "uah";
}

// Stripe SDK ініціалізація через глобальний клас
builder.Services.Configure<StripeOptions>(
    builder.Configuration.GetSection("Stripe"));

builder.Services.AddScoped<StripePaymentProvider>(sp =>
{
    var opts = sp.GetRequiredService<IOptions<StripeOptions>>().Value;
    StripeConfiguration.ApiKey = opts.SecretKey;
    return new StripePaymentProvider(opts);
});

using Stripe;
using Stripe.Checkout;

public class StripePaymentProvider : IPaymentProvider
{
    private readonly StripeOptions _options;

    public string ProviderName => "stripe";

    public StripePaymentProvider(StripeOptions options)
        => _options = options;

    public async Task<CreatePaymentResult> CreatePaymentAsync(
        PaymentRequest request,
        CancellationToken ct = default)
    {
        // Stripe Checkout Session — найпростіший hosted flow
        var sessionOptions = new SessionCreateOptions
        {
            PaymentMethodTypes = ["card"],
            LineItems =
            [
                new SessionLineItemOptions
                {
                    PriceData = new SessionLineItemPriceDataOptions
                    {
                        UnitAmount = (long)(request.Amount * 100), // Копійки/центи
                        Currency = request.Currency.ToLower(),
                        ProductData = new SessionLineItemPriceDataProductDataOptions
                        {
                            Name = request.Description
                        }
                    },
                    Quantity = 1
                }
            ],
            Mode = "payment",
            SuccessUrl = request.ReturnUrl + "?session_id={CHECKOUT_SESSION_ID}",
            CancelUrl = request.ReturnUrl + "?cancelled=true",

            // Ключ ідемпотентності для уникнення дублювання
            ClientReferenceId = request.IdempotencyKey
        };

        var service = new SessionService();
        var session = await service.CreateAsync(sessionOptions,
            requestOptions: new RequestOptions
            {
                IdempotencyKey = request.IdempotencyKey
            },
            cancellationToken: ct);

        return new CreatePaymentResult(
            Success: true,
            CheckoutUrl: session.Url,            // Redirect на stripe.com/checkout
            FormData: session.Id,               // Session ID для перевірки статусу
            ProviderPaymentId: session.Id,
            ErrorMessage: null
        );
    }

    public async Task<PaymentStatusResult> GetPaymentStatusAsync(
        string providerTransactionId,
        CancellationToken ct = default)
    {
        var service = new SessionService();
        var session = await service.GetAsync(providerTransactionId,
            cancellationToken: ct);

        return new PaymentStatusResult(
            Success: true,
            Status: MapStripeStatus(session.PaymentStatus),
            ProviderTransactionId: session.PaymentIntentId,
            ErrorMessage: null
        );
    }

    public async Task<RefundResult> RefundAsync(
        string providerTransactionId,
        decimal amount,
        CancellationToken ct = default)
    {
        // providerTransactionId = PaymentIntent ID (pi_...)
        var refundOptions = new RefundCreateOptions
        {
            PaymentIntent = providerTransactionId,
            Amount = (long)(amount * 100)
        };

        var service = new RefundService();
        var refund = await service.CreateAsync(refundOptions, cancellationToken: ct);

        return refund.Status == "succeeded"
            ? new RefundResult(true, refund.Id, null)
            : new RefundResult(false, null, refund.FailureReason);
    }

    public Task<WebhookResult> ProcessWebhookAsync(
        HttpRequest httpRequest,
        CancellationToken ct = default)
        => throw new NotSupportedException("Use WebhookEndpoints for Stripe webhook");

    private static PaymentStatus MapStripeStatus(string? status) =>
        status switch
        {
            "paid"       => PaymentStatus.Settled,
            "unpaid"     => PaymentStatus.Pending,
            "no_payment_required" => PaymentStatus.Settled,
            _ => PaymentStatus.Pending
        };
}

// Додайте до MapWebhookEndpoints:
app.MapPost("/webhooks/stripe", HandleStripeWebhook)
    .WithTags("Webhooks");

private static async Task<IResult> HandleStripeWebhook(
    HttpRequest request,
    IOptions<StripeOptions> options,
    PaymentService paymentService,
    ILogger<Program> logger,
    CancellationToken ct)
{
    // Зчитуємо сире тіло (необхідно до будь-якої обробки)
    var body = await new StreamReader(request.Body).ReadToEndAsync(ct);
    var stripeSignature = request.Headers["Stripe-Signature"].ToString();

    // Stripe SDK верифікує підпис та парсить event — одна строчка!
    Event stripeEvent;
    try
    {
        stripeEvent = EventUtility.ConstructEvent(
            body, stripeSignature, options.Value.WebhookSecret);
    }
    catch (StripeException ex)
    {
        logger.LogWarning("Stripe webhook signature verification failed: {Error}", ex.Message);
        return Results.BadRequest("Invalid signature");
    }

    logger.LogInformation("Stripe webhook event: {Type}", stripeEvent.Type);

    // Обробляємо конкретні типи подій
    switch (stripeEvent.Type)
    {
        case Events.CheckoutSessionCompleted:
        {
            var session = stripeEvent.Data.Object as Session;
            if (session?.PaymentStatus == "paid")
            {
                await paymentService.UpdatePaymentByProviderIdAsync(
                    providerTransactionId: session.Id,
                    newStatus: PaymentStatus.Settled,
                    rawPayload: body);
            }
            break;
        }

        case Events.PaymentIntentPaymentFailed:
        {
            var pi = stripeEvent.Data.Object as PaymentIntent;
            if (pi is not null)
            {
                await paymentService.UpdatePaymentByProviderIdAsync(
                    providerTransactionId: pi.Id,
                    newStatus: PaymentStatus.Failed,
                    rawPayload: body);
            }
            break;
        }

        case Events.ChargeRefunded:
        {
            var charge = stripeEvent.Data.Object as Charge;
            if (charge is not null)
            {
                await paymentService.UpdatePaymentByProviderIdAsync(
                    providerTransactionId: charge.PaymentIntentId,
                    newStatus: PaymentStatus.Refunded,
                    rawPayload: body);
            }
            break;
        }
    }

    return Results.Ok();
}