Events

const paypalComponent = sdk.create('paypal-button', {
  onApprove: async (data, actions) => {
    console.log('PayPal payment approved:', data);
    
    try {
      // Capture the payment using PayPal actions
      const captureResult = await actions.capture();
      console.log('Payment captured successfully:', captureResult);
      
      // Extract important transaction details
      const transactionId = captureResult.id;
      const payerEmail = captureResult.payer.email_address;
      const amount = captureResult.purchase_units[0].amount.value;
      const currency = captureResult.purchase_units[0].amount.currency_code;
      
      // Update your system with the successful payment
      await updateOrderStatus({
        orderId: data.orderID,
        transactionId: transactionId,
        status: 'completed',
        paymentMethod: 'paypal',
        fundingSource: data.paymentSource,
        amount: amount,
        currency: currency
      });
      
      // Update inventory
      await updateInventory(data.orderID);
      
      // Send confirmation email
      await sendConfirmationEmail(payerEmail, {
        orderId: data.orderID,
        transactionId: transactionId,
        amount: amount,
        currency: currency
      });
      
      // Track successful payment
      trackEvent('paypal-payment-completed', {
        orderId: data.orderID,
        transactionId: transactionId,
        fundingSource: data.paymentSource,
        amount: amount,
        currency: currency,
        timestamp: new Date().toISOString()
      });
      
      // Redirect to success page
      window.location.href = `/payment-success?order=${data.orderID}&txn=${transactionId}`;
      
    } catch (error) {
      console.error('Payment capture failed:', error);
      
      // Handle capture failure
      showErrorMessage('Payment processing failed. Please try again or contact support.');
      
      // Log the error for debugging
      logError('paypal-capture-failed', {
        orderId: data.orderID,
        error: error.message,
        timestamp: new Date().toISOString()
      });
    }
  }
});

const paypalComponent = sdk.create('paypal-button', {
onCancel: (data) => {
    console.log('PayPal payment cancelled:', data);
    
    // Track cancellation for analytics
    trackEvent('paypal-payment-cancelled', {
      orderId: data.orderID,
      timestamp: new Date().toISOString(),
      cartValue: getCurrentCartValue(),
      stage: 'paypal_checkout'
    });
    
    // Preserve cart for later
    saveCartForLater();
    
    // Show helpful message
    showMessage('No worries! Your items are saved. You can complete your purchase anytime.', 'info');
    
    // Offer alternatives after a short delay
    setTimeout(() => {
      showAlternativePaymentOptions();
    }, 2000);
    
    // Optional: Schedule abandoned cart email
    scheduleAbandonedCartEmail(customerEmail, 30); // 30 minutes delay
  }
});

const paypalComponent = sdk.create('paypal-button', {
onError: (error) => {
    console.error('PayPal payment error:', error);
    
    // Log error for debugging
    logError('paypal-payment-error', {
      message: error.message,
      name: error.name,
      stack: error.stack,
      timestamp: new Date().toISOString(),
      userAgent: navigator.userAgent
    });
    
    // Handle different error types
    if (error.message.includes('INSTRUMENT_DECLINED')) {
      showUserMessage('Your PayPal payment was declined. Please try a different payment method or contact PayPal support.');
    } else if (error.message.includes('PAYER_ACTION_REQUIRED')) {
      showUserMessage('Additional action required in PayPal. Please try again or complete any pending actions in your PayPal account.');
    } else if (error.message.includes('UNPROCESSABLE_ENTITY')) {
      showUserMessage('There was an issue processing your payment. Please check your payment details and try again.');
    } else if (error.message.includes('Network')) {
      showUserMessage('Network error. Please check your connection and try again.');
      // Offer retry option for network errors
      showRetryButton();
    } else {
      showUserMessage('Payment failed. Please try again or use a different payment method.');
    }
    
    // Show alternative payment methods
    showAlternativePaymentMethods();
    
    // Notify support team for critical errors
    if (error.message.includes('INTERNAL_ERROR')) {
      notifySupport('PayPal internal error occurred', error);
    }
  }
});

const paypalComponent = sdk.create('paypal-button', {
onOrderCreated: (data) => {
    console.log('PayPal order created successfully:', data);
    
    // Store order information
    storeOrderInformation({
      paypalOrderId: data.providerTransactionId,
      pxpTransactionId: data.transactionId,
      correlationId: data.correlationId,
      status: 'created',
      createdAt: new Date().toISOString()
    });
    
    // Update UI to show order created state
    updateOrderStatus('Order created, awaiting payment approval...');
    
    // Track order creation
    trackEvent('paypal-order-created', {
      paypalOrderId: data.providerTransactionId,
      pxpTransactionId: data.transactionId,
      correlationId: data.correlationId,
      timestamp: new Date().toISOString()
    });
    
    // Optional: Start order timeout timer
    startOrderTimeoutTimer(data.providerTransactionId, 15); // 15 minute timeout
  }
});

const paypalComponent = sdk.create('paypal-button', {
  onShippingAddressChange: async (data, actions) => {
    console.log('PayPal shipping address changed:', data.shipping_address);
    
    try {
      const shippingAddress = data.shipping_address;
      
      // Validate if we can ship to this location
      const canShip = await validateShippingAddress(shippingAddress);
      if (!canShip) {
        return actions.reject();
      }
      
      // Calculate new shipping cost and tax
      const shippingCost = await calculateShipping(shippingAddress);
      const taxAmount = await calculateTax(shippingAddress, baseAmount);
      const newTotal = baseAmount + taxAmount + shippingCost;
      
      // Get available shipping methods for this address
      const shippingOptions = await getShippingOptions(shippingAddress);
      
      // Update the order with new totals and shipping options
      return actions.resolve({
        purchase_units: [{
          amount: {
            currency_code: 'USD',
            value: newTotal.toFixed(2),
            breakdown: {
              item_total: {
                currency_code: 'USD',
                value: baseAmount.toFixed(2)
              },
              shipping: {
                currency_code: 'USD',
                value: shippingCost.toFixed(2)
              },
              tax_total: {
                currency_code: 'USD',
                value: taxAmount.toFixed(2)
              }
            }
          },
          shipping: {
            options: shippingOptions.map(option => ({
              id: option.id,
              label: option.label,
              type: option.type,
              amount: {
                currency_code: 'USD',
                value: option.cost.toFixed(2)
              },
              selected: option.selected
            }))
          }
        }]
      });
      
    } catch (error) {
      console.error('Shipping calculation failed:', error);
    return actions.reject();
  }
}
});

const paypalComponent = sdk.create('paypal-button', {
  onShippingOptionsChange: async (data, actions) => {
    console.log('PayPal shipping option changed:', data.selected_shipping_option);
    
    const selectedOption = data.selected_shipping_option;
    const baseAmount = 100.00;
    const taxAmount = 10.00;
    const shippingCost = parseFloat(selectedOption.amount.value);
    
    // Add insurance for expedited shipping
    let insurance = 0;
    if (selectedOption.id === 'expedited' && baseAmount > 50) {
      insurance = 2.99;
    }
    
    // Calculate carbon offset for eco-friendly shipping
    const carbonOffset = selectedOption.id === 'standard' ? 0.50 : 0;
    
    const newTotal = baseAmount + taxAmount + shippingCost + insurance + carbonOffset;
    
    // Track shipping method selection
    trackEvent('paypal-shipping-method-selected', {
      shippingMethod: selectedOption.id,
      shippingCost: shippingCost,
      orderValue: baseAmount,
      timestamp: new Date().toISOString()
    });
    
    // Update order totals
    return actions.resolve({
      purchase_units: [{
        amount: {
          currency_code: 'USD',
          value: newTotal.toFixed(2),
          breakdown: {
            item_total: {
              currency_code: 'USD',
              value: baseAmount.toFixed(2)
            },
            shipping: {
              currency_code: 'USD',
              value: shippingCost.toFixed(2)
            },
            tax_total: {
              currency_code: 'USD',
              value: taxAmount.toFixed(2)
            },
            ...(insurance > 0 && {
              insurance: {
                currency_code: 'USD',
                value: insurance.toFixed(2)
              }
            })
          }
        }
      }]
    });
  }
});

const paypalComponent = sdk.create('paypal-button', {
  onInit: (data, actions) => {
    console.log('PayPal button initialised:', data);
    
    // Initially disable the button
    actions.disable();
    
    // Enable button when form is valid
    function validateForm() {
      const email = document.getElementById('email')?.value;
      const terms = document.getElementById('terms')?.checked;
      
      if (email && terms && email.includes('@')) {
        actions.enable();
      } else {
        actions.disable();
      }
    }
    
    // Set up form validation listeners
    document.getElementById('email')?.addEventListener('input', validateForm);
    document.getElementById('terms')?.addEventListener('change', validateForm);
    
    // Initial validation
    validateForm();
  }
});

const paypalComponent = sdk.create('paypal-button', {
  onClick: async (data, actions) => {
    console.log('PayPal button clicked:', data);
    
    // Track button click
    trackEvent('paypal-button-clicked', {
      timestamp: new Date().toISOString(),
      cartValue: getCurrentCartValue()
    });
    
    // Validate collected shipping address and shopper details before proceeding
    try {
      // Collect current shopper data from your form/state
      const shopperData = {
        id: getCurrentShopperId(),
        email: getCustomerEmail(),
        firstName: getCustomerFirstName(),
        lastName: getCustomerLastName(),
        phoneNumber: getCustomerPhone()
      };
      
      // Collect current shipping address from your form/state
      const shippingAddress = {
        address: getShippingAddress(),
        city: getShippingCity(),
        state: getShippingState(),
        postalCode: getShippingPostalCode(),
        countryCode: getShippingCountryCode()
      };
      
      // Validate shopper data completeness
      if (!shopperData.id || !shopperData.email) {
        showError('Please complete customer information before proceeding.');
        return actions.reject();
      }
      
      // Validate shipping address when required
      if (requiresShipping() && (!shippingAddress.address || !shippingAddress.city || !shippingAddress.postalCode)) {
        showError('Please complete shipping address before proceeding.');
        return actions.reject();
      }
      
      // Additional business validations
      const isFormValid = validateCheckoutForm();
      const hasInventory = await checkInventoryAvailability();
      const isCustomerEligible = await checkCustomerEligibility();
      
      if (!isFormValid) {
        showError('Please complete all required fields before proceeding.');
        return actions.reject();
      }
      
      if (!hasInventory) {
        showError('Some items in your cart are no longer available.');
        return actions.reject();
      }
      
      if (!isCustomerEligible) {
        showError('PayPal is not available for your location.');
        return actions.reject();
      }
      
      // All validations passed - show loading state and proceed
      showCheckoutLoader();
      return actions.resolve();
      
    } catch (error) {
      console.error('Validation failed:', error);
      showError('Please verify your information and try again.');
      return actions.reject();
    }
  }
});

const paypalComponent = sdk.create('paypal-button', {
  onSubmitError: (error) => {
    console.error('PayPal submission error:', error);
    
    // Log error for debugging
    logError('paypal-submission-error', {
      message: error.message,
      errorCode: error.errorCode,
      timestamp: new Date().toISOString()
    });
    
    // Handle specific error types
    switch (error.errorCode) {
      case 'VALIDATION_ERROR':
        showError('Please check your payment details and try again.');
        break;
      case 'INSUFFICIENT_FUNDS':
        showError('Insufficient funds in your PayPal account. Please add funds or use a different payment method.');
        break;
      case 'MERCHANT_NOT_ELIGIBLE':
        showError('PayPal payments are temporarily unavailable. Please try a different payment method.');
        break;
      default:
        showError('Payment processing failed. Please try again or contact support.');
    }
    
    // Offer alternative payment methods
    showAlternativePaymentMethods();
  }
});

const paypalComponent = sdk.create('paypal-button', {
  onScriptLoaded: () => {
    console.log('PayPal SDK script loaded successfully');
    
    // Track script loading
    trackEvent('paypal-script-loaded', {
      timestamp: new Date().toISOString(),
      loadTime: performance.now()
    });
    
    // Show PayPal buttons that were hidden during loading
    document.querySelectorAll('.paypal-button-container').forEach(container => {
      container.style.display = 'block';
    });
    
    // Hide loading spinner
    hidePayPalLoadingSpinner();
    
    // Initialise PayPal messaging
    if (window.paypal && window.paypal.Messages) {
      window.paypal.Messages({
        amount: getCurrentCartValue(),
        placement: 'cart',
        style: {
          layout: 'text',
          logo: {
            type: 'primary'
          }
        }
      }).render('#paypal-messages');
    }
  }
});

const paypalComponent = sdk.create('paypal-button', {
  renderType: 'setOfButtons',
  fundingSources: ['paypal', 'paylater', 'venmo'],
  
  onClick: (data, actions) => {
    // Track which funding source was clicked
    trackEvent('paypal-funding-source-clicked', {
      fundingSource: data.fundingSource,
      timestamp: new Date().toISOString()
    });
    
    // Apply different logic based on funding source
    if (data.fundingSource === 'paylater') {
      // Special handling for Pay Later
      const isEligibleForPayLater = checkPayLaterEligibility();
      if (!isEligibleForPayLater) {
        showError('Pay Later is not available for this purchase.');
    return actions.reject();
      }
    }
    
    return actions.resolve();
  },
  
  onApprove: async (data, actions) => {
    // Handle approval differently based on funding source
    const fundingSource = data.paymentSource || 'paypal';
    
    trackEvent('paypal-payment-approved', {
      fundingSource: fundingSource,
      orderId: data.orderID,
      timestamp: new Date().toISOString()
    });
    
    // Proceed with capture
    return await actions.capture();
  }
});

const paypalComponent = sdk.create('paypal-button', {
  onError: (error) => {
    const errorInfo = {
      message: error.message,
      timestamp: new Date().toISOString(),
      userAgent: navigator.userAgent,
      url: window.location.href
    };
    
    // Log to monitoring service
    logError('paypal-error', errorInfo);
    
    // Determine if error is retryable
    const retryableErrors = [
      'NETWORK_ERROR',
      'TIMEOUT',
      'TEMPORARY_FAILURE'
    ];
    
    const isRetryable = retryableErrors.some(retryableError => 
      error.message.includes(retryableError)
    );
    
    if (isRetryable) {
      showRetryButton(() => {
        // Retry the PayPal initialisation
        location.reload();
      });
    } else {
      // Show alternative payment methods
      showAlternativePaymentMethods();
    }
    
    // Send error metrics to analytics
    trackEvent('paypal-error', {
      errorType: error.name,
      errorMessage: error.message,
      isRetryable: isRetryable
    });
  }
});