Events

onPostAuthorisation: async (data) => {
  console.log('Payment authorisation completed');
  console.log('Merchant Transaction ID:', data.merchantTransactionId);
  console.log('System Transaction ID:', data.systemTransactionId);
  
  // Get authorisation result from merchant backend
  const authorisationResult = await getAuthorisationResultFromGateway(
    data.merchantTransactionId, 
    data.systemTransactionId
  );
  
  if (authorisationResult.status === 'Authorised') {
    // Update inventory
    await updateInventory(data.merchantTransactionId);
    
    // Send confirmation email
    await sendConfirmationEmail(
      authorisationResult.customerEmail, 
      data.merchantTransactionId
    );
    
    // Track analytics
    trackPurchase(data.merchantTransactionId, authorisationResult.amount);
    
    // Redirect to success page
    window.location.href = `/payment-success?txn=${data.merchantTransactionId}`;
  } else if (authorisationResult.status === 'Declined') {
    console.error('Payment declined:', authorisationResult.reason);
    showErrorMessage('Payment declined. Please try again or use a different payment method.');
  } else {
    console.error('Payment exception:', authorisationResult.reason);
    showErrorMessage('Payment processing error. Please contact support.');
  }
}

onPreAuthorisation: async () => {
  // Perform pre-payment validation
  const deviceSessionId = await getKountSessionId();
  const isHighRisk = await checkCustomerRiskProfile();
  const customerTier = await getCustomerTier();
  
  // Get billing address if AVS is enabled
  const billingAddress = await getBillingAddress();
  
  // Update authorisation decision to true in backend via Modify Session API
  await updateSessionAuthorisationDecision(true);
  
  return {
    addressVerification: billingAddress ? {
      countryCode: billingAddress.countryCode,
      houseNumberOrName: billingAddress.address,
      postalCode: billingAddress.postalCode,
      city: billingAddress.city,
      state: billingAddress.state
    } : undefined,
    riskScreeningData: {
      deviceSessionId: deviceSessionId,
      performRiskScreening: true,
      customData: {
        customerTier: customerTier,
        orderType: 'ecommerce',
        previousTransactionCount: await getPreviousTransactionCount(),
        riskScore: isHighRisk ? 'high' : 'low'
      }
    }
  };
}

onPreAuthorisation: async () => {
  // Check if authorisation should proceed
  const shouldProceed = await checkAuthorizationDecision();
  
  if (!shouldProceed) {
    // Update authorisation decision to false in backend via Modify Session API
    await updateSessionAuthorisationDecision(false);
    // Stop the authorisation process
    return null;
  }
  
  // Update authorisation decision to true in backend via Modify Session API
  await updateSessionAuthorisationDecision(true);
  
  // Return authorisation configuration
  return {
    riskScreeningData: {
      performRiskScreening: true
    }
  };
}

onError: (error) => {
  console.error('Apple Pay error:', error);
  
  // Log error for debugging
  logError('apple-pay-error', {
    message: error.message,
    code: error.code,
    timestamp: new Date().toISOString()
  });
  
  // Handle different error types
  if (error.message.includes('User cancelled')) {
    // Silent handling - user intentionally cancelled
    return;
  } else if (error.message.includes('Network')) {
    showUserMessage('Network error. Please check your connection and try again.');
    // Offer offline payment options
  } else if (error.message.includes('Merchant validation')) {
    showUserMessage('Payment system temporarily unavailable. Please try again later.');
    // Alert support team
    notifySupport('Apple Pay merchant validation failed');
  } else {
    showUserMessage('Payment failed. Please try again or use a different payment method.');
    // Show alternative payment options
    showAlternativePaymentMethods();
  }
}

onCancel: (error) => {
  console.log('Apple Pay cancelled:', error);
  
  // Track cancellation for analytics
  trackEvent('apple-pay-cancelled', {
    reason: error?.message || 'unknown',
    timestamp: new Date().toISOString(),
    cartValue: getCurrentCartValue()
  });
  
  // Preserve cart for later
  saveCartForLater();
  
  // Show helpful message
  showMessage('No worries! Your items are saved. You can complete your purchase anytime.', 'info');
  
  // Offer alternatives
  setTimeout(() => {
    showAlternativePaymentOptions();
  }, 2000);
  
  // Optional: Trigger abandoned cart email sequence
  scheduleAbandonedCartEmail(customer.email, 30); // 30 minutes delay
}

onShippingContactSelected: async (contact) => {
  console.log('Shipping contact selected:', contact);
  
  try {
    // Validate shipping address
    const isValidAddress = await validateAddress(contact.postalAddress);
    if (!isValidAddress) {
      return {
        errors: [{
          code: 'shippingContactInvalid',
          contactField: 'postalAddress',
          message: 'Please enter a valid shipping address'
        }]
      };
    }
    
    // Calculate shipping and tax
    const shippingCost = await calculateShipping(contact.postalAddress);
    const taxAmount = await calculateTax(contact.postalAddress, baseAmount);
    const newTotal = baseAmount + taxAmount + shippingCost;
    
    // Get available shipping methods
    const shippingMethods = await getShippingMethods(contact.postalAddress);
    
    return {
      newTotal: {
        label: 'Total',
        amount: newTotal.toFixed(2)
      },
      newLineItems: [
        { label: 'Subtotal', amount: baseAmount.toFixed(2) },
        { label: 'Tax', amount: taxAmount.toFixed(2) },
        { label: 'Shipping', amount: shippingCost.toFixed(2) }
      ],
      newShippingMethods: shippingMethods
    };
  } catch (error) {
    console.error('Shipping calculation failed:', error);
    return {
      errors: [{
        code: 'shippingContactInvalid',
        message: 'Unable to calculate shipping. Please try again.'
      }]
    };
  }
}

onShippingMethodSelected: async (method) => {
  console.log('Shipping method selected:', method);
  
  // Update total based on selected shipping method
  const baseAmount = 20.00;
  const tax = 5.00;
  const shippingCost = parseFloat(method.amount);
  
  // Add insurance for express shipping
  let insurance = 0;
  if (method.identifier === 'express' && baseAmount > 50) {
    insurance = 2.99;
  }
  
  // Calculate carbon offset for eco-conscious customers
  const carbonOffset = method.identifier === 'standard' ? 0.50 : 0;
  
  const newTotal = baseAmount + tax + shippingCost + insurance + carbonOffset;
  
  // Track shipping method selection
  trackEvent('shipping-method-selected', {
    method: method.identifier,
    cost: shippingCost,
    orderValue: baseAmount
  });
  
  return {
    newTotal: {
      label: 'Total',
      amount: newTotal.toFixed(2)
    },
    newLineItems: [
      { label: 'Subtotal', amount: baseAmount.toFixed(2) },
      { label: 'Tax', amount: tax.toFixed(2) },
      { label: `Shipping (${method.label})`, amount: shippingCost.toFixed(2) },
      ...(insurance > 0 ? [{ label: 'Shipping Insurance', amount: insurance.toFixed(2) }] : []),
      ...(carbonOffset > 0 ? [{ label: 'Carbon Offset', amount: carbonOffset.toFixed(2) }] : [])
    ]
  };
}

onPaymentMethodSelected: async (paymentMethod) => {
  console.log('Payment method selected:', paymentMethod);
  
  const baseAmount = 20.00;
  const tax = 5.00;
  let processingFee = 0;
  let reward = 0;
  
  // Apply different fees based on card type
  if (paymentMethod.type === 'credit') {
    processingFee = 2.99; // Credit card processing fee
  } else if (paymentMethod.type === 'debit') {
    processingFee = 0.99; // Lower fee for debit
  }
  
  // Offer rewards for specific networks
  if (paymentMethod.network === 'amex') {
    reward = 1.00; // American Express cashback offer
  }
  
  // Track payment method selection
  trackEvent('payment-method-selected', {
    network: paymentMethod.network,
    type: paymentMethod.type,
    lastFour: paymentMethod.paymentPass?.primaryAccountNumberSuffix
  });
  
  const newTotal = baseAmount + tax + processingFee - reward;
  
  return {
    newTotal: {
      label: 'Total',
      amount: Math.max(0, newTotal).toFixed(2)
    },
    newLineItems: [
      { label: 'Subtotal', amount: baseAmount.toFixed(2) },
      { label: 'Tax', amount: tax.toFixed(2) },
      ...(processingFee > 0 ? [{ label: `${paymentMethod.type} Fee`, amount: processingFee.toFixed(2) }] : []),
      ...(reward > 0 ? [{ label: `${paymentMethod.network} Reward`, amount: `-${reward.toFixed(2)}` }] : [])
    ]
  };
}

onCouponCodeChanged: async (couponCode) => {
  console.log('Coupon code entered:', couponCode);
  
  try {
    // Validate coupon code
    const discount = await validateCouponCode(couponCode);
    
    if (discount.valid && !discount.expired) {
      const baseAmount = 20.00;
      const tax = 5.00;
      
      // Calculate discount amount
      let discountAmount = 0;
      if (discount.type === 'percentage') {
        discountAmount = baseAmount * (discount.value / 100);
      } else if (discount.type === 'fixed') {
        discountAmount = discount.value;
      }
      
      // Apply minimum purchase requirement
      if (discount.minimumPurchase && baseAmount < discount.minimumPurchase) {
        return {
          errors: [{
            code: 'couponCodeInvalid',
            message: `Minimum purchase of $${discount.minimumPurchase} required`
          }]
        };
      }
      
      // Cap discount at maximum amount
      discountAmount = Math.min(discountAmount, discount.maxDiscount || discountAmount);
      
      const newTotal = Math.max(0, baseAmount + tax - discountAmount);
      
      // Track coupon usage
      trackEvent('coupon-applied', {
        code: couponCode,
        discountType: discount.type,
        discountAmount: discountAmount,
        orderValue: baseAmount
      });
      
      return {
        newTotal: {
          label: 'Total',
          amount: newTotal.toFixed(2)
        },
        newLineItems: [
          { label: 'Subtotal', amount: baseAmount.toFixed(2) },
          { label: 'Tax', amount: tax.toFixed(2) },
          { label: `Discount (${couponCode})`, amount: `-${discountAmount.toFixed(2)}` }
        ]
      };
    } else {
      // Handle invalid or expired coupon
      const errorMessage = discount.expired 
        ? 'This coupon code has expired' 
        : 'Invalid coupon code';
        
      return {
        errors: [{
          code: 'couponCodeInvalid',
          message: errorMessage
        }]
      };
    }
  } catch (error) {
    console.error('Coupon validation failed:', error);
    return {
      errors: [{
        code: 'couponCodeInvalid',
        message: 'Unable to validate coupon code. Please try again.'
      }]
    };
  }
}

interface ApplePayContact {
  postalAddress?: {
    street?: string;
    city?: string;
    state?: string;
    postalCode?: string;
    country?: string;
    countryCode?: string;
  };
  name?: {
    givenName?: string;
    familyName?: string;
  };
  phoneNumber?: string;
  emailAddress?: string;
}

interface ApplePayPaymentMethod {
  displayName?: string;
  network?: string;
  type?: 'debit' | 'credit' | 'prepaid' | 'store';
  paymentPass?: {
    primaryAccountIdentifier?: string;
    primaryAccountNumberSuffix?: string;
    deviceAccountIdentifier?: string;
    deviceAccountNumberSuffix?: string;
  };
}

interface ApplePayUpdateResponse {
  newTotal?: {
    label: string;
    amount: string;
  };
  newLineItems?: Array<{
    label: string;
    amount: string;
  }>;
  newShippingMethods?: Array<{
    identifier: string;
    label: string;
    detail?: string;
    amount: string;
  }>;
  errors?: Array<{
    code: string;
    contactField?: string;
    message: string;
  }>;
}

const applePayConfig = {
  onShippingContactSelected: async (contact) => {
    try {
      // Validate shipping address
      const isValid = await validateShippingAddress(contact.postalAddress);
      
      if (!isValid) {
        return {
          errors: [{
            code: 'shippingContactInvalid',
            contactField: 'postalAddress',
            message: 'We cannot ship to this address'
          }]
        };
      }
      
      // Calculate shipping
      const shippingCost = await calculateShipping(contact.postalAddress);
      return {
        newTotal: {
          label: 'Total',
          amount: (baseAmount + shippingCost).toFixed(2)
        }
      };
      
    } catch (error) {
      console.error('Shipping calculation failed:', error);
      return {
        errors: [{
          code: 'shippingContactInvalid',
          message: 'Unable to calculate shipping. Please try again.'
        }]
      };
    }
  },
  
  onPostAuthorisation: async (data) => {
    try {
      // Retrieve authorisation result from backend
      const result = await getAuthorisationResultFromGateway(
        data.merchantTransactionId,
        data.systemTransactionId
      );
      
      if (result.status === 'Authorised') {
        // Handle success
        window.location.href = `/payment-success?txn=${data.merchantTransactionId}`;
      } else {
        // Handle declined payment
        showUserMessage('Payment declined. Please try again or use a different payment method.');
      }
    } catch (error) {
      console.error('Failed to retrieve authorisation result:', error);
      showUserMessage('Unable to confirm payment status. Please contact support.');
    }
  },
  
  onError: (error) => {
    // Log error for debugging
    console.error('Apple Pay error:', error);
    
    // Show user-friendly message
    if (error.message.includes('Network')) {
      showUserMessage('Network error. Please check your connection and try again.');
    } else if (error.message.includes('Merchant validation')) {
      showUserMessage('Payment system temporarily unavailable. Please try again later.');
    } else {
      showUserMessage('Payment failed. Please try again or use a different payment method.');
    }
  }
};

// Check if Apple Pay is available in the browser
if (window.ApplePaySession && ApplePaySession.canMakePayments()) {
  // Initialise Apple Pay component
  const applePayComponent = pxpCheckoutSdk.create('apple-pay-button', applePayConfig);
} else {
  // Show alternative payment methods
  console.log('Apple Pay not available in this browser');
}

onPreAuthorisation: async () => {
  // Check if transaction should proceed
  const transactionDecision = await getAuthorisationDecision();
  
  if (!transactionDecision) {
    // Update authorisation decision to false in backend via Modify Session API
    await updateSessionAuthorisationDecision(false);
    return null; // Do not proceed
  }
  
  // Update authorisation decision to true in backend via Modify Session API
  await updateSessionAuthorisationDecision(true);
  
  return {
    riskScreeningData: {
      deviceSessionId: await getDeviceSessionId(),
      performRiskScreening: true,
      customData: {
        isRecurring: true,
        recurringFrequency: 'monthly',
        subscriptionId: await getSubscriptionId()
      }
    }
  };
}

onPreAuthorisation: async () => {
  // Check if transaction should proceed
  const transactionDecision = await getAuthorisationDecision();
  
  if (!transactionDecision) {
    // Update authorisation decision to false in backend via Modify Session API
    await updateSessionAuthorisationDecision(false);
    return null; // Do not proceed
  }
  
  // Get cart items for risk analysis
  const cartItems = await getCartItems();
  const shippingAddress = await getShippingAddress();
  const customer = await getCustomer();
  
  // Update authorisation decision to true in backend via Modify Session API
  await updateSessionAuthorisationDecision(true);
  
  return {
    riskScreeningData: {
      performRiskScreening: true,
      deviceSessionId: await getDeviceSessionId(),
      items: cartItems.map(item => ({
        price: item.price,
        quantity: item.quantity,
        category: item.category,
        sku: item.sku
      })),
      fulfillments: [{
        type: 'SHIPPING',
        recipientPerson: {
          name: {
            first: customer.firstName,
            family: customer.lastName
          },
          email: customer.email,
          phoneNumber: customer.phone,
          address: {
            line1: shippingAddress.street,
            city: shippingAddress.city,
            region: shippingAddress.state,
            countryCode: shippingAddress.countryCode,
            postalCode: shippingAddress.postalCode
          }
        }
      }],
      transaction: {
        subtotal: cartItems.reduce((sum, item) => sum + (item.price * item.quantity), 0)
      }
    }
  };
}

// Official Apple Pay SDK method (recommended)
const officialConfig = {
  usingCss: false, // Use Apple's official button
  onPostAuthorisation: async (data) => {
    // Retrieve authorisation result from backend
    const result = await getAuthorisationResultFromGateway(
      data.merchantTransactionId, 
      data.systemTransactionId
    );
    // Handle authorisation result
  }
};

// Custom CSS method (more restrictive browser support)
const cssConfig = {
  usingCss: true, // Use custom styled button
  style: {
    template: '<button class="custom-apple-pay">Pay with Apple Pay</button>',
    templateCSS: '.custom-apple-pay { /* custom styles */ }'
  },
  onPostAuthorisation: async (data) => {
    // Same event handling regardless of rendering method
    const result = await getAuthorisationResultFromGateway(
      data.merchantTransactionId, 
      data.systemTransactionId
    );
    // Handle authorisation result
  }
};