Troubleshooting

import PXPCheckoutSDK

onError: { error in
    switch error.errorCode {
    case "SDK0809", "SDK0810", "SDK0811", "SDK0817", "SDK0818":
        // SDK validation error - fix input data
        print("Validation error: \(error.errorMessage)")
        
    case "SDK0819":
        // PayPal API error - check error message for details
        print("Payout failed: \(error.errorMessage)")
        // Message contains PayPal's error code and reason
        
    default:
        // Could be Unity API error or other SDK error
        print("Error: \(error.errorCode) - \(error.errorMessage)")
    }
}

import PXPCheckoutSDK

let config = PayoutSubmissionComponentConfig(
    buttonText: "Submit Payout",
    
    // Add verbose logging to callbacks
    onClick: {
        print("📱 PayPal payout button clicked")
    },
    
    onPrePayoutSubmit: {
        print("💰 Pre-payout approval requested")
        // ... approval logic ...
        return result
    },
    
    onPostPayout: { result in
        print("🎉 Payout successful!")
        print("   Merchant TX ID: \(result.merchantTransactionId)")
        print("   System TX ID: \(result.systemTransactionId)")
    },
    
    onCancel: {
        print("❌ User cancelled payout flow")
    },
    
    onError: { error in
        print("⚠️ Error occurred:")
        print("   Code: \(error.errorCode)")
        print("   Message: \(error.errorMessage)")
    }
)

# PXP Checkout logs
subsystem:com.pxp.checkout

# PayPal payout logs
process:YourAppName AND payout

# All SDK logs
category:PXPCheckoutSDK

# Example filter once you identify the subsystem:
subsystem:com.yourcompany.yourapp process:YourAppName

import Network
import Combine

class NetworkMonitor: ObservableObject {
    static let shared = NetworkMonitor()
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue(label: "NetworkMonitor")
    
    @Published private(set) var isConnected: Bool = false
    @Published private(set) var connectionType: NWInterface.InterfaceType?
    
    private init() {}
    
    func startMonitoring() {
        monitor.pathUpdateHandler = { [weak self] path in
            DispatchQueue.main.async {
                self?.isConnected = path.status == .satisfied
                self?.connectionType = path.availableInterfaces.first?.type
                
                if path.status == .satisfied {
                    print("✅ Network connected via \(path.availableInterfaces.first?.type.debugDescription ?? "unknown")")
                } else {
                    print("⚠️ Network disconnected")
                }
            }
        }
        
        monitor.start(queue: queue)
    }
    
    func stopMonitoring() {
        monitor.cancel()
    }
    
    deinit {
        stopMonitoring()
    }
}

// Usage example:
NetworkMonitor.shared.startMonitoring()

if !NetworkMonitor.shared.isConnected {
    showAlert(title: "No Connection", 
             message: "Please check your internet connection and try again.")
    return
}

// Proceed with payout flow

import PXPCheckoutSDK

struct PayoutValidationResult {
    let isValid: Bool
    let errors: [String]
}

func validatePayoutConfig(
    amount: Decimal,
    payerId: String?
) -> PayoutValidationResult {
    var errors: [String] = []
    
    // Validate amount
    if amount.isNaN {
        errors.append("Amount must be a valid number (SDK0810)")
    }
    
    if amount <= 0 {
        errors.append("Amount must be greater than zero (SDK0811)")
    }
    
    if amount < 1.00 {
        errors.append("Amount must be at least $1.00 (PayPal minimum)")
    }
    
    // Validate payer ID if provided
    if let payerId = payerId {
        if payerId.isEmpty {
            errors.append("Payer ID cannot be empty (SDK0809)")
        }
        
        if payerId.count > 13 {
            errors.append("Payer ID exceeds 13 characters (SDK0817)")
        }
        
        let alphanumericSet = CharacterSet.alphanumerics
        if payerId.unicodeScalars.contains(where: { !alphanumericSet.contains($0) }) {
            errors.append("Payer ID must be alphanumeric (SDK0818)")
        }
    }
    
    return PayoutValidationResult(
        isValid: errors.isEmpty,
        errors: errors
    )
}

// Usage example:
let validation = validatePayoutConfig(
    amount: Decimal(100.00),
    payerId: storedPayerId
)

if !validation.isValid {
    print("❌ Validation errors: \(validation.errors.joined(separator: ", "))")
    showErrorDialog(validation.errors.first ?? "Validation failed")
    return
}

// Proceed with payout

import SwiftUI
import PXPCheckoutSDK

struct PayoutView: View {
    @State private var showApprovalAlert = false
    @State private var pendingApprovalContinuation: CheckedContinuation<PrePayoutSubmitResult?, Never>?
    @State private var storedPayerId: String?
    
    let payoutAmount = 100.00
    
    var body: some View {
        VStack {
            // ... payout UI ...
        }
        .alert("Confirm Payout", isPresented: $showApprovalAlert) {
            Button("Cancel", role: .cancel) {
                // User rejected - resume with nil
                pendingApprovalContinuation?.resume(returning: nil)
                pendingApprovalContinuation = nil
            }
            Button("Confirm") {
                // User approved - resume with approval result
                pendingApprovalContinuation?.resume(returning: 
                    PrePayoutSubmitResult(
                        isApproved: true,
                        payerId: storedPayerId ?? ""
                    )
                )
                pendingApprovalContinuation = nil
            }
        } message: {
            Text("Send $\(String(format: "%.2f", payoutAmount)) to your PayPal account?")
        }
    }
    
    private func createPayoutComponent() {
        let config = PayoutSubmissionComponentConfig(
            buttonText: "Submit Payout",
            
            onPrePayoutSubmit: { [self] in
                // Use withCheckedContinuation for async dialog
                return await withCheckedContinuation { continuation in
                    Task { @MainActor in
                        self.pendingApprovalContinuation = continuation
                        self.showApprovalAlert = true
                    }
                }
            }
        )
        
        // ... create component ...
    }
}

extension View {
    func debugPrint(_ message: String) -> some View {
        print("🔍 \(message)")
        return self
    }
    
    func debugBorder(_ color: Color = .red) -> some View {
        self.border(color, width: 2)
    }
}

// Usage example:
struct PayoutView: View {
    var body: some View {
        VStack {
            if let component = payoutComponent {
                component.buildContent()
                    .frame(height: 50)
                    .debugBorder(.red) // Visualise button area
                    .debugPrint("Payout button rendered")
            } else {
                Text("Loading...")
                    .debugPrint("Still loading component")
            }
        }
        .debugBorder(.blue) // Visualise container
    }
}

import SwiftUI
import PXPCheckoutSDK

struct PayoutView: View {
    @State private var payoutComponent: BaseComponent?
    @State private var isLoading = true
    @State private var errorMessage: String?
    @State private var initTask: Task<Void, Never>?
    
    var body: some View {
        VStack {
            if isLoading {
                ProgressView("Initialising...")
            } else if let error = errorMessage {
                Text("Error: \(error)")
                    .foregroundColor(.red)
                Button("Retry") {
                    initTask = Task {
                        await createPayoutComponent()
                    }
                }
            } else if let component = payoutComponent {
                component.buildContent()
            }
        }
        .task {
            await createPayoutComponent()
        }
        .onDisappear {
            initTask?.cancel()
        }
    }
    
    @MainActor
    private func createPayoutComponent() async {
        isLoading = true
        errorMessage = nil
        
        do {
            // Initialise SDK
            let checkoutConfig = CheckoutConfig(
                environment: .test,
                session: sessionData,
                transactionData: transactionData,
                merchantShopperId: "user-123",
                ownerId: "merchant-456",
                paypalConfig: paypalConfig
            )
            
            let pxpCheckout = try PxpCheckout.initialize(config: checkoutConfig)
            
            // Create payout component
            let config = PayoutSubmissionComponentConfig(
                buttonText: "Submit Payout"
            )
            
            let component = try pxpCheckout.create(
                .payoutSubmission,
                componentConfig: config
            )
            
            self.payoutComponent = component
            
        } catch let error as NSError {
            print("❌ Initialisation error: \(error.localizedDescription)")
            print("Error domain: \(error.domain)")
            print("Error code: \(error.code)")
            print("Error userInfo: \(error.userInfo)")
            
            self.errorMessage = "Failed to initialise payout: \(error.localizedDescription)"
            
            // Track error for analytics
            logError(error)
        }
        
        isLoading = false
    }
    
    func logError(_ error: Error) {
        // Log to your analytics/crash reporting service
        print("📊 Logging error to analytics")
    }
}

import PXPCheckoutSDK

// Example with common analytics services:

// Firebase Analytics:
// Analytics.logEvent("payout_started", parameters: [...])

// Mixpanel:
// Mixpanel.mainInstance().track(event: "payout_started", properties: [...])

// Amplitude:
// Amplitude.instance().logEvent("payout_started", withEventProperties: [...])

// Custom analytics service:
// YourAnalyticsService.shared.trackEvent(name: "payout_started", properties: [...])

let config = PayoutSubmissionComponentConfig(
    buttonText: "Submit Payout",
    
    onClick: {
        Analytics.track("payout_started", properties: [
            "timestamp": Date().timeIntervalSince1970,
            "amount": payoutAmount
        ])
    },
    
    onPrePayoutSubmit: {
        Analytics.track("payout_approval_requested", properties: [
            "timestamp": Date().timeIntervalSince1970
        ])
        
        let result = await showApprovalDialog()
        
        if result == nil {
            Analytics.track("payout_approval_rejected", properties: [
                "timestamp": Date().timeIntervalSince1970
            ])
        } else {
            Analytics.track("payout_approval_granted", properties: [
                "timestamp": Date().timeIntervalSince1970
            ])
        }
        
        return result
    },
    
    onPostPayout: { result in
        Analytics.track("payout_completed", properties: [
            "transactionId": result.merchantTransactionId,
            "timestamp": Date().timeIntervalSince1970,
            "amount": payoutAmount
        ])
    },
    
    onCancel: {
        Analytics.track("payout_cancelled", properties: [
            "timestamp": Date().timeIntervalSince1970
        ])
    },
    
    onError: { error in
        Analytics.track("payout_error", properties: [
            "errorCode": error.errorCode,
            "errorMessage": error.errorMessage,
            "timestamp": Date().timeIntervalSince1970
        ])
    }
)