Events

val preFillCheckboxConfig = PreFillBillingAddressCheckboxComponentConfig(
    onAddressSync = { event ->
        Log.d("AddressSync", "Starting address sync")
        Log.d("AddressSync", "Source: ${event.sourceAddress}")
        Log.d("AddressSync", "Strategy: ${event.syncStrategy}")
        Log.d("AddressSync", "Fields: ${event.syncedFields.joinToString()}")
        
        // Show loading UI
        showAddressSyncLoading()
        
        // Update progress indicators
        updateSyncProgress(0, event.syncedFields.size)
        
        // Track sync start
        analytics.track("address_sync_started", mapOf(
            "sync_strategy" to event.syncStrategy.name,
            "field_count" to event.syncedFields.size,
            "target_component" to event.targetComponentId
        ))
        
        // Log for debugging
        logSyncOperation("started", event)
    }
)

val cardNumberConfig = CardNumberComponentConfig(
    onBlur = { focusEvent ->
        Log.d("Payment", "Card number field blurred: ${focusEvent.value}")
        Log.d("Payment", "Field valid: ${focusEvent.isValid}")
        
        // Hide input assistance UI
        hideInputHelper()
        
        // Trigger validation if field has content
        if (focusEvent.value.isNotEmpty()) {
            validateCardNumber(focusEvent.value)
        }
        
        // Update UI state
        updateFieldAppearance(focusEvent.fieldName, focused = false)
        
        // Track field completion
        analytics.track("field_blur", mapOf(
            "field" to focusEvent.fieldName,
            "has_value" to focusEvent.value.isNotEmpty(),
            "is_valid" to focusEvent.isValid
        ))
    }
)

val cardNumberConfig = CardNumberComponentConfig(
    onCardBrandCannotRecognised = { event ->
        Log.d("Payment", "Card brand could not be recognised")
        // Show generic card icon or warning
        showUnknownCardBrandWarning()
    }
)

val cardNumberConfig = CardNumberComponentConfig(
    onCardBrandDetected = { event ->
        val cardBrand = event.cardBrand
        val isAccepted = event.isCardBrandAccepted
        Log.d("Payment", "Card brand detected: ${cardBrand.name}, accepted: $isAccepted")
        
        // Update UI to show detected brand
        updateCardBrandIcon(cardBrand)
        
        if (!isAccepted) {
            showCardNotAcceptedMessage(cardBrand)
        }
        
        // Track detection analytics
        analytics.track("card_brand_detected", mapOf(
            "brand" to cardBrand.name,
            "accepted" to isAccepted,
            "confidence" to event.confidence
        ))
    }
)

val dynamicCardImageConfig = DynamicCardImageComponentConfig(
    onCardDetected = { event ->
        Log.d("CardImage", "Card detected: ${event.detectedBrand.displayName}")
        Log.d("CardImage", "Confidence: ${event.confidence}")
        Log.d("CardImage", "Detection time: ${event.detectionTime}ms")
        
        // Update UI based on detected brand
        when (event.detectedBrand) {
            CardBrand.VISA -> {
                updateCardValidation(visaValidationRules)
                enableVisaSpecificFeatures()
            }
            CardBrand.AMERICAN_EXPRESS -> {
                updateCardValidation(amexValidationRules)
                showAmexCvcHelper() // 4-digit CVC
            }
            CardBrand.MASTERCARD -> {
                updateCardValidation(mastercardValidationRules)
                enableMastercardBenefits()
            }
            else -> {
                updateCardValidation(genericValidationRules)
            }
        }
        
        // Announce brand change for accessibility
        if (announceCardChanges) {
            announceToAccessibility("${event.detectedBrand.displayName} card detected")
        }
        
        // Track detection analytics
        if (trackCardDetection) {
            trackAnalyticsEvent("card_brand_detected", mapOf(
                "brand" to event.detectedBrand.displayName,
                "confidence" to event.confidence.toString(),
                "detection_time" to event.detectionTime.toString(),
                "source" to event.source.name
            ))
        }
    }
)

val dynamicCardImageConfig = DynamicCardImageComponentConfig(
    onCardFlipped = { event ->
        Log.d("CardImage", "Card flipped: ${event.cardBrand.displayName}")
        Log.d("CardImage", "Showing back: ${event.showingBack}")
        Log.d("CardImage", "Trigger: ${event.trigger}")
        
        // Update related UI components
        if (event.showingBack) {
            // Highlight CVC field when back is shown
            highlightCvcField()
            showCvcHelper()
        } else {
            // Show card number helper when front is shown
            highlightCardNumberField()
            showCardNumberHelper()
        }
        
        // Provide accessibility feedback
        announceToAccessibility(
            if (event.showingBack) "Showing card back with security code field"
            else "Showing card front with card number"
        )
        
        // Track user engagement
        analytics.track("card_flip", mapOf(
            "showing_back" to event.showingBack,
            "trigger" to event.trigger.name,
            "brand" to event.cardBrand.displayName
        ))
    }
)

val dynamicCardImageConfig = DynamicCardImageComponentConfig(
    onCardInteraction = { event ->
        Log.d("CardImage", "Card interaction: ${event.interactionType}")
        Log.d("CardImage", "Brand: ${event.cardBrand.displayName}")
        
        when (event.interactionType) {
            InteractionType.TAP -> {
                // Simple tap - flip card
                triggerCardFlip()
                provideTapFeedback()
            }
            InteractionType.LONG_PRESS -> {
                // Long press - show card details
                showCardDetailsMenu()
                provideHapticFeedback()
            }
            InteractionType.DOUBLE_TAP -> {
                // Double tap - zoom card
                showCardZoom()
            }
            InteractionType.SWIPE_LEFT -> {
                // Swipe left - previous card style
                switchToPreviousCardStyle()
            }
            InteractionType.SWIPE_RIGHT -> {
                // Swipe right - next card style
                switchToNextCardStyle()
            }
        }
        
        // Track engagement metrics
        analytics.track("card_interaction", mapOf(
            "interaction_type" to event.interactionType.name,
            "brand" to event.cardBrand.displayName,
            "timestamp" to event.timestamp
        ))
    }
)

val cardNumberConfig = CardNumberComponentConfig(
    onChange = { changeEvent ->
        Log.d("Payment", "Card number changed: ${changeEvent.value}")
        Log.d("Payment", "Change type: ${changeEvent.changeType}")
        Log.d("Payment", "Cursor position: ${changeEvent.cursorPosition}")
        
        // Real-time validation and formatting
        val formattedValue = formatCardNumber(changeEvent.value)
        if (formattedValue != changeEvent.value) {
            updateFieldValue(changeEvent.fieldName, formattedValue)
        }
        
        // Detect card brand as user types
        val detectedBrand = detectCardBrand(changeEvent.value)
        updateCardBrandIndicator(detectedBrand)
        
        // Auto-advance when complete
        if (isCardNumberComplete(changeEvent.value) && changeEvent.isValid) {
            advanceToNextField()
        }
        
        // Track typing patterns for UX insights
        analytics.track("field_change", mapOf(
            "field" to changeEvent.fieldName,
            "change_type" to changeEvent.changeType.name,
            "length" to changeEvent.value.length,
            "is_valid" to changeEvent.isValid
        ))
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onSubmitStart = {
        Log.d("Payment", "Payment submission started")
        
        // Show loading indicator
        showPaymentProcessingUI()
        
        // Disable form interactions
        disableAllFormInputs()
        
        // Update UI state
        updateSubmitButtonState(loading = true)
        
        // Track submission attempt
        analytics.track("payment_submission_started", mapOf(
            "timestamp" to System.currentTimeMillis(),
            "payment_method" to getCurrentPaymentMethod()
        ))
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onCollectStart = {
        Log.d("Payment", "Device data collection started")
        
        // Show collection progress
        showMessage("Collecting device information...", MessageType.INFO)
        
        // Update progress indicators
        updateProgressStep("collect", ProgressStepStatus.IN_PROGRESS)
        
        // Track collection start
        analytics.track("device_collection_started", mapOf(
            "timestamp" to System.currentTimeMillis(),
            "session_id" to getCurrentSessionId()
        ))
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onCollectComplete = { collectResult ->
        Log.d("Payment", "Device data collection completed")
        Log.d("Payment", "Risk score: ${collectResult.riskScore}")
        Log.d("Payment", "Collection time: ${collectResult.collectDuration}ms")
        
        // Hide collection progress
        hideDataCollectionIndicator()
        
        // Evaluate risk score
        when {
            collectResult.riskScore > 0.8f -> {
                Log.w("Payment", "High risk transaction detected")
                handleHighRiskTransaction(collectResult)
            }
            collectResult.riskScore > 0.5f -> {
                Log.i("Payment", "Medium risk transaction")
                handleMediumRiskTransaction(collectResult)
            }
            else -> {
                Log.d("Payment", "Low risk transaction")
                proceedWithNormalFlow()
            }
        }
        
        // Track collection performance
        analytics.track("device_collection_completed", mapOf(
            "risk_score" to collectResult.riskScore,
            "duration" to collectResult.collectDuration,
            "data_points" to collectResult.dataPoints,
            "fingerprint_quality" to getFingerprintQuality(collectResult)
        ))
    }
)

val clickOnceConfig = ClickOnceComponentConfig(
    onCvcEntered = { cvcEvent ->
        Log.d("Payment", "CVC has been entered for card: ${cvcEvent.cardToken.maskedPAN}")
        Log.d("Payment", "CVC valid: ${cvcEvent.isValid}")
        
        if (cvcEvent.isValid) {
            // Enable submit button
            enableSubmitButton()
            
            // Clear any previous errors
            clearCvcError()
            
            // Track successful CVC entry
            analytics.track("cvc_entered", mapOf(
                "card_brand" to cvcEvent.cardToken.cardBrand.name,
                "is_valid" to true
            ))
        } else {
            // Show validation errors
            showCvcErrors(cvcEvent.validationErrors)
            
            // Keep submit button disabled
            disableSubmitButton()
        }
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    onDeleteTokenFailed = { response ->
        Log.e("Payment", "Token deletion failed: ${response.error}")
        Log.e("Payment", "Token ID: ${response.tokenId}")
        Log.e("Payment", "Retryable: ${response.retryable}")
        
        // Show appropriate error message
        val errorMessage = when (response.error.code) {
            "NETWORK_ERROR" -> "Network error. Please check your connection and try again."
            "INVALID_TOKEN" -> "This card is no longer valid."
            "INSUFFICIENT_PERMISSIONS" -> "You don't have permission to delete this card."
            else -> "Failed to delete card. Please try again."
        }
        
        showErrorDialog(errorMessage)
        
        // Enable retry if possible
        if (response.retryable) {
            showRetryOption { 
                retryTokenDeletion(response.tokenId)
            }
        }
        
        // Track deletion failures
        analytics.track("token_deletion_failed", mapOf(
            "token_id" to response.tokenId,
            "error_code" to response.error.code,
            "retryable" to response.retryable
        ))
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    onDeleteTokenSuccess = { response ->
        Log.d("Payment", "Token deleted successfully: ${response.tokenId}")
        Log.d("Payment", "Remaining tokens: ${response.remainingTokenCount}")
        
        // Show success message
        showSuccessMessage("Card deleted successfully")
        
        // Refresh the token list
        refreshCardList()
        
        // Update UI if no cards remain
        if (response.remainingTokenCount == 0) {
            showNoCardsMessage()
            hideCardOnFileSection()
        }
        
        // Track successful deletion
        analytics.track("token_deletion_success", mapOf(
            "token_id" to response.tokenId,
            "card_brand" to response.deletedToken.cardBrand.name,
            "remaining_count" to response.remainingTokenCount,
            "deletion_time" to response.deletionTime
        ))
        
        // Announce to accessibility services
        announceToAccessibility("Card deleted successfully")
    }
)

val cardNumberConfig = CardNumberComponentConfig(
    onFocus = { focusEvent ->
        Log.d("Payment", "Card number field focused")
        Log.d("Payment", "Current value: ${focusEvent.value}")
        Log.d("Payment", "Previous focus: ${focusEvent.previousFocusTarget}")
        
        // Show input hints or help text
        showCardNumberInputHelper()
        
        // Update field appearance
        updateFieldAppearance(focusEvent.fieldName, focused = true)
        
        // Show numeric keyboard for card number
        showNumericKeyboard()
        
        // Track field focus for UX analytics
        analytics.track("field_focus", mapOf(
            "field" to focusEvent.fieldName,
            "has_value" to focusEvent.value.isNotEmpty(),
            "previous_field" to focusEvent.previousFocusTarget
        ))
        
        // Announce to accessibility services
        announceToAccessibility("Card number field focused. Enter your card number")
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onGetFingerprintResult = {
        // Return fingerprint data as a string
        return@CardSubmitComponentConfig getDeviceFingerprintData()
    }
)

private suspend fun getDeviceFingerprintData(): String {
    // Implement device fingerprinting logic
    return deviceFingerprintService.collectFingerprint()
}

val dynamicCardImageConfig = DynamicCardImageComponentConfig(
    onImageError = { event ->
        Log.e("CardImage", "Image load failed for ${event.cardBrand.displayName}")
        Log.e("CardImage", "Error: ${event.error}")
        Log.e("CardImage", "Retry attempt: ${event.retryAttempt}")
        
        when (event.error) {
            ImageError.NETWORK_ERROR -> {
                if (event.canRetry && event.retryAttempt < 3) {
                    // Retry with exponential backoff
                    retryImageLoad(event.cardBrand, event.retryAttempt)
                } else {
                    // Use cached fallback image
                    loadFallbackImage(event.cardBrand)
                }
            }
            ImageError.NOT_FOUND -> {
                // Use generic card image
                loadGenericCardImage()
                reportMissingImage(event.cardBrand)
            }
            ImageError.TIMEOUT -> {
                // Show loading state and retry
                showImageLoadingState()
                retryImageLoad(event.cardBrand, event.retryAttempt)
            }
            else -> {
                // Use fallback and log error
                loadFallbackImage(event.cardBrand)
                logImageError(event)
            }
        }
        
        // Track error metrics
        analytics.track("image_load_error", mapOf(
            "brand" to event.cardBrand.displayName,
            "error_type" to event.error.name,
            "retry_attempt" to event.retryAttempt,
            "can_retry" to event.canRetry
        ))
    }
)

val dynamicCardImageConfig = DynamicCardImageComponentConfig(
    onImageLoaded = { event ->
        Log.d("CardImage", "Image loaded: ${event.cardBrand.displayName}")
        Log.d("CardImage", "Load time: ${event.loadTime}ms")
        Log.d("CardImage", "From cache: ${event.fromCache}")
        Log.d("CardImage", "Image size: ${formatFileSize(event.imageSize)}")
        
        // Hide loading indicators
        hideImageLoadingState()
        
        // Update image cache statistics
        updateCacheStats(event.fromCache, event.loadTime, event.imageSize)
        
        // Track loading performance
        if (trackImageLoading) {
            trackPerformanceMetric("image_load_time", event.loadTime)
            trackPerformanceMetric("image_cache_hit", if (event.fromCache) 1 else 0)
            trackPerformanceMetric("image_size", event.imageSize)
        }
        
        // Optimize future loading based on performance
        if (event.loadTime > SLOW_LOAD_THRESHOLD) {
            considerImageQualityReduction()
        }
        
        // Preload related images if performance is good
        if (event.loadTime < FAST_LOAD_THRESHOLD && !event.fromCache) {
            preloadRelatedBrandImages()
        }
        
        // Update accessibility
        updateImageAccessibilityDescription(event.cardBrand)
        
        // Analytics tracking
        analytics.track("image_loaded", mapOf(
            "brand" to event.cardBrand.displayName,
            "load_time" to event.loadTime,
            "from_cache" to event.fromCache,
            "size" to event.imageSize,
            "resolution" to "${event.resolution.width}x${event.resolution.height}"
        ))
    }
)

val clickOnceConfig = ClickOnceComponentConfig(
    onOnceCardClick = { event ->
        Log.d("Payment", "User selected saved card: ${event.maskedNumber}")
        Log.d("Payment", "Card brand: ${event.cardBrand.displayName}")
        
        // Update UI to show selected card
        updateSelectedCardDisplay(event)
        
        // Handle CVC requirement
        if (event.requiresCvc) {
            showCvcInput()
            focusCvcField()
        } else {
            hideCvcInput()
            enableSubmitButton()
        }
        
        // Track user preferences
        analytics.track("saved_card_selected", mapOf(
            "brand" to event.cardBrand.displayName,
            "is_default" to event.isDefault,
            "requires_cvc" to event.requiresCvc
        ))
    }
)

val countrySelectionConfig = CountrySelectionComponentConfig(
    onCountryDeselected = { event ->
        Log.d("Country", "Country deselected: ${event.deselectedCountry.name}")
        Log.d("Country", "Reason: ${event.reason}")
        
        // Clear dependent fields
        when (event.deselectedCountry.code) {
            "US" -> {
                clearStateField()
                clearZipCodeField()
                hideStateSelector()
            }
            "CA" -> {
                clearProvinceField()
                clearPostalCodeField()
                hideProvinceSelector()
            }
            "GB" -> {
                clearCountyField()
                clearPostcodeField()
            }
        }
        
        // Reset address validation
        resetAddressValidation()
        
        // Update form layout
        updateFormLayout(null)
        
        // Track deselection analytics
        analytics.track("country_deselected", mapOf(
            "country" to event.deselectedCountry.code,
            "reason" to event.reason.name,
            "previous_method" to event.previousSelectionMethod?.name
        ))
    }
)

val countrySelectionConfig = CountrySelectionComponentConfig(
    onCountrySelected = { event ->
        Log.d("Country", "Country selected: ${event.selectedCountry.name}")
        Log.d("Country", "Selection method: ${event.selectionMethod}")
        
        // Configure country-specific fields
        when (event.selectedCountry.code) {
            "US" -> {
                showStateField()
                showZipCodeField()
                updatePhoneFormat(PhoneFormat.US)
                setAddressValidation(USAddressValidator())
            }
            "CA" -> {
                showProvinceField()
                showPostalCodeField()
                updatePhoneFormat(PhoneFormat.CA)
                setAddressValidation(CanadaAddressValidator())
            }
            "GB" -> {
                showCountyField()
                showPostcodeField()
                updatePhoneFormat(PhoneFormat.UK)
                setAddressValidation(UKAddressValidator())
            }
            else -> {
                configureGenericFields()
                setAddressValidation(GenericAddressValidator())
            }
        }
        
        // Update currency if needed
        updateCurrencyForCountry(event.selectedCountry)
        
        // Update form labels and placeholders
        updateFormLabelsForCountry(event.selectedCountry)
        
        // Track selection analytics
        analytics.track("country_selected", mapOf(
            "country" to event.selectedCountry.code,
            "country_name" to event.selectedCountry.name,
            "selection_method" to event.selectionMethod.name,
            "user_initiated" to event.userInitiated,
            "previous_country" to event.previousCountry?.code
        ))
        
        // Announce selection for accessibility
        announceToAccessibility("Selected ${event.selectedCountry.name}")
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onPostAuthentication = { authResult ->
        Log.d("Payment", "3DS authentication completed: $authResult")
        when (authResult.status) {
            AuthenticationStatus.AUTHENTICATED -> {
                showMessage("Authentication successful", MessageType.SUCCESS)
            }
            AuthenticationStatus.FAILED -> {
                showMessage("Authentication failed", MessageType.ERROR)
            }
        }
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onPostAuthorisation = { result ->
        when (result.state) {
            AuthorisationState.AUTHORISED -> {
                // Payment successful
                showSuccessDialog("Payment successful!")
                navigateToSuccessScreen()
            }
            AuthorisationState.DECLINED -> {
                // Payment failed
                showErrorDialog("Payment failed. Please try again.")
            }
        }
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onPostInitiateAuthentication = { authResult ->
        Log.d("Payment", "3DS authentication initiated: $authResult")
        when (authResult.status) {
            AuthenticationStatus.CHALLENGE_REQUIRED -> {
                showMessage("Please complete 3DS verification", MessageType.INFO)
            }
        }
    }
)

val newCardConfig = NewCardComponentConfig(
    onPostTokenisation = { tokenData ->
        Log.d("Payment", "Card tokenised: $tokenData")
        // Store token reference or proceed to payment
        handleTokenisation(tokenData)
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onPreAuthentication = { preAuthData ->
        Log.d("Payment", "Starting 3DS authentication: $preAuthData")
        return@CardSubmitComponentConfig AuthenticationConfig(
            acquirerProfileId = "your-acquirer-id",
            providerId = "your-provider-id",
            timeout = 30
        )
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onPreAuthorisation = { data ->
        Log.d("Payment", "Pre-authorisation data: $data")
        return@CardSubmitComponentConfig AuthorisationData(
            addressVerification = AddressVerification(
                countryCode = "US",
                houseNumberOrName = "123 Main St",
                postalCode = "12345"
            )
        )
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    onPreDeleteToken = { token ->
        val confirmed = showConfirmationDialog(
            title = "Delete Card",
            message = "Delete card ending in ${token.maskedPrimaryAccountNumber.takeLast(4)}?",
            positiveButton = "Delete",
            negativeButton = "Cancel"
        )
        return@CardOnFileComponentConfig confirmed
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onPreInitiateAuthentication = {
        return@CardSubmitComponentConfig AuthenticationInitData(
            threeDSecureVersion = "2.1.0",
            merchantName = "Your Store"
        )
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onPreTokenisation = {
        Log.d("Payment", "About to tokenise card")
        // Check business rules before tokenisation
        return@CardSubmitComponentConfig validateBusinessRules()
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    onPreRenderTokens = { response ->
        // Filter only Visa cards and mark them as requiring CVC
        return@CardOnFileComponentConfig response.gatewayTokens
            .filter { token -> token.scheme == CardBrand.VISA }
            .map { token ->
                CardTokenMapping(
                    id = token.gatewayTokenId,
                    isCvcRequired = true,
                    displayLabel = buildCustomLabel(token)
                )
            }
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    onRetrieveTokensFailed = { response ->
        Log.e("Payment", "Failed to retrieve tokens: ${response.error}")
        // Show fallback UI or error message
        showErrorMessage("Unable to load saved cards. Please try again.")
    }
)

val cardSubmitConfig = CardSubmitComponentConfig(
    onSubmitError = { error ->
        Log.e("Payment", "Submit error: ${error.message}")
        Log.e("Payment", "Error type: ${error.errorType}")
        Log.e("Payment", "Retryable: ${error.retryable}")
        
        // Show appropriate error message based on error type
        val userMessage = when (error.errorType) {
            ErrorType.NETWORK -> "Network error. Please check your connection and try again."
            ErrorType.SERVER -> "Server error. Please try again in a moment."
            ErrorType.VALIDATION -> "Please check your payment information and try again."
            ErrorType.PAYMENT_DECLINED -> "Payment was declined. Please try a different card."
            ErrorType.AUTHENTICATION -> "Authentication failed. Please verify your details."
            else -> "Payment failed. Please try again."
        }
        
        showErrorDialog(userMessage)
        
        // Enable retry if appropriate
        if (error.retryable) {
            showRetryOption {
                retryPaymentSubmission()
            }
        } else {
            // Suggest alternative payment methods
            showAlternativePaymentOptions()
        }
        
        // Track submission errors
        analytics.track("payment_submission_failed", mapOf(
            "error_code" to error.code,
            "error_type" to error.errorType.name,
            "retryable" to error.retryable,
            "payment_method" to getCurrentPaymentMethod()
        ))
        
        handlePaymentError(error)
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    onUpdateTokenFailed = { response ->
        Log.e("Payment", "Token update failed: ${response.error}")
        // Show error message to user
        showErrorMessage("Failed to update card information")
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    onUpdateTokenSuccess = { response ->
        Log.d("Payment", "Token updated successfully: $response")
        // Refresh display with new information
        showSuccessMessage("Card information updated")
        refreshCardDisplay()
    }
)

val newCardConfig = NewCardComponentConfig(
    onValidation = { validationEvent ->
        Log.d("Payment", "Form validation triggered")
        Log.d("Payment", "Form valid: ${validationEvent.isFormValid}")
        Log.d("Payment", "Error count: ${validationEvent.errorCount}")
        
        // Update submit button state
        updateSubmitButtonState(validationEvent.isFormValid)
        
        // Process each field's validation result
        validationEvent.validationResults.forEach { result ->
            if (!result.isValid && result.errors.isNotEmpty()) {
                result.errors.forEach { error ->
                    Log.e("Validation", "${result.fieldName}: ${error.message} (${error.code})")
                    showFieldError(result.fieldName, error.message)
                }
            } else {
                clearFieldError(result.fieldName)
            }
        }
        
        // Track validation metrics
        analytics.track("form_validation", mapOf(
            "is_valid" to validationEvent.isFormValid,
            "error_count" to validationEvent.errorCount,
            "field_count" to validationEvent.fieldCount,
            "trigger_source" to validationEvent.triggerSource
        ))
    }
)

val cardNumberConfig = CardNumberComponentConfig(
    onValidationFailed = { validationResult ->
        Log.e("Validation", "Card number validation failed")
        Log.e("Validation", "Errors: ${validationResult.errors}")
        
        // Show specific error message
        val primaryError = validationResult.errors.firstOrNull()
        if (primaryError != null) {
            showFieldError("card_number", primaryError.message)
        }
        
        // Update field appearance
        updateFieldAppearance("card_number", hasError = true)
        
        // Disable submit if needed
        if (validationResult.blockSubmission) {
            disableSubmitButton()
        }
        
        // Track validation failures
        analytics.track("field_validation_failed", mapOf(
            "field" to "card_number",
            "error_codes" to validationResult.errors.map { it.code },
            "trigger" to validationResult.validationTrigger
        ))
    }
)

val cardNumberConfig = CardNumberComponentConfig(
    onValidationPassed = { validationResult ->
        Log.d("Validation", "Card number validation passed")
        Log.d("Validation", "Value: ${validationResult.value}")
        
        // Clear any error states
        clearFieldError("card_number")
        
        // Update field appearance to show success
        updateFieldAppearance("card_number", hasError = false, isValid = true)
        
        // Check if all fields are now valid
        if (isFormValid()) {
            enableSubmitButton()
        }
        
        // Auto-advance to next field if configured
        if (shouldAutoAdvance()) {
            focusNextField("expiry_date")
        }
        
        // Track successful validation
        analytics.track("field_validation_passed", mapOf(
            "field" to "card_number",
            "validation_duration" to validationResult.validationDuration,
            "trigger" to validationResult.validationTrigger
        ))
    }
)

val cardOnFileConfig = CardOnFileComponentConfig(
    tokenItemBuilder = { elementIds ->
        // Return a custom Composable for the token item
        @Composable
        fun CustomTokenItem() {
            Row(
                modifier = Modifier
                    .fillMaxWidth()
                    .padding(12.dp),
                verticalAlignment = Alignment.CenterVertically
            ) {
                // Card brand image
                AsyncImage(
                    model = elementIds.tokenImageId,
                    contentDescription = "Card brand",
                    modifier = Modifier.size(32.dp)
                )
                
                Spacer(modifier = Modifier.width(12.dp))
                
                // Card label
                Text(
                    text = elementIds.tokenLabelId,
                    modifier = Modifier.weight(1f),
                    style = MaterialTheme.typography.bodyMedium
                )
                
                // Expiry date
                Text(
                    text = elementIds.expiryDateId,
                    style = MaterialTheme.typography.bodySmall,
                    color = MaterialTheme.colorScheme.onSurfaceVariant
                )
                
                Spacer(modifier = Modifier.width(8.dp))
                
                // Action buttons
                Row {
                    IconButton(onClick = { /* Edit action */ }) {
                        Icon(Icons.Default.Edit, contentDescription = "Edit")
                    }
                    IconButton(onClick = { /* Delete action */ }) {
                        Icon(Icons.Default.Delete, contentDescription = "Delete")
                    }
                }
            }
        }
        
        return@CardOnFileComponentConfig CustomTokenItem()
    }
)