Troubleshooting

import PXPCheckoutSDK
import UIKit
import Network

// Drop-in diagnostic helper
func diagnoseDropIn(
    sessionData: SessionData?,
    config: CheckoutDropInConfig
) {
    print("=== Checkout Drop-in diagnostics ===")
    
    // Check SDK import
    print("SDK imported: \(CheckoutDropIn.self)")
    
    // Check session data
    // Required for init: non-empty sessionId and hmacKey (empty → SDK0103 / SDK0104 throws).
    // encryptionKey is needed for card secured fields; empty may not throw at init.
    print("Session ID: \((sessionData?.sessionId.isEmpty == false) ? "Present" : "Missing")")
    print("HMAC key: \((sessionData?.hmacKey.isEmpty == false) ? "Present" : "Missing")")
    print("Encryption key: \((sessionData?.encryptionKey.isEmpty == false) ? "Present" : "Missing")")
    if let sessionExpiry = sessionData?.sessionExpiry {
        print("Session expiry: \(sessionExpiry)")
    }
    if let restrictions = sessionData?.restrictions {
        print("Restrictions: \(String(describing: restrictions))")
    }
    print("Allowed funding types: \(String(describing: sessionData?.allowedFundingTypes))")
    
    // Check environment
    print("Environment: \(config.environment)")
    print("Owner ID: \(config.ownerId)")
    print("Merchant Shopper ID: \(config.merchantShopperId)")
    
    // Check device info
    print("iOS version: \(UIDevice.current.systemVersion)")
    print("Device: \(UIDevice.current.model)")
    print("Screen scale: \(UIScreen.main.scale)")
    
    // Check network connectivity
    let monitor = NWPathMonitor()
    let queue = DispatchQueue(label: "NetworkMonitor")
    monitor.pathUpdateHandler = { path in
        print("Network available: \(path.status == .satisfied)")
    }
    monitor.start(queue: queue)
    
    print("===================================")
}

import SwiftUI
import PXPCheckoutSDK

struct DiagnoseRenderingIssueView: View {
    @StateObject private var viewModel = DiagnosticViewModel()
    
    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 8) {
                Text(viewModel.diagnostics)
                    .font(.system(.caption, design: .monospaced))
                
                if let dropIn = viewModel.dropIn {
                    dropIn.buildContent()
                } else {
                    ProgressView("Loading...")
                }
            }
            .padding()
        }
        .task {
            await viewModel.diagnose()
        }
    }
}

@MainActor
final class DiagnosticViewModel: ObservableObject {
    @Published var dropIn: CheckoutDropIn?
    @Published var diagnostics: String = ""
    private var isCreatingDropIn = false
    private var createFailed = false
    
    func diagnose() async {
        diagnostics += "Step 1: Fetching session...\n"
        
        do {
            let sessionData = try await fetchSessionFromBackend()
            diagnostics += "Step 2: Session fetched successfully\n"
            diagnostics += "Session ID: \(sessionData.sessionId)\n"
            
            // Step 3: Validate session data
            diagnostics += "Step 3: Validating session data...\n"
            
            if sessionData.sessionId.isEmpty {
                diagnostics += "ERROR: Session ID missing\n"
            } else {
                diagnostics += "Session ID present\n"
            }
            
            if sessionData.allowedFundingTypes == nil {
                diagnostics += "ERROR: No allowed funding types\n"
            } else {
                var paymentMethodCount = 0
                
                // Cards: Drop-in requires the cards key (empty array is valid).
                // cardSchemes alone does not enable the card panel.
                if sessionData.allowedFundingTypes?.cards != nil {
                    paymentMethodCount += 1
                    diagnostics += "Cards key present\n"
                } else if sessionData.allowedFundingTypes?.cardSchemes != nil {
                    diagnostics += "WARNING: cardSchemes is set but does not enable the Card panel (cards key missing)\n"
                }
                
                // PayPal: must have allowedFundingOptions present and non-empty
                if let paypalConfig = sessionData.allowedFundingTypes?.wallets?.paypal,
                   let allowedFundingOptions = paypalConfig.allowedFundingOptions,
                   !allowedFundingOptions.isEmpty {
                    paymentMethodCount += 1
                }
                
                // Apple Pay: must have merchantId present and non-empty
                if let applePayConfig = sessionData.allowedFundingTypes?.wallets?.applePay,
                   let merchantId = applePayConfig.merchantId,
                   !merchantId.isEmpty {
                    paymentMethodCount += 1
                }
                
                // Aeropay: funding object present (credentials validated at create)
                if sessionData.allowedFundingTypes?.payByBanks?.aeropay != nil {
                    paymentMethodCount += 1
                }
                
                if paymentMethodCount == 0 {
                    diagnostics += "ERROR: No payment methods enabled in session (SDK0204 risk)\n"
                } else {
                    diagnostics += "\(paymentMethodCount) payment method(s) available from session checks\n"
                    diagnostics += "Note: session checks alone can still produce SDK0204 if card display config hides Card and no wallets render\n"
                }
            }
            
            // Card display overrides (defaults true when omitted)
            let showCOF = true
            let showNewCard = true
            diagnostics += "showCOF=\(showCOF) showNewCard=\(showNewCard)\n"
            if !showCOF && !showNewCard {
                diagnostics += "WARNING: Both showCOF and showNewCard are false — Card panel hidden even if session.cards is present\n"
            }
            
            // Initialise Drop-in
            isCreatingDropIn = true
            createFailed = false
            let config = CheckoutDropInConfig(
                environment: .test,
                session: sessionData,
                transactionData: DropInTransactionData(
                    amount: Decimal(string: "1.00") ?? 0,
                    currency: "USD",
                    entryType: .ecom,
                    intent: DropInTransactionIntentData(
                        card: .authorisation
                    ),
                    merchantTransactionId: "test-\(Date().timeIntervalSince1970)",
                    merchantTransactionDate: { Date() }
                ),
                merchantShopperId: "shopper-123",
                ownerId: "MERCHANT_GROUP_1", // Merchant group ID (ownerType is always "MerchantGroup")
                methodConfig: DropInMethodConfig(
                    card: DropInCardConfig(showCOF: showCOF, showNewCard: showNewCard)
                ),
                onSuccess: { result in
                    print("Success: \(result.systemTransactionId)")
                },
                onError: { paymentMethod, error in
                    if isCreatingDropIn {
                        createFailed = true
                    }
                    diagnostics += "onError: \(error.errorCode): \(error.errorMessage)\n"
                    print("Error: \(error.errorMessage)")
                }
            )
            
            let instance = try CheckoutDropIn(config: config)
            // Create-time failures (including SDK1100 and method setup errors) are delivered
            // through onError, not thrown from create().
            await instance.create()
            isCreatingDropIn = false
            if !createFailed {
                dropIn = instance
            } else {
                diagnostics += "create() finished but Drop-in did not mount. See onError above.\n"
            }
            
        } catch {
            diagnostics += "ERROR: \(error.localizedDescription)\n"
            print("Diagnostic error: \(error)")
        }
    }
}

import SwiftUI
import PXPCheckoutSDK

struct CheckoutViewWithSessionRefresh: View {
    @StateObject private var viewModel = CheckoutViewModel()
    
    var body: some View {
        Group {
            if let errorMessage = viewModel.errorMessage {
                VStack {
                    Text(errorMessage)
                        .foregroundColor(.red)
                    
                    Button("Refresh") {
                        Task {
                            await viewModel.refreshSession()
                        }
                    }
                }
            }
            if let dropIn = viewModel.dropIn {
                dropIn.buildContent()
            } else if viewModel.errorMessage == nil {
                ProgressView("Loading checkout...")
            }
        }
        .task {
            await viewModel.loadDropIn()
        }
    }
}

@MainActor
final class CheckoutViewModel: ObservableObject {
    @Published var dropIn: CheckoutDropIn?
    @Published var errorMessage: String?
    private var isCreatingDropIn = false
    private var createFailed = false
    
    func loadDropIn() async {
        do {
            let sessionData = try await fetchSessionFromBackend()
            try await initializeDropIn(with: sessionData)
        } catch {
            print("Failed to fetch session: \(error)")
            errorMessage = "Failed to load checkout. Please try again."
        }
    }
    
    func refreshSession() async {
        errorMessage = nil
        dropIn = nil
        await loadDropIn()
    }
    
    private func initializeDropIn(with sessionData: SessionData) async throws {
        isCreatingDropIn = true
        createFailed = false
        let config = CheckoutDropInConfig(
            environment: .live,
            session: sessionData,
            transactionData: DropInTransactionData(
                amount: Decimal(string: "99.99") ?? 0,
                currency: "USD",
                entryType: .ecom,
                intent: DropInTransactionIntentData(
                    card: .authorisation
                ),
                merchantTransactionId: UUID().uuidString,
                merchantTransactionDate: { Date() }
            ),
            merchantShopperId: "shopper-123",
            ownerId: "MERCHANT_GROUP_1", // Merchant group ID (ownerType is always "MerchantGroup")
            onSuccess: { result in
                Task {
                    await verifyPaymentOnBackend(result)
                }
            },
            onError: { paymentMethod, error in
                if isCreatingDropIn {
                    createFailed = true
                }
                // Handle session expiry
                if error.errorMessage.localizedCaseInsensitiveContains("expired") ||
                   error.errorMessage.localizedCaseInsensitiveContains("session") {
                    print("Session expired, refreshing...")
                    
                    Task { @MainActor in
                        self.errorMessage = "Session expired. Please refresh."
                    }
                } else {
                    print("Payment error: \(error.errorMessage)")
                    Task { @MainActor in
                        self.errorMessage = "Payment failed: \(error.errorMessage)"
                    }
                }
            }
        )
        
        // try only covers SDK0103 / SDK0104 (empty sessionId / hmacKey).
        // Create-time failures (including SDK1100 and method setup errors) are delivered
        // through onError, not thrown from create().
        let instance = try CheckoutDropIn(config: config)
        await instance.create()
        isCreatingDropIn = false
        if !createFailed {
            dropIn = instance
        }
    }
}

func fetchSessionFromBackend() async throws -> SessionData {
    // Implementation to fetch session from your backend
    // ...
}

import PassKit
import PXPCheckoutSDK

func diagnosePaymentMethodVisibility(
    sessionData: SessionData?,
    config: CheckoutDropInConfig
) async {
    print("=== Payment method diagnostics ===")
    
    let fundingTypes = sessionData?.allowedFundingTypes
    print("Session funding types: \(String(describing: fundingTypes))")
    
    // Check cards — requires the cards key (empty array OK). cardSchemes alone is insufficient.
    if fundingTypes?.cards != nil {
        print("Cards key present: \(String(describing: fundingTypes?.cards))")
        print("cardSchemes (networks only): \(String(describing: fundingTypes?.cardSchemes))")
    } else {
        print("WARNING: Cards not enabled in session (allowedFundingTypes.cards must not be nil)")
        if fundingTypes?.cardSchemes != nil {
            print("WARNING: cardSchemes is set but does not enable the Card panel")
        }
    }
    
    let showCOF = config.methodConfig?.card?.showCOF ?? true
    let showNewCard = config.methodConfig?.card?.showNewCard ?? true
    print("showCOF=\(showCOF) showNewCard=\(showNewCard)")
    if showCOF == false && showNewCard == false {
        print("WARNING: Both showCOF and showNewCard are false — Card panel will be hidden even if session.cards is present")
    }
    
    if showCOF {
        let shopper = await config.onGetShopper?()
        if let shopperId = shopper?.id, !shopperId.isEmpty {
            print("onGetShopper returned non-empty id")
        } else {
            print("WARNING: Card-on-file needs onGetShopper to return TransactionShopper(id:) with a non-empty id")
        }
    }
    
    // Check PayPal - must have allowedFundingOptions present and non-empty
    if let paypalConfig = fundingTypes?.wallets?.paypal {
        print("PayPal wallet present")
        if let allowedFundingOptions = paypalConfig.allowedFundingOptions,
           !allowedFundingOptions.isEmpty {
            print("PayPal enabled with funding options: \(allowedFundingOptions)")
        } else if let fundingSources = config.methodConfig?.paypal?.fundingSources,
                  !fundingSources.isEmpty {
            print("PayPal fundingSources override present: \(fundingSources)")
        } else {
            print("WARNING: PayPal wallet present but allowedFundingOptions is missing/empty (and no fundingSources override)")
        }
        if config.transactionData.entryType != .ecom {
            print("WARNING: PayPal requires entryType .ecom (SDK1120)")
        }
    } else {
        print("WARNING: PayPal not enabled (wallets.paypal missing)")
    }
    
    // Check Apple Pay - must have merchantId present and non-empty
    if let applePayConfig = fundingTypes?.wallets?.applePay,
       let merchantId = applePayConfig.merchantId,
       !merchantId.isEmpty {
        print("Apple Pay configuration present with merchant ID: \(merchantId)")
        
        if PKPaymentAuthorizationController.canMakePayments() {
            print("Device supports Apple Pay")
            
            let networks = config.methodConfig?.global?.acceptedCardNetworks?.compactMap { network -> PKPaymentNetwork? in
                switch network {
                case .visa: return .visa
                case .mastercard: return .masterCard
                case .amex: return .amex
                case .discover: return .discover
                default: return nil
                }
            } ?? [.visa, .masterCard, .amex]
            
            if PKPaymentAuthorizationController.canMakePayments(usingNetworks: networks) {
                print("Apple Pay has cards configured for accepted networks: \(networks)")
            } else {
                print("WARNING: No cards configured in Apple Wallet for accepted networks")
                print("  Provision Apple sandbox Wallet cards — not Drop-in manual-entry PANs")
            }
        } else {
            print("WARNING: Device does not support Apple Pay")
        }
    } else {
        print("WARNING: Apple Pay not configured (wallets.applePay.merchantId must be present and non-empty)")
    }
    
    // Check Aeropay - funding object present; credentials must be non-blank
    if let aeropay = fundingTypes?.payByBanks?.aeropay {
        print("Aeropay funding present: \(aeropay)")
        let externalMerchantId = aeropay.externalMerchantId ?? ""
        let configurationId = aeropay.configurationId ?? ""
        if externalMerchantId.isEmpty || configurationId.isEmpty {
            print("WARNING: Aeropay credentials incomplete (externalMerchantId or configurationId). Expect SDK0113 via onError")
        }
        if config.transactionData.currency != "USD" {
            print("WARNING: Aeropay requires USD (SDK0116 if not)")
        }
        if config.transactionData.entryType != .ecom {
            print("WARNING: Aeropay requires entryType .ecom (SDK0114 if not)")
        }
        if config.transactionData.intent.aeropay == nil {
            print("WARNING: Aeropay intent missing (expect SDK0115 via onError)")
        }
    } else {
        print("WARNING: Aeropay not configured in session (payByBanks.aeropay missing)")
    }
    
    print("iOS version: \(UIDevice.current.systemVersion)")
    print("Device: \(UIDevice.current.model)")
    
    print("===================================")
}

import PassKit

func checkApplePayAvailability() {
    print("=== Apple Pay Diagnostics ===")
    
    // Check if device supports Apple Pay
    if PKPaymentAuthorizationController.canMakePayments() {
        print("✓ Device supports Apple Pay")
    } else {
        print("✗ Device does not support Apple Pay")
        return
    }
    
    // Check if user has cards configured
    let networks: [PKPaymentNetwork] = [.visa, .masterCard, .amex]
    if PKPaymentAuthorizationController.canMakePayments(usingNetworks: networks) {
        print("✓ Apple Pay has cards configured")
    } else {
        print("✗ No cards configured in Apple Wallet")
        print("  Provision Apple sandbox Wallet cards — not Drop-in manual-entry PANs")
    }
    
    // Check iOS version
    if #available(iOS 14.0, *) {
        print("✓ iOS version compatible (14.0+)")
    } else {
        print("✗ iOS version too old (requires 14.0+)")
    }
    
    print("=============================")
}

// Backend webhook handler (Node.js/Express example)
app.post('/webhooks/pxp', async (req, res) => {
  try {
    const events = req.body;
    
    // Verify webhook authenticity using HMAC
    if (!verifyWebhookSignature(req)) {
      console.error('Invalid webhook signature');
      return res.status(401).json({ error: 'Unauthorised' });
    }
    
    for (const event of events) {
      if (event.eventCategory === 'Transaction') {
        const txn = event.eventData;
        
        console.log('Processing transaction:', txn.systemTransactionId);
        
        // Idempotency check
        const existing = await db.transactions.findOne({
          systemTransactionId: txn.systemTransactionId
        });
        
        if (existing) {
          console.log('Transaction already processed, skipping');
          continue;
        }
        
        // Verify transaction state
        if (txn.state === 'Authorised' || txn.state === 'Captured') {
          // Find order by merchant transaction ID
          const order = await db.orders.findOne({
            merchantTransactionId: txn.merchantTransactionId
          });
          
          if (!order) {
            console.error('Order not found:', txn.merchantTransactionId);
            continue;
          }
          
          // Verify amount matches
          const transactionAmount = txn.amounts?.transactionValue || txn.amount;
          if (Math.abs(transactionAmount - order.amount) > 0.01) {
            console.error('Amount mismatch:', {
              expected: order.amount,
              actual: transactionAmount
            });
            continue;
          }
          
          // Mark transaction as processed
          await db.transactions.create({
            systemTransactionId: txn.systemTransactionId,
            merchantTransactionId: txn.merchantTransactionId,
            amount: transactionAmount,
            state: txn.state,
            processedAt: new Date()
          });
          
          // Fulfill order
          await fulfillOrder(order.id, txn.systemTransactionId);
          
          console.log('Order fulfilled:', order.id);
        }
      }
    }
    
    // Always return success
    res.json({ state: 'Success' });
  } catch (error) {
    console.error('Webhook processing error:', error);
    res.status(500).json({ error: 'Internal server error' });
  }
});

import SwiftUI
import PXPCheckoutSDK

struct CheckoutView: View {
    @StateObject private var viewModel = CheckoutViewModel()
    @Environment(\.scenePhase) private var scenePhase
    
    var body: some View {
        Group {
            if let errorMessage = viewModel.errorMessage {
                Text(errorMessage)
                    .foregroundColor(.red)
            }
            if let dropIn = viewModel.dropIn {
                dropIn.buildContent()
            } else if viewModel.errorMessage == nil {
                ProgressView("Loading...")
            }
        }
        .task {
            await viewModel.loadDropIn()
        }
        // Single-value onChange compiles with the SDK's iOS 14 deployment floor
        .onChange(of: scenePhase) { phase in
            switch phase {
            case .background:
                print("App backgrounded")
            case .inactive:
                print("App inactive")
            case .active:
                print("App active")
            @unknown default:
                break
            }
        }
        .onDisappear {
            viewModel.cleanup()
        }
    }
}

@MainActor
final class CheckoutViewModel: ObservableObject {
    @Published var dropIn: CheckoutDropIn?
    @Published var errorMessage: String?
    
    func loadDropIn() async {
        // Implementation
    }
    
    func cleanup() {
        dropIn?.destroy()
        dropIn = nil
        errorMessage = nil
        print("Checkout view cleaned up")
    }
    
    deinit {
        print("CheckoutViewModel deallocated")
    }
}

import SwiftUI

struct CheckoutView: View {
    @StateObject private var viewModel = CheckoutViewModel()
    @FocusState private var focusedField: Field?
    
    enum Field {
        case cardNumber, expiry, cvv
    }
    
    var body: some View {
        ScrollView {
            VStack(spacing: 16) {
                if let dropIn = viewModel.dropIn {
                    dropIn.buildContent()
                }
            }
            .padding()
        }
        // `.scrollDismissesKeyboard` requires iOS 16+. On iOS 14–15, omit this modifier
        // and use keyboard frame notifications for insets (see below).
        .modifier(ScrollDismissesKeyboardIfAvailable())
        // Do not use `.ignoresSafeArea(.keyboard)` here — that prevents keyboard insets
        // and can leave fields or the submit area covered.
    }
}

private struct ScrollDismissesKeyboardIfAvailable: ViewModifier {
    func body(content: Content) -> some View {
        if #available(iOS 16.0, *) {
            content.scrollDismissesKeyboard(.interactively)
        } else {
            content
        }
    }
}

import OSLog

let logger = Logger(subsystem: "com.yourapp.checkout", category: "DropIn")

CheckoutDropInConfig(
    // ... other config
    analyticsEvent: { event in
        #if DEBUG
        // BaseAnalyticsEvent encodes eventName, sessionId, and timestamp only.
        // Subclass-specific properties aren't included unless you cast to the concrete event type.
        let timestamp = ISO8601DateFormatter().string(from: event.timestamp)
        logger.debug("Event: \(event.eventName) sessionId=\(event.sessionId) timestamp=\(timestamp)")
        #endif
    }
)

import UIKit

func collectDiagnosticInfo(sessionData: SessionData?, config: CheckoutDropInConfig) -> String {
    var info: [String: Any] = [:]
    
    // Device information
    info["device"] = UIDevice.current.model
    info["systemName"] = UIDevice.current.systemName
    info["systemVersion"] = UIDevice.current.systemVersion
    info["identifierForVendor"] = UIDevice.current.identifierForVendor?.uuidString ?? "N/A"
    
    // Screen information
    let screen = UIScreen.main
    info["screenWidth"] = screen.bounds.width
    info["screenHeight"] = screen.bounds.height
    info["screenScale"] = screen.scale
    
    // App information
    if let bundleInfo = Bundle.main.infoDictionary {
        info["appVersion"] = bundleInfo["CFBundleShortVersionString"] ?? "N/A"
        info["buildNumber"] = bundleInfo["CFBundleVersion"] ?? "N/A"
    }
    
    // SDK version — there is no CheckoutDropIn.sdkVersion API.
    // Record the Swift Package resolved version from Xcode (Package Dependencies) or Package.resolved.
    info["environment"] = String(describing: config.environment)
    
    // Session info (sanitised - DO NOT log hmacKey, encryptionKey, or API secrets)
    info["sessionIdPresent"] = sessionData?.sessionId.isEmpty == false
    info["hmacKeyPresent"] = sessionData?.hmacKey.isEmpty == false
    info["encryptionKeyPresent"] = sessionData?.encryptionKey.isEmpty == false
    info["allowedFundingTypes"] = String(describing: sessionData?.allowedFundingTypes)
    
    // Timestamp
    info["timestamp"] = ISO8601DateFormatter().string(from: Date())
    
    // Convert to JSON string
    if let jsonData = try? JSONSerialization.data(withJSONObject: info, options: .prettyPrinted),
       let jsonString = String(data: jsonData, encoding: .utf8) {
        print(jsonString)
        
        // Copy to pasteboard
        UIPasteboard.general.string = jsonString
        
        return jsonString
    }
    
    return "Failed to generate diagnostics"
}