Events

const googlePayConfig = {
  onPreAuthorisation: async (data) => {
    console.log('Pre-authorisation started');
    console.log('Gateway Token ID:', data.gatewayTokenId);
    
    // Perform pre-payment validation
    const isHighRisk = await checkCustomerRiskProfile();
    const customerTier = await getCustomerTier();
    
    // Check inventory before proceeding
    const inventoryAvailable = await checkInventory();
    if (!inventoryAvailable) {
      showError('Some items are no longer available');
      return null; // Cancel payment
    }
    
    // Check business rules
    const cartTotal = getCurrentCartTotal();
    if (cartTotal > 10000 && isHighRisk) {
      showError('Transaction requires additional verification');
      return null; // Cancel payment for manual review
    }
    
    return {
      riskScreeningData: {
        performRiskScreening: true,
        excludeDeviceData: false
      },
      psd2Data: {
        scaExemption: cartTotal < 30 ? 'LowValue' : 'TransactionRiskAnalysis'
      }
    };
  }
};

const googlePayConfig = {
  onPostAuthorisation: async (result, paymentData) => {
    console.log('Payment completed:', result);
    
    if (result && 'merchantTransactionId' in result && !('errorCode' in result)) {
      // Success - MerchantSubmitResult
      console.log('Payment authorised successfully');
      console.log('Transaction ID:', result.merchantTransactionId);
      console.log('System Transaction ID:', result.systemTransactionId);
      
      // Extract payment data
      const email = paymentData.Email;
      const shippingAddress = paymentData.ShippingAddress;
      const shippingOption = paymentData.ShippingOption;
      
      // Update inventory
      await updateInventory(result.merchantTransactionId);
      
      // Create order record
      await createOrder({
        transactionId: result.merchantTransactionId,
        email: email,
        shippingAddress: shippingAddress,
        shippingMethod: shippingOption?.id,
        status: 'confirmed'
      });
      
      // Send confirmation email
      await sendConfirmationEmail({
        transactionId: result.merchantTransactionId,
        email: email,
        shippingAddress: shippingAddress
      });
      
      // Track successful payment
      trackEvent('google-pay-success', {
        transactionId: result.merchantTransactionId,
        cartValue: getCurrentCartValue(),
        shippingMethod: shippingOption?.id
      });
      
      // Update customer account
      await updateCustomerPurchaseHistory(result.merchantTransactionId);
      
      // Redirect to success page
      window.location.href = `/payment-success?txn=${result.merchantTransactionId}`;
      
    } else if (result && 'errorCode' in result) {
      // Failure - FailedSubmitResult
      console.error('Payment declined:', result.errorReason);
      console.error('Error code:', result.errorCode);
      console.error('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
      const errorMessage = getErrorMessage(result.errorCode);
      showError(`Payment declined: ${errorMessage}`);
      
      // Track failed payment
      trackEvent('google-pay-declined', {
        errorCode: result.errorCode,
        correlationId: result.correlationId
      });
      
      // Offer alternatives
      showAlternativePaymentMethods();
      
    } else {
      // Payment exception
      console.error('Payment exception:', result);
      showError('Payment processing error. Please contact support.');
      trackEvent('google-pay-exception', { result });
    }
  }
};

const googlePayConfig = {
  onPaymentDataChanged: async (intermediatePaymentData) => {
    console.log('Payment data changed:', intermediatePaymentData.callbackTrigger);
    
    const baseAmount = 20.00;
    let tax = 5.00;
    let shippingCost = 0;
    let error = null;
    
    // Handle shipping address change
    if (intermediatePaymentData.callbackTrigger === 'SHIPPING_ADDRESS') {
      const address = intermediatePaymentData.shippingAddress;
      
      // Validate address completeness
      if (!address.postalCode || !address.countryCode) {
        error = {
          reason: 'SHIPPING_ADDRESS_INVALID',
          message: 'Please enter a complete address',
          intent: 'SHIPPING_ADDRESS'
        };
      } 
      // Check if we ship to this location
      else if (!['US', 'CA', 'GB'].includes(address.countryCode)) {
        error = {
          reason: 'SHIPPING_ADDRESS_UNSERVICEABLE',
          message: `We do not ship to ${address.countryCode}`,
          intent: 'SHIPPING_ADDRESS'
        };
      }
      // Calculate shipping and tax for valid address
      else {
        // Calculate shipping cost based on location
        shippingCost = await calculateShipping(address);
        
        // Calculate tax based on destination
        tax = await calculateTax(address, baseAmount);
        
        console.log('Shipping calculated:', { shippingCost, tax });
      }
    }
    
    // Handle shipping option change
    if (intermediatePaymentData.callbackTrigger === 'SHIPPING_OPTION') {
      const optionId = intermediatePaymentData.shippingOptionData.id;
      
      // Apply different shipping rates
      const shippingRates = {
        'shipping_standard': 5.00,
        'shipping_express': 15.00,
        'shipping_overnight': 25.00
      };
      
      shippingCost = shippingRates[optionId] || 5.00;
      console.log('Shipping option selected:', optionId, shippingCost);
    }
    
    // Calculate new total
    const newTotal = baseAmount + tax + shippingCost;
    
    // Update SDK amount (synchronizes with backend)
    await pxpSdk.updateAmount(newTotal);
    
    // Return updated payment data
    return {
      newTransactionInfo: {
        totalPriceStatus: 'FINAL',
        totalPrice: newTotal.toFixed(2),
        totalPriceLabel: 'Total',
        displayItems: [
          {
            label: 'Subtotal',
            type: 'LINE_ITEM',
            price: baseAmount.toFixed(2)
          },
          {
            label: 'Tax',
            type: 'TAX',
            price: tax.toFixed(2)
          },
          {
            label: 'Shipping',
            type: 'LINE_ITEM',
            price: shippingCost.toFixed(2)
          }
        ]
      },
      ...(error && { error })
    };
  }
};

const googlePayConfig = {
  onGooglePaymentButtonClicked: async (event) => {
    console.log('Google Pay button clicked');
    
    // Track button click
    trackEvent('google-pay-button-clicked', {
      timestamp: new Date().toISOString(),
      cartValue: getCurrentCartValue(),
      itemCount: getCartItemCount()
    });
    
    // Show loading indicator
    showLoadingIndicator();
    
    // Final inventory check
    const inventoryOk = await checkInventory();
    if (!inventoryOk) {
      hideLoadingIndicator();
      showError('Some items are no longer available. Please review your cart.');
      event.preventDefault();
      return;
    }
    
    // Prepare checkout data
    await prepareCheckoutData();
    
    // Update cart totals
    await recalculateCartTotals();
    
    hideLoadingIndicator();
  }
};

const googlePayConfig = {
  onCustomValidation: async () => {
    // Validate email
    const email = document.getElementById('email')?.value;
    if (!email || !email.includes('@')) {
      showError('Please enter a valid email address');
      highlightField('email');
      return false;
    }
    
    // Validate phone number (if required)
    const phone = document.getElementById('phone')?.value;
    if (!phone || phone.length < 10) {
      showError('Please enter a valid phone number');
      highlightField('phone');
      return false;
    }
    
    // Validate terms acceptance
    const termsAccepted = document.getElementById('terms')?.checked;
    if (!termsAccepted) {
      showError('Please accept the terms and conditions');
      highlightField('terms');
      return false;
    }
    
    // Validate age verification (if required)
    const ageVerified = document.getElementById('age-verify')?.checked;
    if (!ageVerified) {
      showError('You must be 18 or older to complete this purchase');
      return false;
    }
    
    // Validate minimum order amount
    const cartTotal = getCurrentCartTotal();
    if (cartTotal < 10.00) {
      showError('Minimum order amount is $10.00');
      return false;
    }
    
    // Final inventory check
    const inventoryAvailable = await checkInventory();
    if (!inventoryAvailable) {
      showError('Some items are no longer available. Please review your cart.');
      return false;
    }
    
    return true; // All validations passed
  }
};

const googlePayConfig = {
  onError: (error) => {
    console.error('Google Pay error:', error);
    
    // Log error for debugging
    logError('google-pay-error', {
      name: error.name,
      message: error.message,
      code: error.code,
      stack: error.stack,
      timestamp: new Date().toISOString(),
      userId: getCurrentUserId(),
      sessionId: getSessionId()
    });
    
    // Handle different error types
    if (error.name === 'GooglePayPaymentFailedException' && error.message.includes('cancel')) {
      // User cancelled - silent handling
      console.log('User cancelled Google Pay');
      trackEvent('google-pay-user-cancelled');
      return;
    } 
    
    if (error.name === 'GooglePayNotReadyException') {
      showUserMessage('Google Pay is not available on this device. Please use an alternative payment method.');
      showAlternativePaymentMethods();
      trackEvent('google-pay-not-available');
    } 
    
    else if (error.name === 'GooglePayPaymentFailedException' && error.message.includes('HTTPS')) {
      showUserMessage('Secure connection required. Please ensure your site uses HTTPS.');
      notifySupport('HTTPS requirement not met');
    }
    
    else if (error.name === 'GooglePayConfigurationValidationFailedException') {
      showUserMessage('Payment system temporarily unavailable. Please try again later.');
      notifySupport('Merchant configuration error', error);
    }
    
    else if (error.message.includes('Network')) {
      showUserMessage('Network error. Please check your connection and try again.');
      // Offer retry option
      showRetryButton();
    } 
    
    else {
      showUserMessage('Payment failed. Please try again or use a different payment method.');
      showAlternativePaymentMethods();
    }
    
    // Track error for monitoring
    trackEvent('google-pay-error', {
      errorType: error.name,
      errorCode: error.code
    });
  }
};

const googlePayConfig = {
  onCancel: () => {
    console.log('Google Pay cancelled');
    
    // Track cancellation for analytics
    trackEvent('google-pay-cancelled', {
      timestamp: new Date().toISOString(),
      cartValue: getCurrentCartValue(),
      itemCount: getCartItemCount(),
      pageUrl: window.location.href
    });
    
    // Preserve cart for later
    saveCartForLater();
    
    // Show helpful message
    showMessage(
      'No worries! Your items are saved. You can complete your purchase anytime.', 
      'info'
    );
    
    // Offer live chat support
    if (getCartValue() > 100) {
      showLiveChatOffer('Need help completing your purchase?');
    }
    
    // Offer alternatives after a short delay
    setTimeout(() => {
      showAlternativePaymentOptions();
    }, 2000);
    
    // Schedule abandoned cart email
    scheduleAbandonedCartEmail(
      getCustomerEmail(), 
      getCurrentCartData(),
      60 // Send after 60 minutes
    );
  }
};

const googlePayButton = pxpSdk.create('google-pay-button', {
  // ... other configuration
  
  // Use Unity authentication strategy
  useUnityAuthenticationStrategy: true,
  
  onPreInitiateAuthentication: () => {
    return {
      providerId: 'pxpfinancial',
      timeout: 12
    };
  },
  
  onPreAuthentication: async () => {
    // Simplified - no need to provide merchantCountryNumericCode, 
    // merchantLegalName, or requestorChallengeIndicator
    return {
      challengeWindowSize: 4
    };
  },
  
  onPreAuthorisation: async (data) => {
    // No need to provide scaExemption when using Unity strategy
    return {
      riskScreeningData: {
        performRiskScreening: true
      }
    };
  }
});

const googlePayButton = pxpSdk.create('google-pay-button', {
  // ... other configuration
  
  // useUnityAuthenticationStrategy: false, // Default
  
  onPreInitiateAuthentication: () => {
    return {
      providerId: 'pxpfinancial',
      timeout: 12
    };
  },
  
  onPreAuthentication: async () => {
    // All parameters required when not using Unity strategy
    return {
      merchantCountryNumericCode: '840',
      merchantLegalName: 'Your Store',
      challengeWindowSize: 4,
      requestorChallengeIndicator: '02'
    };
  },
  
  onPreAuthorisation: async (data) => {
    return {
      riskScreeningData: {
        performRiskScreening: true
      },
      psd2Data: {
        scaExemption: 'LowValue'
      }
    };
  }
});

const googlePayConfig = {
  onPreInitiateAuthentication: () => {
    console.log('Initiating 3DS pre-authentication');
    
    // Track 3DS initiation
    trackEvent('3ds-pre-initiate');
    
    return {
      providerId: 'your-3ds-provider-id', // Optional - your 3DS provider identifier
      requestorAuthenticationIndicator: '01', // Payment transaction
      timeout: 300 // 5 minutes (300 seconds)
    };
  }
};

const googlePayConfig = {
  onPostInitiateAuthentication: async (data) => {
    console.log('3DS pre-initiation completed. Authentication ID:', data.authenticationId);
    
    // Retrieve initiate authentication result from Unity
    const authResult = await fetchAuthenticationResultFromBackend(data.authenticationId);
    
    // Check if authentication setup was successful
    if (authResult.state === 'PendingClientData') {
      console.log('Waiting for client data collection');
    }
    
    // Check if SCA (Strong Customer Authentication) is mandated
    if (authResult.scaMandated) {
      console.log('SCA is required - 3DS must complete successfully');
      showMessage('Additional verification required');
    }
    
    // Check available exemptions
    if (authResult.applicableExemptions === 'LVP') {
      console.log('Low value exemption available');
    } else if (authResult.applicableExemptions === 'TRA') {
      console.log('Transaction risk analysis exemption available');
    }
    
    // Evaluate the result to update authentication decision
    const decision = await evaluateAuthenticationAndUpdateSession(authResult);
  }
};

const googlePayConfig = {
  onPreAuthentication: async () => {
    console.log('Starting 3DS authentication');
    
    // Get merchant configuration
    const merchantConfig = await getMerchantConfiguration();
    
    // Assess transaction risk
    const riskLevel = await assessTransactionRisk();
    
    // Determine challenge indicator based on risk
    let challengeIndicator = '01'; // No preference
    if (riskLevel === 'high') {
      challengeIndicator = '04'; // Challenge required
    } else if (riskLevel === 'low') {
      challengeIndicator = '02'; // No challenge requested
    }
    
    // Track authentication start
    trackEvent('3ds-authentication-started', {
      riskLevel,
      challengeIndicator
    });
    
    return {
      merchantCountryNumericCode: '840', // USA
      merchantLegalName: merchantConfig.legalName,
      challengeWindowSize: 5, // Full screen for best UX
      requestorChallengeIndicator: challengeIndicator,
      timeout: 600 // 10 minutes (600 seconds) - max value
    };
  }
};

const googlePayConfig = {
  onPostAuthentication: async (data) => {
    console.log('3DS authentication completed. Authentication ID:', data.authenticationId);
    
    // Send authenticationId to backend to retrieve authentication result
    const authResult = await fetchAuthenticationResultFromBackend(data.authenticationId);
    
    console.log('Authentication result:', authResult);
    
    // Check transaction status
    switch (authResult.transactionStatus) {
      case 'Y':
        console.log('Authentication successful - no challenge needed');
        showMessage('Card verified successfully');
        break;
        
      case 'C':
        console.log('Challenge completed - checking result...');
        if (authResult.state === 'AuthenticationSuccessful') {
          console.log('Challenge completed successfully');
          showMessage('Verification completed');
        } else {
          console.log('Challenge failed');
          showError('Verification failed. Please try again.');
          return; // Stop payment
        }
        break;
        
      case 'N':
        console.log('Authentication failed');
        showError('Card verification failed');
        return; // Stop payment
        
      case 'R':
        console.log('Authentication rejected');
        showError('Payment was rejected by your bank');
        return; // Stop payment
    }
    
    // Evaluate authentication result to update authorisation decision
    const authorisationDecision = await evaluateAuthenticationAndUpdateAuthorization(authResult);
    
    console.log('Proceeding to final authorisation...');
  }
};

const googlePayButton = pxpSdk.create('google-pay-button', {
  // ... payment configuration
  
  onGetConsent: () => {
    // Return a default value when not using consent checkbox
    // Set to true to always store tokens, false to never store
    return true; // Always save payment method for this merchant
  },
  
  onPostAuthorisation: (result, paymentData) => {
    if (result && 'merchantTransactionId' in result) {
      console.log('Payment successful, token will be stored');
      // Token storage is handled automatically based on consent
    }
  }
});

const googlePayButton = pxpSdk.create('google-pay-button', {
  // ... payment configuration
  
  onGetConsent: () => {
    // Check your own custom checkbox
    const consentGiven = document.getElementById('save-payment-checkbox')?.checked || false;
    
    if (consentGiven) {
      console.log('Customer consented to save payment method');
      
      // Track consent
      trackEvent('payment-consent-given', {
        timestamp: new Date().toISOString(),
        paymentMethod: 'google-pay'
      });
    } else {
      console.log('Customer did not consent to save payment method');
    }
    
    return consentGiven;
  }
});

// Create consent component
const googlePayConsent = pxpSdk.create('google-pay-consent', {
  label: 'Save my payment method for future purchases',
  checked: false
});
googlePayConsent.mount('consent-container');

const googlePayButton = pxpSdk.create('google-pay-button', {
  // ... payment configuration
  
  // Link the consent component
  googlePayConsentComponent: googlePayConsent,
  
  // This callback will NOT be called because consent component is linked
  onGetConsent: () => {
    return true; // This is ignored when consent component is present
  }
});

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

const googlePayConfig = {
  onKountCollectStart: () => {
    console.log('Kount fraud screening started');
    
    // Track screening start
    trackEvent('kount-screening-started', {
      timestamp: new Date().toISOString()
    });
    
    // Show loading indicator
    showMessage('Verifying transaction...', 'info');
  }
};

const googlePayConfig = {
  onKountCollectEnd: () => {
    console.log('Kount fraud screening completed');
    
    // Track screening completion
    trackEvent('kount-screening-completed', {
      timestamp: new Date().toISOString(),
      duration: getScreeningDuration()
    });
    
    // Hide loading indicator
    hideMessage();
  }
};

const googlePayConfig = {
  onPreRetrySoftDecline: (result) => {
    console.log('Soft decline occurred, preparing retry');
    console.log('Merchant Transaction ID:', result.merchantTransactionId);
    console.log('System Transaction ID:', result.systemTransactionId);
    console.log('Error code:', result.errorCode);
    console.log('Decline reason:', result.errorReason);
    console.log('Correlation ID:', result.correlationId);
    
    // Track soft decline
    trackEvent('payment-soft-decline', {
      merchantTransactionId: result.merchantTransactionId,
      systemTransactionId: result.systemTransactionId,
      errorCode: result.errorCode,
      errorReason: result.errorReason,
      correlationId: result.correlationId
    });
    
    // Show message to user
    showMessage('Processing payment with additional verification...', 'info');
    
    // Retry with forced 3DS challenge
    return {
      retry: true,
      updatedConfigs: {
        onPreInitiateAuthentication: () => ({
          providerId: 'pxpfinancial',
          timeout: 12
        }),
        onPreAuthentication: async () => ({
          merchantCountryNumericCode: '826',
          merchantLegalName: 'Your Store Ltd',
          challengeWindowSize: 5,
          requestorChallengeIndicator: '04' // Force challenge on retry
        })
      }
    };
    
    // Or simply return true to retry with same config:
    // return true;
    
    // Or return false to cancel retry:
    // return false;
  }
};

// Initialise SDK
const pxpSdk = window.PXPCheckout.init({
  merchantGroupName: process.env.REACT_APP_MERCHANT_GROUP,
  merchantName: process.env.REACT_APP_MERCHANT_NAME,
  environment: 'test'
});

// Create consent component
const googlePayConsent = pxpSdk.create('google-pay-consent', {});
googlePayConsent.mount('consent-container');

// Create Google Pay button with comprehensive event handling
const googlePayButton = pxpSdk.create('google-pay-button', {
  paymentDataRequest: {
    allowedPaymentMethods: [{
      type: 'CARD',
      parameters: {
        allowedCardNetworks: ['VISA', 'MASTERCARD', 'AMEX'],
        allowedAuthMethods: ['PAN_ONLY', 'CRYPTOGRAM_3DS']
      }
      // Note: tokenizationSpecification is automatically configured by the SDK from session data
    }],
    transactionInfo: {
      currencyCode: 'GBP',
      totalPriceStatus: 'FINAL',
      totalPrice: '25.00'
    },
    emailRequired: true,
    shippingAddressRequired: true,
    callbackIntents: ['SHIPPING_ADDRESS', 'SHIPPING_OPTION']
  },
  
  googlePayConsentComponent: googlePayConsent,
  
  // Pre-authorisation
  onPreAuthorisation: async (data) => {
    const cartTotal = getCurrentCartTotal();
    
    return {
      riskScreeningData: {
        performRiskScreening: true
      },
      psd2Data: {
        scaExemption: cartTotal < 30 ? 'LowValue' : 'TransactionRiskAnalysis'
      }
    };
  },
  
  // Post-authorisation
  onPostAuthorisation: async (result, paymentData) => {
    if (result && 'merchantTransactionId' in result && !('errorCode' in result)) {
      await updateInventory(result.merchantTransactionId);
      await sendConfirmationEmail({
        transactionId: result.merchantTransactionId,
        email: paymentData.Email
      });
      window.location.href = `/success?txn=${result.merchantTransactionId}`;
    } else if (result && 'errorCode' in result) {
      showError(`Payment declined: ${result.errorReason}`);
    }
  },
  
  // Payment sheet interactions
  onPaymentDataChanged: async (intermediatePaymentData) => {
    const baseAmount = 20.00;
    let tax = 5.00;
    let shippingCost = 0;
    
    if (intermediatePaymentData.shippingAddress) {
      shippingCost = await calculateShipping(intermediatePaymentData.shippingAddress);
      tax = await calculateTax(intermediatePaymentData.shippingAddress, baseAmount);
    }
    
    const newTotal = baseAmount + tax + shippingCost;
    await pxpSdk.updateAmount(newTotal);
    
    return {
      newTransactionInfo: {
        totalPriceStatus: 'FINAL',
        totalPrice: newTotal.toFixed(2),
        displayItems: [
          { label: 'Subtotal', type: 'LINE_ITEM', price: baseAmount.toFixed(2) },
          { label: 'Tax', type: 'TAX', price: tax.toFixed(2) },
          { label: 'Shipping', type: 'LINE_ITEM', price: shippingCost.toFixed(2) }
        ]
      }
    };
  },
  
  // Custom validation
  onCustomValidation: async () => {
    const email = document.getElementById('email')?.value;
    if (!email || !email.includes('@')) {
      showError('Please enter a valid email address');
      return false;
    }
    return true;
  },
  
  // Error handling
  onError: (error) => {
    console.error('Google Pay error:', error);
    logError('google-pay-error', error);
    
    if (!(error.name === 'GooglePayPaymentFailedException' && error.message.includes('cancel'))) {
      showError('Payment failed. Please try again or use a different payment method.');
    }
  },
  
  // Cancellation handling
  onCancel: () => {
    trackEvent('google-pay-cancelled', { cartValue: getCurrentCartValue() });
    saveCartForLater();
  },
  
  // Consent handling
  onGetConsent: () => {
    return document.getElementById('save-payment-checkbox')?.checked || false;
  }
});

// Mount button
googlePayButton.mount('google-pay-container');