Events

onPreAuthorisation: (suspend (PreAuthorisationData?) -> GooglePayTransactionInitData?)?

import com.pxp.checkout.components.googlepay.types.GooglePayTransactionInitData
import com.pxp.checkout.services.kount.*
import com.pxp.checkout.services.models.transaction.ScaExemptionType

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onPreAuthorisation = suspend { data ->
        Log.d("GooglePay", "Pre-authorisation started")
        Log.d("GooglePay", "Gateway Token ID: ${data?.gatewayTokenId}")
        Log.d("GooglePay", "Scheme Token ID: ${data?.schemeTokenId}")
        
        // Perform pre-payment validation
        val isHighRisk = checkCustomerRiskProfile()
        val customerTier = getCustomerTier()
        
        // Check inventory before proceeding
        val inventoryAvailable = checkInventoryAvailability()
        if (!inventoryAvailable) {
            showError("Some items are no longer available")
            return@suspend null // Cancel payment
        }
        
        // Check business rules
        val cartTotal = getCurrentCartTotal()
        if (cartTotal > 10000.0 && isHighRisk) {
            showError("Transaction requires additional verification")
            return@suspend null // Cancel payment for manual review
        }
        
        GooglePayTransactionInitData(
            riskScreeningData = RiskScreeningData(
                performRiskScreening = true,
                excludeDeviceData = false,
                userIp = "192.168.1.100",
                account = RiskScreeningAccount(
                    id = "user_12345678",
                    creationDateTime = "2024-01-15T10:30:00.000Z"
                ),
                transaction = RiskScreeningTransaction(
                    subtotal = cartTotal
                ),
                items = cartItems.map { item ->
                    RiskScreeningItem(
                        price = item.price,
                        quantity = item.quantity,
                        category = item.category,
                        sku = item.sku
                    )
                },
                fulfillments = listOf(
                    RiskScreeningFulfillment(
                        type = FulfillmentType.SHIPPED,
                        shipping = RiskScreeningShipping(
                            shippingMethod = ShippingMethod.STANDARD
                        ),
                        recipientPerson = RiskScreeningRecipientPerson(
                            phoneNumber = "+1234567890"
                        )
                    )
                )
            ),
            psd2Data = GooglePayTransactionInitData.Psd2Data(
                scaExemption = if (cartTotal < 30.0) {
                    ScaExemptionType.LOW_VALUE
                } else {
                    ScaExemptionType.TRANSACTION_RISK_ANALYSIS
                }
            )
        )
    }
}

onPostAuthorisation: ((SubmitResult?, AuthorisationPaymentData) -> Unit)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onPostAuthorisation = { result, paymentData ->
        Log.d("GooglePay", "Payment completed: $result")
        
        when (result) {
            is MerchantSubmitResult -> {
                // Payment successful
                Log.d("GooglePay", "Payment authorised successfully")
                Log.d("GooglePay", "Merchant Transaction ID: ${result.merchantTransactionId}")
                Log.d("GooglePay", "System Transaction ID: ${result.systemTransactionId}")
                
                // Extract payment data
                val email = paymentData.email
                val shippingAddress = paymentData.shippingAddress
                val shippingOption = paymentData.shippingOption
                
                // Use your Activity's lifecycleScope or CoroutineScope
                lifecycleScope.launch {
                    try {
                        // Update inventory
                        updateInventory(result.merchantTransactionId)
                        
                        // Create order record
                        createOrder(
                            transactionId = result.merchantTransactionId,
                            systemTransactionId = result.systemTransactionId,
                            email = email,
                            shippingAddress = shippingAddress,
                            shippingMethod = shippingOption?.get("id"),
                            status = "confirmed"
                        )
                        
                        // Send confirmation email
                        sendConfirmationEmail(
                            transactionId = result.merchantTransactionId,
                            email = email,
                            shippingAddress = shippingAddress
                        )
                        
                        // Track successful payment
                        analyticsTracker.trackEvent("google_pay_success") {
                            put("transaction_id", result.merchantTransactionId)
                            put("cart_value", getCurrentCartValue())
                            put("shipping_method", shippingOption?.get("id"))
                        }
                        
                        // Update customer account
                        updateCustomerPurchaseHistory(result.merchantTransactionId)
                        
                        // Navigate to success screen
                        withContext(Dispatchers.Main) {
                            navController.navigate(
                                "payment_success/${result.merchantTransactionId}"
                            )
                        }
                    } catch (e: Exception) {
                        Log.e("GooglePay", "Error in post-authorisation", e)
                        showError("Payment succeeded but order processing failed")
                    }
                }
            }
            
            is FailedSubmitResult -> {
                // Payment declined
                Log.e("GooglePay", "Payment declined: ${result.errorReason}")
                Log.e("GooglePay", "Error code: ${result.errorCode}")
                Log.e("GooglePay", "Correlation ID: ${result.correlationId}")
                
                // Log failure for monitoring
                logPaymentFailure(
                    errorCode = result.errorCode,
                    errorReason = result.errorReason,
                    correlationId = result.correlationId,
                    merchantTransactionId = result.merchantTransactionId
                )
                
                // Show user-friendly error message
                val errorMessage = getErrorMessage(result.errorCode)
                showError("Payment declined: $errorMessage")
                
                // Track failed payment
                analyticsTracker.trackEvent("google_pay_declined") {
                    put("error_code", result.errorCode)
                    put("correlation_id", result.correlationId)
                }
                
                // Offer alternatives
                showAlternativePaymentMethods()
            }
            
            else -> {
                // Unexpected result
                Log.e("GooglePay", "Unexpected result: $result")
                showError("Payment processing error. Please contact support.")
                analyticsTracker.trackEvent("google_pay_exception") {
                    put("result", result.toString())
                }
            }
        }
    }
}

onPaymentDataChanged: ((Any) -> Any?)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    paymentDataRequest = PaymentDataRequest(
        // ... other configuration
        shippingAddressRequired = true,
        shippingOptionRequired = true
    )
    
    onPaymentDataChanged = { intermediatePaymentData ->
        Log.d("GooglePay", "Payment data changed")
        
        // Parse the intermediate payment data
        // Note: You'll need to cast/parse based on Google Pay's structure
        
        val baseAmount = 20.00
        var tax = 5.00
        var shippingCost = 0.0
        var errorMap: Map<String, String>? = null
        
        // Example: Handle shipping address or option changes
        // The structure depends on Google Pay's IntermediatePaymentData format
        
        // Calculate new total
        val newTotal = baseAmount + tax + shippingCost
        
        // Update SDK amount
        pxpCheckout.updateAmount(newTotal)
        
        // Return updated payment data as Map
        mapOf(
            "newTransactionInfo" to mapOf(
                "totalPrice" to newTotal.toString(),
                "totalPriceStatus" to "FINAL",
                "displayItems" to listOf(
                    mapOf(
                        "label" to "Subtotal",
                        "type" to "SUBTOTAL",
                        "price" to baseAmount.toString()
                    ),
                    mapOf(
                        "label" to "Shipping",
                        "type" to "LINE_ITEM",
                        "price" to shippingCost.toString()
                    ),
                    mapOf(
                        "label" to "Tax",
                        "type" to "TAX",
                        "price" to tax.toString()
                    )
                )
            ),
            "error" to errorMap // Include error if validation failed
        ).filterValues { it != null } // Remove null values
    }
}

onGooglePaymentButtonClicked: (() -> kotlinx.coroutines.Deferred<Unit>?)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onGooglePaymentButtonClicked = {
        Log.d("GooglePay", "Google Pay button clicked")
        
        // Track button click
        analyticsTracker.trackEvent("google_pay_button_clicked") {
            put("timestamp", System.currentTimeMillis())
            put("cart_value", getCurrentCartValue())
            put("item_count", getCartItemCount())
        }
        
        // Show loading indicator
        withContext(Dispatchers.Main) {
            showLoadingDialog()
        }
        
        // Final inventory check
        val inventoryOk = checkInventoryAvailability()
        if (!inventoryOk) {
            withContext(Dispatchers.Main) {
                hideLoadingDialog()
                showError("Some items are no longer available")
            }
            throw IllegalStateException("Inventory unavailable")
        }
        
        // Prepare checkout data
        prepareCheckoutData()
        
        // Update cart totals
        recalculateCartTotals()
        
        withContext(Dispatchers.Main) {
            hideLoadingDialog()
        }
        
        CompletableDeferred(Unit)
    }
}

onCustomValidation: (() -> suspend Boolean)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onCustomValidation = suspend {
        var isValid = true
        
        // Validate email
        val email = emailField.text.toString()
        if (email.isEmpty() || !email.contains('@')) {
            showError("Please enter a valid email address")
            highlightField(emailField)
            isValid = false
        }
        
        // Validate phone number (if required)
        val phone = phoneField.text.toString()
        if (phone.isEmpty() || phone.length < 10) {
            showError("Please enter a valid phone number")
            highlightField(phoneField)
            isValid = false
        }
        
        // Validate terms acceptance
        val termsAccepted = termsCheckbox.isChecked
        if (!termsAccepted) {
            showError("Please accept the terms and conditions")
            highlightField(termsCheckbox)
            isValid = false
        }
        
        // Validate age verification (if required)
        val ageVerified = ageVerifyCheckbox.isChecked
        if (!ageVerified) {
            showError("You must be 18 or older to complete this purchase")
            isValid = false
        }
        
        // Validate minimum order amount
        val cartTotal = getCurrentCartTotal()
        if (cartTotal < 10.00) {
            showError("Minimum order amount is £10.00")
            isValid = false
        }
        
        // Final inventory check
        if (isValid) {
            val inventoryAvailable = checkInventory()
            if (!inventoryAvailable) {
                showError("Some items are no longer available. Please review your cart.")
                isValid = false
            }
        }
        
        isValid // Return validation result
    }
}

onError: ((BaseSdkException) -> Unit)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onError = { error ->
        Log.e("GooglePay", "Error occurred", error)
        
        // Log error for debugging
        logError("google-pay-error") {
            put("message", error.message ?: "Unknown error")
            put("code", error.ErrorCode)
            put("timestamp", System.currentTimeMillis())
            put("user_id", getCurrentUserId())
        }
        
        // Handle specific error types
        when (error) {
            is GooglePayNotReadyException -> {
                Log.e("GooglePay", "Google Pay not available")
                showError("Google Pay is not available on this device. Please use another payment method.")
                showAlternativePaymentMethods()
                analyticsTracker.trackEvent("google_pay_not_available")
            }
            
            is GooglePayConfigurationValidationFailedException -> {
                Log.e("GooglePay", "Configuration validation failed")
                showError("Payment system temporarily unavailable. Please try again later.")
                notifySupport("Configuration error", error)
            }
            
            is GooglePayClientNotInitializedException -> {
                Log.e("GooglePay", "Client not initialised")
                showError("Payment system not ready. Please refresh and try again.")
                notifySupport("Client initialisation error", error)
            }
            
            is GooglePayLoadFailedException -> {
                Log.e("GooglePay", "Failed to load Google Pay")
                showError("Unable to load payment system. Please check your connection.")
                offerRetryOption()
            }
            
            is GooglePayPaymentFailedException -> {
                Log.e("GooglePay", "Payment processing failed")
                showError("Payment failed. Please check your payment information.")
                offerRetryOption()
            }
            
            is GooglePayDecryptAndTokenVaultFailedException -> {
                Log.e("GooglePay", "Token vault error")
                showError("Payment processing error. Please try again.")
                notifySupport("Token vault error", error)
            }
            
            else -> {
                Log.e("GooglePay", "Unexpected error: ${error.message}")
                showError("An unexpected error occurred. Please try again.")
                analyticsTracker.trackEvent("google_pay_error") {
                    put("error_type", error::class.simpleName ?: "Unknown")
                    put("error_code", error.ErrorCode)
                }
            }
        }
    }
}

onCancel: (() -> Unit)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onCancel = {
        Log.d("GooglePay", "Payment cancelled by user")
        
        // Track cancellation
        analyticsTracker.trackEvent("google_pay_cancelled") {
            put("timestamp", System.currentTimeMillis())
            put("cart_value", getCurrentCartValue())
            put("item_count", getCartItemCount())
        }
        
        // Preserve cart for later
        saveCartForLater()
        
        // Show helpful message
        showMessage(
            "No worries! Your items are saved. You can complete your purchase anytime.",
            isError = false
        )
        
        // Offer support for high-value carts
        if (getCartValue() > 100.0) {
            showSupportDialog("Need help completing your purchase?")
        }
        
        // Schedule abandoned cart notification
        lifecycleScope.launch {
            scheduleAbandonedCartNotification(
                customerId = getCurrentCustomerId(),
                cartData = getCurrentCartData(),
                delayMinutes = 60
            )
        }
    }
}

useUnityAuthenticationStrategy: Boolean = false

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    // Enable Unity authentication strategy
    useUnityAuthenticationStrategy = true
    
    // Simplified callbacks when using Unity strategy
    onPreInitiateAuthentication = {
        PreInitiateIntegratedAuthenticationData(
            providerId = "pxpfinancial",
            timeout = 12
        )
    }
    
    onPreAuthentication = suspend {
        InitiateIntegratedAuthenticationData(
            merchantCountryNumericCode = "840",
            merchantLegalName = "Your Store Name",
            challengeWindowSize = ChallengeWindowSize.FULL_SCREEN,
            requestorChallengeIndicator = RequestorChallengeIndicatorType.NO_PREFERENCE,
            timeout = 180
        )
    }
}

onPreInitiateAuthentication: (() -> PreInitiateIntegratedAuthenticationData?)?

import com.pxp.checkout.services.models.authentication.PreInitiateIntegratedAuthenticationData
import com.pxp.checkout.models.RequestorAuthenticationIndicatorType

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onPreInitiateAuthentication = {
        Log.d("GooglePay", "Initiating 3DS pre-authentication")
        
        // Track 3DS initiation
        analyticsTracker.trackEvent("3ds_pre_initiate")
        
        PreInitiateIntegratedAuthenticationData(
            providerId = "your-3ds-provider-id", // Optional
            requestorAuthenticationIndicator = RequestorAuthenticationIndicatorType.PAYMENT_TRANSACTION,
            timeout = 300 // 5 minutes
        )
    }
}

onPostInitiateAuthentication: ((AuthenticationResult) -> Unit)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onPostInitiateAuthentication = { result ->
        when (result) {
            is FailedAuthenticationResult -> {
                Log.e("GooglePay", "3DS pre-initiation failed: ${result.errorReason}")
            }
            is MerchantAuthenticationResult -> {
                Log.d("GooglePay", "Pre-authentication complete: ${result.authenticationId}")
                Log.d("GooglePay", "3DS supported: ${result.threeDSecureSupported}")

                if (result.authenticationId.isNullOrEmpty() && !result.threeDSecureSupported) {
                    return@onPostInitiateAuthentication
                }

                val authId = result.authenticationId ?: return@onPostInitiateAuthentication

                lifecycleScope.launch {
                    try {
                        val authResult = fetchAuthenticationResultFromBackend(authId)

                        if (authResult.state == "PendingClientData") {
                            Log.d("GooglePay", "Waiting for client data collection")
                        }

                        if (authResult.scaMandated) {
                            Log.d("GooglePay", "SCA is required - 3DS must complete successfully")
                            withContext(Dispatchers.Main) {
                                showMessage("Additional verification required")
                            }
                        }

                        evaluateAuthenticationAndUpdateSession(authResult)
                    } catch (e: Exception) {
                        Log.e("GooglePay", "Error retrieving authentication result", e)
                    }
                }
            }
        }
    }
}

onPreAuthentication: (suspend () -> InitiateIntegratedAuthenticationData?)?

import com.pxp.checkout.services.models.authentication.InitiateIntegratedAuthenticationData
import com.pxp.checkout.models.RequestorChallengeIndicatorType
import com.pxp.checkout.components.threeds.ChallengeWindowSize

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onPreAuthentication = suspend {
        Log.d("GooglePay", "Configuring 3DS authentication")
        
        // Get authentication decision from backend
        val decision = getAuthenticationDecision()
        
        if (decision == null) {
            Log.d("GooglePay", "Skipping authentication based on backend decision")
            return@suspend null
        }
        
        // Assess transaction risk
        val amount = getTransactionAmount()
        val customerHistory = getCustomerHistory()
        val isHighRisk = amount > 500.0 || customerHistory.chargebacks > 0
        
        // Determine challenge indicator
        val challengeIndicator = when {
            isHighRisk -> RequestorChallengeIndicatorType.CHALLENGE_REQUESTED_MANDATE
            amount < 30.0 && customerHistory.successfulTransactions > 10 -> 
                RequestorChallengeIndicatorType.NO_CHALLENGE_REQUESTED
            else -> RequestorChallengeIndicatorType.NO_PREFERENCE
        }
        
        Log.d("GooglePay", "Challenge indicator: $challengeIndicator")
        
        InitiateIntegratedAuthenticationData(
            merchantCountryNumericCode = "826", // United Kingdom
            merchantLegalName = "Your Store Limited",
            challengeWindowSize = ChallengeWindowSize.FULL_SCREEN,
            requestorChallengeIndicator = challengeIndicator,
            timeout = if (decision.scaMandated) 600 else 300,
            billingAddress = getBillingAddress()?.let {
                BillingAddress(
                    city = it.city,
                    countryNumericCode = it.countryCode,
                    line1 = it.streetAddress,
                    postalCode = it.postalCode
                )
            },
            shopper = ShopperData(
                email = getCurrentCustomerEmail(),
                homePhoneNumber = getCurrentCustomerPhone()
            )
        )
    }
}

onPostAuthentication: ((AuthenticationResult) -> Unit)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onPostAuthentication = { data ->
        Log.d("GooglePay", "3DS authentication completed: ${data.authenticationId}")
        
        lifecycleScope.launch {
            try {
                // Retrieve authentication result from backend
                val authResult = fetchAuthenticationResultFromBackend(data.authenticationId)
                
                Log.d("GooglePay", "Authentication result: $authResult")
                
                // Check transaction status
                when (authResult.transactionStatus) {
                    "Y" -> {
                        Log.d("GooglePay", "Authentication successful - no challenge needed")
                        showMessage("Card verified successfully")
                    }
                    "C" -> {
                        if (authResult.state == "AuthenticationSuccessful") {
                            Log.d("GooglePay", "Challenge completed successfully")
                            showMessage("Verification completed")
                        } else {
                            Log.e("GooglePay", "Challenge failed")
                            showError("Verification failed. Please try again.")
                            return@launch // Stop payment
                        }
                    }
                    "N" -> {
                        Log.e("GooglePay", "Authentication failed")
                        showError("Card verification failed")
                        return@launch // Stop payment
                    }
                    "R" -> {
                        Log.e("GooglePay", "Authentication rejected")
                        showError("Payment was rejected by your bank")
                        return@launch // Stop payment
                    }
                }
                
                // Evaluate and update authorisation decision
                evaluateAuthenticationAndUpdateAuthorization(authResult)
                
                Log.d("GooglePay", "Proceeding to final authorisation...")
            } catch (e: Exception) {
                Log.e("GooglePay", "Error processing authentication result", e)
                showError("Authentication processing error")
            }
        }
    }
}

onGetConsent: (() -> Boolean)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    // ... payment configuration
    
    onGetConsent = {
        // Return a default value when not using consent checkbox
        // Set to true to always store tokens, false to never store
        Log.d("GooglePay", "Setting default consent: true")
        true // Always save payment method for this merchant
    }
    
    onPostAuthorisation = { result, paymentData ->
        when (result) {
            is MerchantSubmitResult -> {
                Log.d("GooglePay", "Payment successful, token will be stored")
                // Token storage is handled automatically based on consent
            }
            else -> { /* Handle failure */ }
        }
    }
}

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    // ... payment configuration
    
    onGetConsent = {
        // Check your own custom checkbox
        val consentGiven = customConsentCheckbox.isChecked
        
        if (consentGiven) {
            Log.d("GooglePay", "Customer consented to save payment method")
            
            // Track consent
            analyticsTracker.trackEvent("payment_consent_given") {
                put("timestamp", System.currentTimeMillis())
                put("payment_method", "google-pay")
            }
        } else {
            Log.d("GooglePay", "Customer did not consent to save payment method")
        }
        
        consentGiven
    }
}

// Create consent component
val consentComponent = pxpCheckout.createComponent<
    GooglePayConsentComponent,
    GooglePayConsentConfig
>(
    type = ComponentType.GOOGLE_PAY_CONSENT,
    config = GooglePayConsentConfig(
        label = "Save this payment method for future purchases",
        initialChecked = false
    )
)

// Create Google Pay button with consent
val googlePayConfig = GooglePayButtonComponentConfig().apply {
    // ... payment configuration
    
    // Link the consent component
    googlePayConsentComponent = consentComponent
    
    // This callback will NOT be called because consent component is linked
    onGetConsent = {
        Log.d("GooglePay", "This callback is ignored when component is linked")
        true // This is ignored when consent component is present
    }
}

// The consent component's checked state will be used for token storage

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    // CVC collection strategy
    collectCvc = GooglePayButtonComponentConfig.CvcCollectionStrategy.DEFAULT
    
    // Custom CVC dialog configuration (optional)
    cvcVerificationPopupConfig = CvcVerificationDialogConfig(
        title = "Security Verification",
        description = "Please enter your card's CVV code",
        submitButtonText = "Confirm Payment",
        cancelButtonText = "Go Back",
        
        // Custom styling
        titleStyles = TextStyle(
            fontSize = 20.sp,
            fontWeight = FontWeight.Bold,
            color = Color(0xFF1A237E)
        ),
        
        // CVC input configuration
        cvcComponentConfig = CardCvcComponentConfig().apply {
            label = "CVV"
            showHintIcon = true
            showValidIcon = true
            showMaskToggle = true
        }
    )
}

enum class CvcCollectionStrategy {
    ALWAYS,   // Always show CVC dialog for FPAN
    NEVER,    // Never show CVC dialog
    DEFAULT   // Show CVC only when 3DS not available/skipped
}

onKountCollectStart: ((Any) -> Unit)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onKountCollectStart = { data ->
        Log.d("GooglePay", "Kount fraud detection started")
        
        // Track fraud detection start
        analyticsTracker.trackEvent("kount_collection_start") {
            put("timestamp", System.currentTimeMillis())
        }
        
        // Show fraud check indicator (optional)
        lifecycleScope.launch(Dispatchers.Main) {
            showFraudCheckIndicator()
        }
    }
}

onKountCollectEnd: ((Any) -> Unit)?

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onKountCollectStart = { data ->
        val startTime = System.currentTimeMillis()
        
        // Store start time for duration calculation
        fraudDetectionStartTime = startTime
        
        Log.d("GooglePay", "Kount collection started at $startTime")
    }
    
    onKountCollectEnd = { data ->
        val endTime = System.currentTimeMillis()
        val duration = endTime - fraudDetectionStartTime
        
        Log.d("GooglePay", "Kount collection completed in ${duration}ms")
        
        // Track fraud detection completion
        analyticsTracker.trackEvent("kount_collection_end") {
            put("timestamp", endTime)
            put("duration_ms", duration)
        }
        
        // Hide fraud check indicator
        lifecycleScope.launch(Dispatchers.Main) {
            hideFraudCheckIndicator()
        }
    }
}

private var fraudDetectionStartTime: Long = 0

onPreRetrySoftDecline: ((SubmitResult) -> RetryConfiguration?)?

import com.pxp.checkout.components.googlepay.types.GooglePayButtonComponentConfig
import com.pxp.checkout.services.models.authentication.*
import com.pxp.checkout.models.*
import com.pxp.checkout.components.threeds.ChallengeWindowSize

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    onPreRetrySoftDecline = { result ->
        Log.w("GooglePay", "Soft decline detected, preparing retry")
        Log.w("GooglePay", "Error code: ${result.errorCode}")
        Log.w("GooglePay", "Decline reason: ${result.errorReason}")
        Log.w("GooglePay", "Correlation ID: ${result.correlationId}")
        
        // Track soft decline
        analyticsTracker.trackEvent("payment_soft_decline") {
            put("error_code", result.errorCode)
            put("error_reason", result.errorReason)
            put("correlation_id", result.correlationId)
            put("transaction_id", result.merchantTransactionId)
        }
        
        // Show message to user
        showMessage("Processing payment with additional verification...")
        
        // Retry with forced 3DS challenge
        GooglePayButtonComponentConfig.RetryConfiguration(
            retry = true,
            updatedConfigs = GooglePayButtonComponentConfig.RetryConfiguration.UpdatedConfigs(
                onPreInitiateAuthentication = {
                    PreInitiateIntegratedAuthenticationData(
                        providerId = "pxpfinancial",
                        timeout = 12
                    )
                },
                onPreAuthentication = suspend {
                    InitiateIntegratedAuthenticationData(
                        merchantCountryNumericCode = "826",
                        merchantLegalName = "Your Store Ltd",
                        challengeWindowSize = ChallengeWindowSize.FULL_SCREEN,
                        requestorChallengeIndicator = 
                            RequestorChallengeIndicatorType.CHALLENGE_REQUESTED_MANDATE,
                        timeout = 300
                    )
                }
            )
        )
        
        // Alternative: Don't retry
        // GooglePayButtonComponentConfig.RetryConfiguration(retry = false)
    }
}

import androidx.compose.foundation.layout.*
import androidx.compose.material3.*
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.unit.dp
import com.pxp.PxpCheckout
import com.pxp.checkout.components.googlepay.*
import com.pxp.checkout.components.googlepay.types.*
import com.pxp.checkout.models.*
import com.pxp.checkout.services.kount.*
import com.pxp.checkout.types.ComponentType
import kotlinx.coroutines.CompletableDeferred

@Composable
fun GooglePayPaymentScreen(
    pxpCheckout: PxpCheckout,
    amount: Double,
    onSuccess: (String) -> Unit,
    onError: (String) -> Unit
) {
    var errorMessage by remember { mutableStateOf<String?>(null) }
    var isProcessing by remember { mutableStateOf(false) }
    
    val googlePayComponent = remember {
        pxpCheckout.createComponent<
            GooglePayButtonComponent,
            GooglePayButtonComponentConfig
        >(
            type = ComponentType.GOOGLE_PAY_BUTTON,
            config = GooglePayButtonComponentConfig().apply {
                
                // Payment configuration
                style = GooglePayButtonStyle(
                    type = GooglePayButtonType.PAY,
                    theme = GooglePayButtonTheme.DARK,
                    cornerRadius = 8
                )
                
                paymentDataRequest = PaymentDataRequest(
                    allowedPaymentMethods = listOf(
                        PaymentMethodSpecification(
                            parameters = PaymentMethodParameters(
                                allowedAuthMethods = listOf(
                                    CardAuthMethod.PAN_ONLY,
                                    CardAuthMethod.CRYPTOGRAM_3DS
                                ),
                                allowedCardNetworks = listOf(
                                    CardNetwork.VISA,
                                    CardNetwork.MASTERCARD,
                                    CardNetwork.AMEX
                                )
                            )
                        )
                    ),
                    transactionInfo = TransactionInfo(
                        currencyCode = "GBP",
                        totalPriceStatus = TotalPriceStatus.FINAL,
                        totalPrice = amount.toString(),
                        countryCode = "GB"
                    ),
                    emailRequired = true
                )
                
                // Enable 3DS with Unity strategy
                useUnityAuthenticationStrategy = true
                collectCvc = GooglePayButtonComponentConfig.CvcCollectionStrategy.DEFAULT
                
                // Button click callback
                onGooglePaymentButtonClicked = {
                    Log.d("GooglePay", "Button clicked")
                    isProcessing = true
                    errorMessage = null
                    CompletableDeferred(Unit)
                }
                
                // Pre-authorisation callback
                onPreAuthorisation = suspend { data ->
                    Log.d("GooglePay", "Pre-authorisation: ${data?.gatewayTokenId}")
                    
                    GooglePayTransactionInitData(
                        riskScreeningData = RiskScreeningData(
                            performRiskScreening = true,
                            excludeDeviceData = false,
                            userIp = "192.168.1.100",
                            account = RiskScreeningAccount(
                                id = "user_12345678",
                                creationDateTime = "2024-01-15T10:30:00.000Z"
                            ),
                            fulfillments = listOf(
                                RiskScreeningFulfillment(
                                    type = FulfillmentType.SHIPPED,
                                    recipientPerson = RiskScreeningRecipientPerson(
                                        phoneNumber = "+1234567890"
                                    )
                                )
                            )
                        )
                    )
                }
                
                // Post-authorisation callback
                onPostAuthorisation = { result, paymentData ->
                    isProcessing = false
                    
                    when (result) {
                        is MerchantSubmitResult -> {
                            Log.d("GooglePay", "Payment successful")
                            onSuccess(result.merchantTransactionId)
                        }
                        is FailedSubmitResult -> {
                            Log.e("GooglePay", "Payment failed: ${result.errorReason}")
                            errorMessage = result.errorReason
                            onError(result.errorReason)
                        }
                    }
                }
                
                // Error callback
                onError = { error ->
                    Log.e("GooglePay", "Error: ${error.message}", error)
                    isProcessing = false
                    errorMessage = error.message
                    onError(error.message ?: "Payment error")
                }
                
                // Cancel callback
                onCancel = {
                    Log.d("GooglePay", "Payment cancelled")
                    isProcessing = false
                    errorMessage = "Payment cancelled"
                }
            }
        )
    }
    
    Column(
        modifier = Modifier
            .fillMaxWidth()
            .padding(16.dp),
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Text(
            text = "Complete Your Payment",
            style = MaterialTheme.typography.headlineMedium
        )
        
        Spacer(modifier = Modifier.height(16.dp))
        
        Text(
            text = "£${amount}",
            style = MaterialTheme.typography.displaySmall
        )
        
        Spacer(modifier = Modifier.height(24.dp))
        
        // Render Google Pay button
        googlePayComponent?.Content(
            modifier = Modifier.fillMaxWidth()
        )
        
        // Error message
        errorMessage?.let { error ->
            Spacer(modifier = Modifier.height(16.dp))
            Text(
                text = error,
                color = MaterialTheme.colorScheme.error,
                style = MaterialTheme.typography.bodyMedium
            )
        }
        
        // Processing indicator
        if (isProcessing) {
            Spacer(modifier = Modifier.height(16.dp))
            CircularProgressIndicator()
        }
    }
}

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.ktx.Firebase

val analytics = Firebase.analytics

val googlePayConfig = GooglePayButtonComponentConfig().apply {
    
    onGooglePaymentButtonClicked = {
        // Track button click
        analytics.logEvent("google_pay_button_clicked", Bundle().apply {
            putLong("timestamp", System.currentTimeMillis())
            putString("currency", "GBP")
            putDouble("amount", 99.99)
        })
        CompletableDeferred(Unit)
    }
    
    onPostAuthorisation = { result, paymentData ->
        when (result) {
            is MerchantSubmitResult -> {
                // Track successful payment
                analytics.logEvent("google_pay_payment_success", Bundle().apply {
                    putString("transaction_id", result.merchantTransactionId)
                    putString("system_transaction_id", result.systemTransactionId)
                })
            }
            is FailedSubmitResult -> {
                // Track failed payment
                analytics.logEvent("google_pay_payment_failed", Bundle().apply {
                    putString("error_code", result.errorCode)
                    putString("error_reason", result.errorReason)
                    putString("correlation_id", result.correlationId)
                })
            }
        }
    }
    
    onError = { error ->
        // Track errors
        analytics.logEvent("google_pay_error", Bundle().apply {
            putString("error_type", error::class.simpleName)
            putString("error_message", error.message)
        })
    }
    
    onCancel = {
        // Track cancellations
        analytics.logEvent("google_pay_cancelled", Bundle().apply {
            putLong("timestamp", System.currentTimeMillis())
        })
    }
}