{
  "name": "John Smith",
  "paymentToken": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJHb29nbGUiLCJhdWQiOiJtZXJjaGFudC5leGFtcGxlLmNvbSIsInBheW1lbnRNZXRob2QiOnsiZGlzcGxheU5hbWUiOiJWaXNhIOKAoiDigoExMjM0IiwidHlwZSI6IkNBUkQifX0",
  "email": "john@example.com",
  "phoneNumber": "+1234567890",
  "address": "123 Main Street",
  "city": "New York",
  "state": "NY",
  "postalCode": "10001",
  "country": "US",
  "amount": 99.99,
  "unit": "USD",
  "originDomain": "shop.example.com",
  "referenceId": "GPY-54321",
  "notifyUrl": "https://api.example.com/webhook",
  "successUrl": "https://shop.example.com/success",
  "failureUrl": "https://shop.example.com/failure",
  "browserInfo": {
    "browserAcceptHeader": "application/json, text/plain, */*",
    "browserColorDepth": "24",
    "browserIP": "192.168.1.100",
    "browserJavaEnabled": false,
    "browserJavascriptEnabled": true,
    "browserLanguage": "en-US",
    "browserScreenHeight": "1080",
    "browserScreenWidth": "1920",
    "browserTZ": "-300",
    "browserUserAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
  }
}

// Google Pay API configuration
const baseRequest = {
  apiVersion: 2,
  apiVersionMinor: 0
};

const allowedCardNetworks = ["AMEX", "DISCOVER", "JCB", "MASTERCARD", "VISA"];
const allowedCardAuthMethods = ["PAN_ONLY", "CRYPTOGRAM_3DS"];

const tokenizationSpecification = {
  type: 'PAYMENT_GATEWAY',
  parameters: {
    'gateway': 'caibo',
    'gatewayMerchantId': process.env.Caibo_MERCHANT_ID
  }
};

const baseCardPaymentMethod = {
  type: 'CARD',
  parameters: {
    allowedAuthMethods: allowedCardAuthMethods,
    allowedCardNetworks: allowedCardNetworks
  }
};

const cardPaymentMethod = Object.assign(
  {},
  baseCardPaymentMethod,
  {
    tokenizationSpecification: tokenizationSpecification
  }
);

const paymentDataRequest = Object.assign({}, baseRequest);
paymentDataRequest.allowedPaymentMethods = [cardPaymentMethod];
paymentDataRequest.transactionInfo = {
  totalPriceStatus: 'FINAL',
  totalPriceLabel: 'Total',
  totalPrice: '99.99',
  currencyCode: 'USD',
  countryCode: 'US'
};

paymentDataRequest.merchantInfo = {
  merchantId: process.env.GOOGLE_PAY_MERCHANT_ID,
  merchantName: 'Example Store'
};

// Initialize Google Pay
function initializeGooglePay() {
  const paymentsClient = new google.payments.api.PaymentsClient({
    environment: 'TEST' // Change to 'PRODUCTION' for live
  });

  return paymentsClient;
}

// Process Google Pay payment
async function processGooglePayPayment(paymentData, customerInfo) {
  const apiEndpoint = process.env.Caibo_H2H_ENDPOINT;
  const apiKey = process.env.Caibo_API_KEY;
  
  try {
    const response = await fetch(apiEndpoint, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-API-Key': apiKey
      },
      body: JSON.stringify({
        // Google Pay specific
        name: customerInfo.name,
        paymentToken: paymentData.paymentMethodData.tokenizationData.token,
        
        // Customer info
        email: customerInfo.email,
        phoneNumber: customerInfo.phoneNumber,
        address: customerInfo.address.street,
        city: customerInfo.address.city,
        state: customerInfo.address.state,
        postalCode: customerInfo.address.postalCode,
        country: customerInfo.address.country,
        
        // Transaction
        amount: paymentData.transactionInfo.totalPrice,
        unit: paymentData.transactionInfo.currencyCode,
        originDomain: window.location.hostname,
        referenceId: customerInfo.orderId,
        
        // URLs
        notifyUrl: customerInfo.webhookUrl,
        successUrl: customerInfo.successUrl,
        failureUrl: customerInfo.failureUrl,
        
        // Browser info
        browserInfo: collectBrowserInfo()
      })
    });
    
    const result = await response.json();
    
    if (response.ok) {
      return {
        success: true,
        paymentRequestId: result.paymentRequestId,
        status: result.status,
        transactionId: result.transactionId
      };
    } else {
      return {
        success: false,
        error: result.error,
        message: result.message
      };
    }
  } catch (error) {
    return {
      success: false,
      error: 'NETWORK_ERROR',
      message: error.message
    };
  }
}

// Complete Google Pay flow
async function handleGooglePayPayment() {
  const paymentsClient = initializeGooglePay();
  
  try {
    // Request payment data from Google Pay
    const paymentData = await paymentsClient.loadPaymentData(paymentDataRequest);
    
    // Process payment with Caibo
    const result = await processGooglePayPayment(paymentData, {
      name: 'John Smith',
      email: 'john@example.com',
      phoneNumber: '+1234567890',
      address: {
        street: '123 Main Street',
        city: 'New York',
        state: 'NY',
        postalCode: '10001',
        country: 'US'
      },
      orderId: 'GPY-54321',
      webhookUrl: 'https://api.example.com/webhook',
      successUrl: 'https://shop.example.com/success',
      failureUrl: 'https://shop.example.com/failure'
    });
    
    if (result.success) {
      // Payment successful
      window.location.href = '/success?id=' + result.paymentRequestId;
    } else {
      // Handle payment error
      displayError(result.message);
    }
  } catch (error) {
    console.error('Google Pay error:', error);
    displayError('Google Pay payment failed');
  }
}

// Google Pay Android integration
class GooglePayActivity : AppCompatActivity() {
    private lateinit var paymentsClient: PaymentsClient
    private val loadPaymentDataRequestCode = 991
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        
        // Initialize Google Pay
        val walletOptions = Wallet.WalletOptions.Builder()
            .setEnvironment(WalletConstants.ENVIRONMENT_TEST) // Change to PRODUCTION
            .build()
        paymentsClient = Wallet.getPaymentsClient(this, walletOptions)
        
        // Check if Google Pay is available
        checkGooglePayAvailability()
    }
    
    private fun checkGooglePayAvailability() {
        val request = IsReadyToPayRequest.fromJson(isReadyToPayRequestJson())
        paymentsClient.isReadyToPay(request)
            .addOnCompleteListener { task ->
                if (task.isSuccessful) {
                    // Google Pay is available
                    showGooglePayButton()
                } else {
                    // Google Pay is not available
                    hideGooglePayButton()
                }
            }
    }
    
    private fun requestPayment() {
        val paymentDataRequest = PaymentDataRequest.fromJson(paymentDataRequestJson())
        AutoResolveHelper.resolveTask(
            paymentsClient.loadPaymentData(paymentDataRequest),
            this,
            loadPaymentDataRequestCode
        )
    }
    
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        
        when (requestCode) {
            loadPaymentDataRequestCode -> {
                when (resultCode) {
                    Activity.RESULT_OK -> {
                        data?.let { intent ->
                            val paymentData = PaymentData.getFromIntent(intent)
                            handlePaymentSuccess(paymentData)
                        }
                    }
                    Activity.RESULT_CANCELED -> {
                        // User cancelled
                    }
                    AutoResolveHelper.RESULT_ERROR -> {
                        val status = AutoResolveHelper.getStatusFromIntent(data)
                        handlePaymentError(status)
                    }
                }
            }
        }
    }
    
    private fun handlePaymentSuccess(paymentData: PaymentData) {
        val paymentInfo = paymentData.toJson()
        
        // Process with Caibo API
        processCaiboPayment(paymentInfo)
    }
    
    private fun processCaiboPayment(paymentInfo: String) {
        // Implementation to call Caibo H2H API
        // Similar to JavaScript example but using Android HTTP client
    }
}

<div id="google-pay-button-container">
  <button id="google-pay-button" onclick="handleGooglePayPayment()">
    <img src="https://developers.google.com/pay/api/web/guides/brand-guidelines/google-pay-mark.svg" 
         alt="Google Pay" width="100" height="40">
  </button>
</div>

#google-pay-button {
  background: #000;
  border: none;
  border-radius: 4px;
  padding: 12px 24px;
  cursor: pointer;
  transition: background-color 0.2s;
}

#google-pay-button:hover {
  background: #333;
}

#google-pay-button:disabled {
  background: #ccc;
  cursor: not-allowed;
}

{
  "protocolVersion": "ECv2",
  "signature": "MEQCIH6Q4OwQ0jAceFEkGF0JID...",
  "intermediateSigningKey": {
    "signedKey": "{\"keyExpiration\":\"1234567890123\",\"keyValue\":\"MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE...\"}",
    "signatures": ["MEQCIH6Q4OwQ0jAceFEkGF0JID..."]
  },
  "signedMessage": "{\"tag\":\"jpGz1F1Bcoi/fCNxI9n7Qrsw7i7KHrGtlaN4PK1a/ccDmqJDOLReKbQAjjeLHuQ0...\",\"ephemeralPublicKey\":\"BPhVspn70Zj2Kkgu9t8+ApEuUWsI/zos5whGCQBlgOkuYagOis7qN3RStgeV/QNFqJdN...\",\"encryptedMessage\":\"adMHdWxSfCiTMwXXdMrAgtznpjqecZ...\"}"
}

function handleGooglePayError(error) {
  switch (error.statusCode) {
    case 'BUYER_ACCOUNT_ERROR':
      displayError('There was an issue with your Google Pay account');
      break;
    case 'CANCELED':
      // User cancelled - no action needed
      break;
    case 'DEVELOPER_ERROR':
      console.error('Google Pay configuration error:', error);
      displayError('Payment system configuration error');
      break;
    case 'INTERNAL_ERROR':
      displayError('An internal error occurred. Please try again');
      break;
    case 'MERCHANT_ACCOUNT_ERROR':
      displayError('Merchant account error. Please contact support');
      break;
    default:
      displayError('Payment failed. Please try again');
  }
}

{
  "success": false,
  "error": "GOOGLE_PAY_TOKEN_INVALID",
  "message": "Invalid Google Pay payment token",
  "code": "GP001",
  "details": {
    "tokenValidation": "failed",
    "reason": "Token signature verification failed"
  }
}

// Secure token validation
function validateGooglePayToken(token) {
  try {
    // Parse token
    const tokenData = JSON.parse(token);
    
    // Validate required fields
    if (!tokenData.protocolVersion || !tokenData.signature || !tokenData.signedMessage) {
      throw new Error('Invalid token structure');
    }
    
    // Validate protocol version
    if (tokenData.protocolVersion !== 'ECv2') {
      throw new Error('Unsupported protocol version');
    }
    
    return {
      valid: true,
      tokenData: tokenData
    };
  } catch (error) {
    return {
      valid: false,
      error: error.message
    };
  }
}

// Test configuration
const testConfig = {
  environment: 'TEST',
  merchantId: '01234567890123456789',
  merchantName: 'Test Merchant'
};

// Test payment data
const testPaymentRequest = {
  apiVersion: 2,
  apiVersionMinor: 0,
  allowedPaymentMethods: [{
    type: 'CARD',
    parameters: {
      allowedAuthMethods: ['PAN_ONLY', 'CRYPTOGRAM_3DS'],
      allowedCardNetworks: ['VISA', 'MASTERCARD']
    },
    tokenizationSpecification: {
      type: 'PAYMENT_GATEWAY',
      parameters: {
        gateway: 'caibo',
        gatewayMerchantId: 'test_merchant_123'
      }
    }
  }],
  transactionInfo: {
    totalPriceStatus: 'FINAL',
    totalPrice: '1.00',
    currencyCode: 'USD'
  },
  merchantInfo: testConfig
};

// Production configuration
const productionConfig = {
  environment: 'PRODUCTION',
  merchantId: 'your_production_merchant_id',
  merchantName: 'Your Store Name'
};