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: .authorisation
        ),
        merchantTransactionId: UUID().uuidString,
        merchantTransactionDate: { Date() }
    ),
    merchantShopperId: "shopper-123",
    ownerId: "MERCHANT-1",
    
    // 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
    onGetShopper: { async in
        TransactionShopper(id: "shopper-123")
    },
    onBeforeSubmit: { paymentMethod in
        // Return true to proceed
        return true
    },
    onSubmit: { paymentMethod in
        // Payment started
    },
    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-1"              // Required — merchant ID from the Unity Portal

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

merchantTransactionId: UUID().uuidString

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

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

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)
        )
    ),
    paypal: DropInPaypalConfig(
        fundingSources: [.paypal, .paylater],
        shippingPreference: .getFromFile
    ),
    applePay: DropInApplePayConfig(
        shippingContactConfiguration: DropInApplePayShippingContactConfiguration(
            requireShippingContactFields: [.postalAddress, .name]
        )
    ),
    paze: DropInPazeConfig(
        emailAddress: "customer@example.com",
        phoneNumber: "15551234567"
    )
)

// Implement a custom localisation type conforming to Localisation protocol
struct MyDropInLocalisation: Localisation {
    var submitText: String? { "Pay Now" }
    var checkoutDropInHeaderText: String? { "Choose Payment Method" }
    var checkoutDropInCardLabel: String? { "Credit or Debit Card" }
    var checkoutDropInPaypalLabel: String? { "PayPal" }
    var checkoutDropInApplePayLabel: String? { "Apple Pay" }
    // ... implement other required protocol properties
}

// 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: .authorisation
        ),
        merchantTransactionId: UUID().uuidString,
        merchantTransactionDate: { Date() }
    ),
    merchantShopperId: "shopper-123",
    ownerId: "MERCHANT-1",
    onGetShopper: { async in
        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
        ),
        merchantTransactionId: "order-\(orderId)",
        merchantTransactionDate: { Date() }
    ),
    merchantShopperId: "shopper-456",
    ownerId: "MERCHANT-1",
    locale: "en-US",
    kountDisabled: false,

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

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

        // Custom validation — return false to cancel payment
        guard await validateOrder(orderId) else {
            return false
        }
        guard await checkInventory(orderId) else {
            return false
        }
        return true
    },

    onSubmit: { paymentMethod in
        print("Payment processing started for: \(paymentMethod.rawValue)")
        showLoadingIndicator()
    },

    onSuccess: { result in
        hideLoadingIndicator()

        // CRITICAL: Verify on backend before fulfilling
        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 "SDK1116" where error.errorMessage.localizedCaseInsensitiveContains("declined"):
            userMessage = "Card declined. Please try a different card."
        case "SDK1116" where error.errorMessage.localizedCaseInsensitiveContains("insufficient"):
            userMessage = "Insufficient funds."
        case "SDK1114":
            userMessage = "Card verification failed."
        case "SDK0500":
            userMessage = "Connection error. Check your internet connection."
        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()