Configuration

import SwiftUI
import PXPCheckoutSDK

let config = CheckoutDropInConfig(
    // REQUIRED
    environment: .test,
    session: sessionData,
    transactionData: DropInTransactionData(
        amount: Decimal(string: "99.99") ?? 0,
        currency: "USD",
        entryType: .ecom,
        intent: DropInTransactionIntentData(
            card: .authorisation,
            paypal: .purchase,
            aeropay: .authorisation
        ),
        merchantTransactionId: UUID().uuidString,
        merchantTransactionDate: { Date() }
    ),
    merchantShopperId: "shopper-123",
    ownerId: "MERCHANT_GROUP_1", // Merchant group ID from Unity Portal
    
    // OPTIONAL: Fraud detection
    kountDisabled: false,
    
    // Recommended: always implement success and error handlers
    onSuccess: { result in
        // Handle success
    },
    onError: { paymentMethod, error in
        // Handle error
    },
    
    // Optional callbacks
    onGetShippingAddress: {
        // Return ShippingAddress? for billing prefill / PayPal setProvidedAddress
        nil
    },
    onGetShopper: {
        TransactionShopper(id: "shopper-123")
    },
    onBeforeSubmit: { paymentMethod async in
        // Return true to proceed
        return true
    },
    onSubmit: { paymentMethod in
        // Payment started (card, Apple Pay, and Aeropay; not PayPal)
    },
    analyticsEvent: { event in
        // Track analytics
    }
)

// Initialise and create Drop-in
let dropIn = try CheckoutDropIn(config: config)
await dropIn.create()

// Render in SwiftUI
dropIn.buildContent()

environment: .test // or .live

// Backend endpoint
let sessionData = try await fetchSessionFromBackend()

// Pass to Drop-in
session: sessionData

merchantShopperId: "shopper-123",        // Required — your shopper identifier
ownerId: "MERCHANT_GROUP_1"              // Required — merchant group ID from the Unity Portal

transactionData: DropInTransactionData(
    amount: Decimal(string: "99.99") ?? 0,
    currency: "USD",
    entryType: .ecom,
    intent: DropInTransactionIntentData(
        card: .authorisation,
        paypal: .purchase,
        aeropay: .authorisation
    ),
    merchantTransactionId: UUID().uuidString,
    merchantTransactionDate: { Date() }
)

merchantTransactionId: UUID().uuidString

// Or use your own format
merchantTransactionId: "order-\(orderId)"

CheckoutDropInConfig(
    // OPTIONAL: Get shopper information
    onGetShopper: {
        TransactionShopper(id: "shopper-123")
    },
    
    // Recommended: called when payment succeeds
    onSuccess: { result in
        print("Payment successful: \(result.systemTransactionId)")
        // CRITICAL: Always verify on backend before fulfilling the order
        verifyPaymentOnBackend(result)
    },
    
    // Recommended: called when payment fails
    onError: { paymentMethod, error in
        print("Payment failed: \(error.errorCode) - \(error.errorMessage)")
    },
    
    // OPTIONAL: Called before payment submission
    onBeforeSubmit: { paymentMethod async in
        print("Payment method: \(paymentMethod.rawValue)")
        // Return true to proceed. Return false to block submission without calling onCancel or onError.
        return true
    },
    
    // OPTIONAL: Called when payment starts processing (card, Apple Pay, and Aeropay)
    onSubmit: { paymentMethod in
        print("Processing payment...")
    }
)

onGetShippingAddress: {
    ShippingAddress(
        // Populate from your checkout form / order record
        countryCode: "GB",
        postalCode: "NW1 6XE",
        address: "221B Baker Street",
        city: "London"
    )
}

analyticsEvent: { event in
    print("Event: \(event.eventName)")
    // Send to your analytics platform
    sendToFirebaseAnalytics(event)
}

methodConfig: DropInMethodConfig(
    global: DropInGlobalConfig(
        acceptedCardNetworks: [.visa, .mastercard, .amex],
        allowedIssuerCountryCodes: ["US", "GB"],
        transactionInfo: DropInTransactionInfo(
            countryCode: "US",
            totalLabel: "Total"
        ),
        riskScreeningData: RiskScreeningData(
            performRiskScreening: true,
            userIp: "203.0.113.10",
            transaction: RiskScreeningTransaction(subtotal: 149.99)
        )
    ),
    card: DropInCardConfig(
        showCOF: true,
        showNewCard: true
    ),
    paypal: DropInPaypalConfig(
        fundingSources: [.paypal, .paylater],
        shippingPreference: .getFromFile
    ),
    applePay: DropInApplePayConfig(
        shippingContactConfiguration: DropInApplePayShippingContactConfiguration(
            requireShippingContactFields: [.postalAddress, .name]
        )
    ),
    aeropay: DropInAeropayConfig(
        // userId: "existing-aeropay-user-id",
        // skipConsumerDataCollection: true, // all four onGetShopper fields required and valid (phone +1 + 10 digits); editable fields nil/empty
        // editableConsumerDataFields: [.email],
        // excludedBankAccountIds: ["12345"]
    )
)

// Localisation has no default implementations. Copy DefaultLocalisation (or wrap it and
// forward every property), then override the Drop-in keys you need.
struct MyDropInLocalisation: Localisation {
    private let base = DefaultLocalisation()

    var submitText: String? { "Pay Now" }
    var checkoutDropInHeaderText: String? { "Choose Payment Method" }
    var checkoutDropInAeropayLabel: String? { "Pay by bank via Aeropay" }

    var cardConsentLabel: String? { base.cardConsentLabel }
    // Forward every other Localisation requirement to `base` the same way.
    // A type that declares only a few properties will not compile.
}

// Pass to Drop-in config
localisation: MyDropInLocalisation()

locale: "en-US" // or "es-ES", "el-GR"

restrictions: Restrictions(
    card: Restrictions.Card(
        ownerTypes: [.consumer],       // Consumer cards only
        fundingSources: [.credit, .debit]  // Exclude prepaid
    )
)

kountDisabled: false // Set to true to disable Kount

methodConfig: DropInMethodConfig(
    global: DropInGlobalConfig(
        riskScreeningData: RiskScreeningData(
            performRiskScreening: true,
            userIp: "203.0.113.10",
            transaction: RiskScreeningTransaction(subtotal: 149.99)
        )
    )
)

import SwiftUI
import PXPCheckoutSDK

// Get session from backend
let sessionData = try await fetchSessionFromBackend()

let config = CheckoutDropInConfig(
    environment: .test,
    session: sessionData,
    transactionData: DropInTransactionData(
        amount: Decimal(string: "99.99") ?? 0,
        currency: "USD",
        entryType: .ecom,
        intent: DropInTransactionIntentData(
            card: .authorisation,
            paypal: .purchase,
            aeropay: .authorisation
        ),
        merchantTransactionId: UUID().uuidString,
        merchantTransactionDate: { Date() }
    ),
    merchantShopperId: "shopper-123",
    ownerId: "MERCHANT_GROUP_1", // Merchant group ID from Unity Portal
    onGetShopper: {
        TransactionShopper(id: "shopper-123")
    },
    onSuccess: { result in
        Task {
            await verifyPaymentOnBackend(result)
        }
    },
    onError: { paymentMethod, error in
        print("Payment failed: \(error.errorMessage)")
    }
)

let dropIn = try CheckoutDropIn(config: config)
await dropIn.create()

import SwiftUI
import PXPCheckoutSDK

let sessionData = try await fetchSessionFromBackend()
let orderId = "order-12345"

let config = CheckoutDropInConfig(
    // REQUIRED
    environment: .live,
    session: sessionData,
    transactionData: DropInTransactionData(
        amount: Decimal(string: "149.99") ?? 0,
        currency: "USD",
        entryType: .ecom,
        intent: DropInTransactionIntentData(
            card: .authorisation,
            paypal: .purchase,
            aeropay: .authorisation
        ),
        merchantTransactionId: "order-\(orderId)",
        merchantTransactionDate: { Date() }
    ),
    merchantShopperId: "shopper-456",
    ownerId: "MERCHANT_GROUP_1", // Merchant group ID from Unity Portal
    locale: "en-US",
    kountDisabled: false,

    // CALLBACKS
    onGetShippingAddress: {
        ShippingAddress(
            countryCode: "US",
            postalCode: "10001",
            address: "123 Main St",
            city: "New York",
            state: "NY"
        )
    },

    onGetShopper: {
        TransactionShopper(
            id: "shopper-456",
            email: "customer@example.com"
        )
    },

    onBeforeSubmit: { paymentMethod async in
        print("Payment method selected: \(paymentMethod.rawValue)")

        // Custom validation — return false to block submission (does not call onCancel or onError)
        guard await validateOrder(orderId) else {
            return false
        }
        guard await checkInventory(orderId) else {
            return false
        }
        return true
    },

    onSubmit: { paymentMethod in
        // Card, Apple Pay, and Aeropay — PayPal does not call onSubmit
        print("Payment processing started for: \(paymentMethod.rawValue)")
        showLoadingIndicator()
    },

    onSuccess: { result in
        hideLoadingIndicator()

        // CRITICAL: Verify on backend before fulfilling the order
        Task {
            do {
                let verified = try await verifyPaymentOnBackend(
                    systemTransactionId: result.systemTransactionId,
                    merchantTransactionId: result.merchantTransactionId ?? "",
                    orderId: orderId
                )
                if verified.success {
                    navigateToOrderConfirmation(orderId: verified.orderId)
                } else {
                    showError("Payment verification failed. Please contact support.")
                }
            } catch {
                showError("Unable to verify payment. Please contact support.")
            }
        }
    },

    onError: { paymentMethod, error in
        hideLoadingIndicator()

        let userMessage: String
        switch error.errorCode {
        case "SDK1114":
            userMessage = "Authentication failed. Please try again or use a different card."
        case "SDK0500":
            userMessage = "Connection error. Check your internet connection."
        case "SDK1116":
            // Generic card-payment failure when no more specific code was preserved
            userMessage = "Card payment failed. Please try another payment method."
        case "SDK0113", "SDK0115", "SDK1125":
            userMessage = "Pay by Bank is unavailable. Please choose another payment method."
        case "SDK1126":
            userMessage = "Pay by Bank payment failed. Please try again."
        default:
            if error.errorMessage.localizedCaseInsensitiveContains("session") ||
               error.errorMessage.localizedCaseInsensitiveContains("expired") {
                userMessage = "Session expired. Please refresh checkout."
            } else {
                userMessage = "Payment failed: \(error.errorMessage)"
            }
        }
        showError(userMessage)
    },

    analyticsEvent: { event in
        print("Analytics: \(event.eventName)")
        sendToAnalyticsPlatform(event)
    }
)

let dropIn = try CheckoutDropIn(config: config)
await dropIn.create()