public class Payment
{
    public Guid Id { get; set; }
    public Guid OrderId { get; set; }
    public Order Order { get; set; } = null!;

    public decimal Amount { get; set; }
    public string Currency { get; set; } = "UAH";

    // Провайдер: "liqpay", "monobank", "stripe"
    public string Provider { get; set; } = null!;

    // ID транзакції на стороні PSP
    public string? ProviderTransactionId { get; set; }

    public PaymentStatus Status { get; set; }

    // Зберігаємо raw webhook payload для аудиту
    public string? LastWebhookPayload { get; set; }

    public DateTimeOffset CreatedAt { get; set; }
    public DateTimeOffset UpdatedAt { get; set; }

    // Ключ ідемпотентності
    public string IdempotencyKey { get; set; } = null!;
}

public enum PaymentStatus
{
    Created,      // Щойно створений, ще не відправлений до PSP
    Pending,      // Відправлений до PSP, очікуємо відповідь
    Authorized,   // Авторизований (кошти зарезервовані)
    Captured,     // Кошти захоплені (для провайдерів з preauth)
    Settled,      // Успішно розрахований
    Failed,       // Відхилений PSP або банком-емітентом
    Cancelled,    // Скасований до авторизації (void)
    Refunded,     // Повернений (повністю)
    PartiallyRefunded // Частково повернений
}

public static class PaymentStateMachine
{
    private static readonly Dictionary<PaymentStatus, HashSet<PaymentStatus>> _validTransitions = new()
    {
        [PaymentStatus.Created]    = [PaymentStatus.Pending],
        [PaymentStatus.Pending]    = [PaymentStatus.Authorized, PaymentStatus.Failed],
        [PaymentStatus.Authorized] = [PaymentStatus.Captured, PaymentStatus.Cancelled],
        [PaymentStatus.Captured]   = [PaymentStatus.Settled],
        [PaymentStatus.Settled]    = [PaymentStatus.Refunded, PaymentStatus.PartiallyRefunded],
        [PaymentStatus.PartiallyRefunded] = [PaymentStatus.Refunded],
    };

    public static bool CanTransition(PaymentStatus from, PaymentStatus to)
        => _validTransitions.TryGetValue(from, out var allowed) && allowed.Contains(to);

    public static void EnsureTransition(PaymentStatus from, PaymentStatus to)
    {
        if (!CanTransition(from, to))
            throw new InvalidOperationException(
                $"Invalid payment state transition: {from} → {to}");
    }
}

public async Task<Payment> CreatePaymentAsync(CreatePaymentRequest request)
{
    // Генеруємо або використовуємо переданий ключ
    var idempotencyKey = request.IdempotencyKey
        ?? $"order_{request.OrderId}_{Guid.NewGuid():N}";

    // Перевіряємо: чи вже існує платіж з цим ключем?
    var existing = await _db.Payments
        .FirstOrDefaultAsync(p => p.IdempotencyKey == idempotencyKey);

    if (existing is not null)
    {
        // Повертаємо існуючий платіж — ідемпотентна відповідь
        _logger.LogInformation(
            "Idempotent payment request detected. Returning existing payment {PaymentId}",
            existing.Id);
        return existing;
    }

    // Створюємо новий платіж
    var payment = new Payment
    {
        Id = Guid.NewGuid(),
        OrderId = request.OrderId,
        Amount = request.Amount,
        IdempotencyKey = idempotencyKey,
        Status = PaymentStatus.Created,
        CreatedAt = DateTimeOffset.UtcNow
    };

    _db.Payments.Add(payment);
    await _db.SaveChangesAsync();

    return payment;
}

public interface IPaymentProvider
{
    // Унікальна назва провайдера: "liqpay", "monobank", "stripe"
    string ProviderName { get; }

    /// <summary>
    /// Ініціює платіж. Повертає URL для redirect або токен форми.
    /// </summary>
    Task<CreatePaymentResult> CreatePaymentAsync(
        PaymentRequest request,
        CancellationToken ct = default);

    /// <summary>
    /// Перевіряє поточний статус транзакції на стороні PSP.
    /// </summary>
    Task<PaymentStatusResult> GetPaymentStatusAsync(
        string providerTransactionId,
        CancellationToken ct = default);

    /// <summary>
    /// Ініціює повернення коштів (повне або часткове).
    /// </summary>
    Task<RefundResult> RefundAsync(
        string providerTransactionId,
        decimal amount,
        CancellationToken ct = default);

    /// <summary>
    /// Верифікує підпис вхідного webhook та парсить payload.
    /// </summary>
    Task<WebhookResult> ProcessWebhookAsync(
        HttpRequest request,
        CancellationToken ct = default);
}

public record PaymentRequest(
    Guid PaymentId,
    decimal Amount,
    string Currency,
    string Description,
    string ReturnUrl,
    string CallbackUrl,
    string IdempotencyKey
);

public record CreatePaymentResult(
    bool Success,
    string? CheckoutUrl,    // Redirect URL для Hosted Page
    string? FormData,       // Base64 data для embedded форми (LiqPay)
    string? ProviderPaymentId,
    string? ErrorMessage
);

public record PaymentStatusResult(
    bool Success,
    PaymentStatus Status,
    string? ProviderTransactionId,
    string? ErrorMessage
);

public record RefundResult(
    bool Success,
    string? RefundId,
    string? ErrorMessage
);

public record WebhookResult(
    bool IsValid,
    PaymentStatus? NewStatus,
    string? ProviderTransactionId,
    string? ErrorMessage,
    object? RawPayload
);

public static IServiceCollection AddPaymentProviders(
    this IServiceCollection services,
    IConfiguration configuration)
{
    services.AddScoped<LiqPayPaymentProvider>();
    services.AddScoped<MonobankPaymentProvider>();
    services.AddScoped<StripePaymentProvider>();

    // Фабрика провайдерів: вибір за назвою
    services.AddScoped<IPaymentProviderFactory, PaymentProviderFactory>();

    return services;
}

public interface IPaymentProviderFactory
{
    IPaymentProvider GetProvider(string providerName);
}

public class PaymentProviderFactory : IPaymentProviderFactory
{
    private readonly IServiceProvider _serviceProvider;

    public PaymentProviderFactory(IServiceProvider serviceProvider)
        => _serviceProvider = serviceProvider;

    public IPaymentProvider GetProvider(string providerName) =>
        providerName switch
        {
            "liqpay"   => _serviceProvider.GetRequiredService<LiqPayPaymentProvider>(),
            "monobank" => _serviceProvider.GetRequiredService<MonobankPaymentProvider>(),
            "stripe"   => _serviceProvider.GetRequiredService<StripePaymentProvider>(),
            _ => throw new NotSupportedException($"Unknown payment provider: {providerName}")
        };
}

public class PaymentService
{
    private readonly IPaymentProviderFactory _providerFactory;
    private readonly AppDbContext _db;

    public async Task<string> InitiatePaymentAsync(Guid paymentId, string providerName)
    {
        var payment = await _db.Payments.FindAsync(paymentId)
            ?? throw new NotFoundException($"Payment {paymentId} not found");

        // Вибір провайдера без if/switch у бізнес-логіці
        var provider = _providerFactory.GetProvider(providerName);

        var request = new PaymentRequest(
            PaymentId: payment.Id,
            Amount: payment.Amount,
            Currency: payment.Currency,
            Description: $"Замовлення #{payment.OrderId}",
            ReturnUrl: "https://myapp.com/payment/result",
            CallbackUrl: "https://myapp.com/webhooks/payment",
            IdempotencyKey: payment.IdempotencyKey
        );

        var result = await provider.CreatePaymentAsync(request);

        if (!result.Success)
            throw new PaymentException(result.ErrorMessage);

        // Оновлюємо статус та зберігаємо ID від PSP
        payment.Status = PaymentStatus.Pending;
        payment.Provider = providerName;
        payment.ProviderTransactionId = result.ProviderPaymentId;
        payment.UpdatedAt = DateTimeOffset.UtcNow;

        PaymentStateMachine.EnsureTransition(PaymentStatus.Created, PaymentStatus.Pending);
        await _db.SaveChangesAsync();

        return result.CheckoutUrl!;
    }
}