Troubleshooting

val paypalConfig = PayPalComponentConfig(
    queryParams = PayPalQueryParams(
        debug = true // Only use in development
    )
)

// In your Application class or before SDK initialisation
if (BuildConfig.DEBUG) {
    WebView.setWebContentsDebuggingEnabled(true)
}

# PXP Checkout logs
adb logcat | grep -E "(PxpCheckout|PXP)"

# PayPal-specific logs
adb logcat | grep -E "(PayPal|paypal)"

# WebView-related logs
adb logcat | grep -E "(WebView|chromium)"

# Network-related logs
adb logcat | grep -E "(OkHttp|Retrofit|Network)"

# Comprehensive debugging
adb logcat | grep -E "(PxpCheckout|PayPal|WebView)" -A 5

val paypalConfig = PayPalComponentConfig(
    onSuccess = { data ->
        Log.d("PayPal", "✓ Payment successful")
        Log.v("PayPal", "Success data: $data")
        processPayment(data)
    },
    onError = { error ->
        Log.e("PayPal", "✗ Payment error: $error")
        Log.e("PayPal", "Stack trace:", Exception(error))
        handleError(error)
    },
    onCancel = {
        Log.w("PayPal", "⚠ Payment cancelled by user")
        handleCancellation()
    },
    onOrderCreated = { orderData ->
        Log.i("PayPal", "📦 Order created: $orderData")
        trackOrderCreation(orderData)
    },
    onScriptLoaded = {
        Log.d("PayPal", "✓ PayPal SDK script loaded")
        hideLoadingIndicator()
    }
)

fun checkWebViewAvailability(context: Context): Boolean {
    return try {
        val webViewPackage = WebView.getCurrentWebViewPackage()
        webViewPackage != null
    } catch (e: Exception) {
        Log.e("PayPal", "WebView not available", e)
        false
    }
}

// Usage example:
if (!checkWebViewAvailability(context)) {
    // Show error and prompt user to install WebView
    promptWebViewUpdate(context)
    return
}
// Proceed with PayPal component creation

fun isNetworkAvailable(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val network = connectivityManager.activeNetwork ?: return false
    val capabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
    
    return capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET) &&
           capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
}

// Usage example:
if (!isNetworkAvailable(context)) {
    Toast.makeText(context, "No internet connection. Please check your network.", Toast.LENGTH_LONG).show()
    return
}
// Proceed with PayPal SDK initialisation

fun checkMemoryStatus() {
    val runtime = Runtime.getRuntime()
    val usedMemory = (runtime.totalMemory() - runtime.freeMemory()) / 1024 / 1024
    val maxMemory = runtime.maxMemory() / 1024 / 1024
    val availableMemory = maxMemory - usedMemory
    
    Log.d("PayPal", "Memory: $usedMemory MB used, $availableMemory MB available")
    
    if (availableMemory < 50) {
        Log.w("PayPal", "Low memory warning")
    }
}

// Usage example:
checkMemoryStatus()
if (Runtime.getRuntime().freeMemory() / 1024 / 1024 < 50) {
    // Consider deferring heavy operations or showing a warning
    Log.w("PayPal", "Low memory condition detected before PayPal component creation")
}

// Define the ValidationResult data class
data class ValidationResult(
    val isValid: Boolean,
    val errors: List<String>
)

fun validatePayPalConfig(config: PayPalComponentConfig): ValidationResult {
    val errors = mutableListOf<String>()
    
    if (config.renderType.isNullOrEmpty()) {
        errors.add("renderType is required")
    }
    
    if (config.fundingSources == null) {
        errors.add("fundingSources is required")
    }
    
    if (config.renderType == "standalone" && config.fundingSources !is String) {
        errors.add("fundingSources must be a String for standalone renderType")
    }
    
    if (config.renderType == "setOfButtons" && config.fundingSources !is List<*>) {
        errors.add("fundingSources must be a List<String> for setOfButtons renderType")
    }
    
    return ValidationResult(
        isValid = errors.isEmpty(),
        errors = errors
    )
}

// Usage example:
val config = PayPalComponentConfig(
    renderType = "standalone",
    fundingSources = "paypal"
    // ... other config
)

val validation = validatePayPalConfig(config)
if (!validation.isValid) {
    Log.e("PayPal", "Configuration errors: ${validation.errors.joinToString()}")
    // Show error to user or fix configuration
    return
}
// Proceed with component creation

@Composable
fun PayPalScreen(navController: NavController) {
    var showExitDialog by remember { mutableStateOf(false) }
    
    BackHandler {
        Log.d("PayPal", "Back pressed during payment flow")
        // Option 1: Exit immediately
        navController.popBackStack()
        
        // Option 2: Show confirmation dialog
        // showExitDialog = true
    }
    
    // Optional: Confirmation dialog
    if (showExitDialog) {
        AlertDialog(
            onDismissRequest = { showExitDialog = false },
            title = { Text("Cancel Payment?") },
            text = { Text("Are you sure you want to cancel this payment?") },
            confirmButton = {
                TextButton(onClick = {
                    showExitDialog = false
                    navController.popBackStack()
                }) {
                    Text("Yes, Cancel")
                }
            },
            dismissButton = {
                TextButton(onClick = { showExitDialog = false }) {
                    Text("Continue Payment")
                }
            }
        )
    }
    
    // PayPal component rendering
}

fun promptWebViewUpdate(context: Context) {
    AlertDialog.Builder(context)
        .setTitle("Update required")
        .setMessage("Please update Android System WebView to use PayPal payments")
        .setPositiveButton("Update") { _, _ ->
            try {
                val intent = Intent(Intent.ACTION_VIEW).apply {
                    data = Uri.parse("market://details?id=com.google.android.webview")
                    // Add flag to avoid adding Play Store to back stack
                    flags = Intent.FLAG_ACTIVITY_NEW_TASK
                }
                context.startActivity(intent)
            } catch (e: ActivityNotFoundException) {
                // Fallback to web browser if Play Store not available
                Log.e("PayPal", "Play Store not available", e)
                val webIntent = Intent(Intent.ACTION_VIEW).apply {
                    data = Uri.parse("https://play.google.com/store/apps/details?id=com.google.android.webview")
                }
                context.startActivity(webIntent)
            }
        }
        .setNegativeButton("Cancel", null)
        .setCancelable(false) // Prevent dismissing without action
        .show()
}

// Usage example:
if (!checkWebViewAvailability(context)) {
    Log.e("PayPal", "WebView not available on device")
    promptWebViewUpdate(context)
    return // Don't proceed with PayPal component creation
}