Configuration

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.ui.Modifier
import com.pxp.checkout.checkoutdropin.CheckoutDropIn
import com.pxp.checkout.checkoutdropin.types.CheckoutDropInConfig
import com.pxp.checkout.models.DropInTransactionData
import com.pxp.checkout.models.DropInTransactionIntentData
import com.pxp.checkout.models.*
import com.pxp.checkout.checkoutdropin.types.*

val checkoutDropIn = CheckoutDropIn.initialize(
    context = context,
    config = CheckoutDropInConfig(
        // REQUIRED
        environment = Environment.TEST,
        session = sessionData,
        ownerType = "MerchantGroup",
        ownerId = "MERCHANT-1",
        transactionData = DropInTransactionData(
            amount = 99.99,
            currency = "USD",
            entryType = EntryType.Ecom,
            intent = DropInTransactionIntentData(
                card = IntentType.Authorisation,
                paypalDropInIntent = DropInPayPalIntentType.Authorisation
            ),
            merchant = "MERCHANT-1",
            merchantTransactionId = UUID.randomUUID().toString(),
            merchantTransactionDate = { Instant.now().toString() }
        ),
        
        // OPTIONAL: Fraud detection
        kountDisabled = false, // Set to true to disable Kount fraud detection
        
        // REQUIRED: Callbacks
        onSuccess = { result -> /* ... */ },
        onError = { error -> /* ... */ },
        
        // OPTIONAL: Callbacks
        onGetShopper = { Shopper(id = "shopper-123") },
        onBeforeSubmit = { paymentMethod -> /* return true to proceed */ },
        onSubmit = { paymentMethod -> /* ... */ },
        analyticsEvent = { event -> /* ... */ }
    )
)

// Create the component from a coroutine
val component = checkoutDropIn.create()

// Render in Compose UI
component.Content(modifier = Modifier.fillMaxWidth())

environment = Environment.TEST // or Environment.LIVE

// Backend endpoint
val sessionData = fetchSessionFromBackend()

// Pass to Drop-in
session = sessionData

ownerType = "MerchantGroup",
ownerId = "MERCHANT-1"

transactionData = DropInTransactionData(
    amount = 99.99,
    currency = "USD",
    entryType = EntryType.Ecom,
    intent = DropInTransactionIntentData(
        card = IntentType.Authorisation,
        paypalDropInIntent = DropInPayPalIntentType.Authorisation
    ),
    merchant = "MERCHANT-1",
    merchantTransactionId = UUID.randomUUID().toString(),
    merchantTransactionDate = { Instant.now().toString() }
)

merchantTransactionId = UUID.randomUUID().toString()

// Or use your own format
merchantTransactionId = "order-${orderId}"

CheckoutDropInConfig(
    // OPTIONAL: Get shopper information
    onGetShopper = {
        Shopper(id = "shopper-123")
    },
    
    // REQUIRED: Called when payment succeeds
    onSuccess = { result ->
        Log.d("CheckoutDropIn", "Payment successful: ${result.systemTransactionId}")
        // CRITICAL: Always verify on backend before fulfilling order
        verifyPaymentOnBackend(result)
    },
    
    // REQUIRED: Called when payment fails
    onError = { error ->
        Log.e("CheckoutDropIn", "Payment failed: ${error.code} - ${error.message}")
    },
    
    // OPTIONAL: Called before payment submission (can cancel)
    onBeforeSubmit = { paymentMethod ->
        Log.d("CheckoutDropIn", "Payment method: $paymentMethod")
        // Return false to cancel payment
        true
    },
    
    // OPTIONAL: Called when payment starts processing
    onSubmit = { paymentMethod ->
        Log.d("CheckoutDropIn", "Processing payment...")
    }
)

analyticsEvent = { event ->
    Log.d("Analytics", "Event: ${event.eventName}")
    // Send to your analytics platform
    sendToFirebaseAnalytics(event)
}

methodConfig = DropInMethodConfig(
    global = DropInGlobalConfig(
        acceptedCardNetworks = listOf(
            CardNetworks.VISA,
            CardNetworks.MASTERCARD
        ),
        allowedIssuerCountryCodes = listOf("US", "GB")
    ),
    paypal = DropInPaypalConfig(
        shippingPreference = ShippingPreference.GET_FROM_FILE
    ),
    googlePay = DropInGooglePayConfig(
        collectCvc = CollectCvcMode.DEFAULT,
        billingAddressRequired = true
    ),
    card = DropInCardConfig() // Currently empty marker
)

card = DropInCardConfig() // Empty marker - inherits from global

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.ui.Modifier
import com.pxp.checkout.checkoutdropin.CheckoutDropIn
import com.pxp.checkout.checkoutdropin.types.CheckoutDropInConfig
import com.pxp.checkout.models.DropInTransactionData
import com.pxp.checkout.models.DropInTransactionIntentData
import com.pxp.checkout.models.*
import com.pxp.checkout.checkoutdropin.types.*
import java.time.Instant
import java.util.UUID

// Get session from backend
val sessionData = fetchSessionFromBackend()

// Initialise with minimal config
val checkoutDropIn = CheckoutDropIn.initialize(
    context = context,
    config = CheckoutDropInConfig(
        environment = Environment.TEST,
        session = sessionData,
        ownerType = "MerchantGroup",
        ownerId = "MERCHANT-1",
        transactionData = DropInTransactionData(
            amount = 99.99,
            currency = "USD",
            entryType = EntryType.Ecom,
            intent = DropInTransactionIntentData(
                card = IntentType.Authorisation,
                paypalDropInIntent = DropInPayPalIntentType.Authorisation
            ),
            merchant = "MERCHANT-1",
            merchantTransactionId = UUID.randomUUID().toString(),
            merchantTransactionDate = { Instant.now().toString() }
        ),
        kountDisabled = false, // OPTIONAL: Set to true to disable Kount fraud detection
        onGetShopper = {
            Shopper(id = "shopper-123")
        },
        onSuccess = { result ->
            verifyPaymentOnBackend(result)
        },
        onError = { error ->
            showError(error.message ?: "Payment failed")
        }
    )
)

// Create and render
val component = checkoutDropIn.create()
component.Content(modifier = Modifier.fillMaxWidth())

import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.ui.Modifier
import com.pxp.checkout.checkoutdropin.CheckoutDropIn
import com.pxp.checkout.checkoutdropin.types.*
import com.pxp.checkout.models.*
import java.time.Instant
import java.util.UUID

// Get session from backend
val sessionData = fetchSessionFromBackend()

// Initialise with all callbacks
val checkoutDropIn = CheckoutDropIn.initialize(
    context = context,
    config = CheckoutDropInConfig(
        // REQUIRED
        environment = Environment.LIVE,
        session = sessionData,
        ownerType = "MerchantGroup",
        ownerId = "MERCHANT-1",
        transactionData = DropInTransactionData(
            amount = 149.99,
            currency = "USD",
            entryType = EntryType.Ecom,
            intent = DropInTransactionIntentData(
                card = IntentType.Authorisation,
                paypalDropInIntent = DropInPayPalIntentType.Purchase
            ),
            merchant = "MERCHANT-1",
            merchantTransactionId = "order-${orderId}",
            merchantTransactionDate = { Instant.now().toString() }
        ),
        
        // OPTIONAL: Fraud detection
        kountDisabled = false, // Set to true to disable Kount fraud detection
        
        // CALLBACKS
        onGetShopper = {
            Shopper(id = "shopper-123")
        },
        
        onBeforeSubmit = { paymentMethod ->
            Log.d("CheckoutDropIn", "Payment method selected: $paymentMethod")
            
            // Custom validation
            val isValid = validateOrder(orderId)
            if (!isValid) {
                showToast("Order validation failed")
                return@CheckoutDropInConfig false // Cancel payment
            }
            
            // Check inventory
            val inStock = checkInventory(orderId)
            if (!inStock) {
                showToast("Item is out of stock")
                return@CheckoutDropInConfig false // Cancel payment
            }
            
            true // Proceed with payment
        },
        
        onSubmit = { paymentMethod ->
            Log.d("CheckoutDropIn", "Payment processing started for: $paymentMethod")
            // Show loading spinner
            showLoadingSpinner(true)
        },
        
        onSuccess = { result ->
            Log.d("CheckoutDropIn", "Payment successful: ${result.systemTransactionId}")
            
            showLoadingSpinner(false)
            
            // CRITICAL: Verify on backend before fulfilling
            lifecycleScope.launch {
                try {
                    val verified = verifyPaymentOnBackend(
                        systemTransactionId = result.systemTransactionId,
                        merchantTransactionId = result.merchantTransactionId,
                        orderId = orderId
                    )
                    
                    if (verified.success) {
                        navigateToOrderConfirmation(verified.orderId)
                    } else {
                        showToast("Payment verification failed. Please contact support.")
                    }
                } catch (e: Exception) {
                    Log.e("CheckoutDropIn", "Verification failed", e)
                    showToast("Unable to verify payment. Please contact support.")
                }
            }
        },
        
        onError = { error ->
            Log.e("CheckoutDropIn", "Payment error: ${error.code}")
            showLoadingSpinner(false)
            
            // Show user-friendly error message
            val userMessage = when {
                error.code == "SDK1114" -> "Card verification failed"
                error.code == "SDK1116" -> "Card payment failed"
                error.message?.contains("declined", ignoreCase = true) == true -> 
                    "Card declined. Please try a different card."
                error.message?.contains("insufficient funds", ignoreCase = true) == true -> 
                    "Insufficient funds."
                error.message?.contains("expired", ignoreCase = true) == true -> 
                    "This card has expired."
                error.message?.contains("cvv", ignoreCase = true) == true -> 
                    "Invalid security code."
                else -> error.message ?: "Payment failed. Please try again."
            }
            
            showError(userMessage)
        },
        
        analyticsEvent = { event ->
            // Send to Firebase Analytics
            firebaseAnalytics.logEvent(event.eventName, bundleOf(
                "event_category" to "checkout",
                "event_label" to event.toString()
            ))
            
            // Send to backend
            sendAnalyticsToBackend(event)
        },
        
        // Method-specific configuration
        methodConfig = DropInMethodConfig(
            global = DropInGlobalConfig(
                acceptedCardNetworks = listOf(
                    CardNetworks.VISA,
                    CardNetworks.MASTERCARD,
                    CardNetworks.AMERICAN_EXPRESS
                ),
                allowedCardFundingSource = listOf(
                    CardFundingSource.CREDIT,
                    CardFundingSource.DEBIT
                ),
                allowedIssuerCountryCodes = listOf("US", "GB", "CA"),
                transactionInfo = TransactionInfo(
                    countryCode = "US",
                    merchantDisplayName = "Demo Store",
                    totalLabel = "Total Amount",
                    totalStatus = DropInTotalStatus.FINAL,
                    lineItems = listOf(
                        TransactionLineItem(label = "Products", amount = "5.00"),
                        TransactionLineItem(label = "Shipping", amount = "2.00")
                    )
                ),
                onGetConsent = { paymentMethod ->
                    // Show consent for cards and PayPal
                    paymentMethod == PaymentMethod.CARD || 
                    paymentMethod == PaymentMethod.PAYPAL
                },
                onCancel = { paymentMethod, data ->
                    Log.d("CheckoutDropIn", "Payment cancelled: $paymentMethod")
                    showLoadingSpinner(false)
                    // Track cancellation
                    trackEvent("payment_cancelled", mapOf(
                        "payment_method" to paymentMethod.toString()
                    ))
                }
            ),
            paypal = DropInPaypalConfig(
                shippingPreference = ShippingPreference.GET_FROM_FILE
            ),
            googlePay = DropInGooglePayConfig(
                collectCvc = CollectCvcMode.DEFAULT,
                shippingAddressRequired = true,
                shippingAddressParameters = ShippingAddressParameters(
                    allowedCountryCodes = listOf("US", "GB"),
                    phoneNumberRequired = true
                ),
                billingAddressRequired = true,
                billingAddressParameters = BillingAddressParameters(
                    phoneNumberRequired = true
                )
            ),
            card = DropInCardConfig()
        )
    )
)

// Create and render
val component = checkoutDropIn.create()
component.Content(modifier = Modifier.fillMaxWidth())