<!-- PayPal SDK integration -->
<script src="https://www.paypal.com/sdk/js?client-id=YOUR_CLIENT_ID&currency=EUR"></script>

<div id="paypal-button-container"></div>

<script>
paypal.Buttons({
    createOrder: function(data, actions) {
        return actions.order.create({
            purchase_units: [{
                amount: {
                    value: '99.99',
                    currency_code: 'EUR'
                },
                description: 'Premium Subscription',
                custom_id: 'ORDER_12345',
                invoice_id: 'INV_12345'
            }]
        });
    },
    
    onApprove: function(data, actions) {
        return actions.order.capture().then(function(details) {
            console.log('Payment completed:', details);
            
            // Verify payment server-side
            fetch('/api/paypal/verify-payment', {
                method: 'POST',
                headers: { 'Content-Type': 'application/json' },
                body: JSON.stringify({
                    orderID: data.orderID,
                    paymentID: details.id
                })
            }).then(response => response.json())
              .then(data => {
                  if (data.verified) {
                      window.location.href = '/success';
                  }
              });
        });
    },
    
    onError: function(err) {
        console.error('PayPal payment error:', err);
        alert('Payment failed. Please try again.');
    }
}).render('#paypal-button-container');
</script>

// PayPal REST API server integration
const paypal = require('@paypal/checkout-server-sdk');

class PayPalService {
    constructor() {
        // Sandbox environment
        this.environment = new paypal.core.SandboxEnvironment(
            process.env.PAYPAL_CLIENT_ID,
            process.env.PAYPAL_CLIENT_SECRET
        );
        
        // Production: new paypal.core.LiveEnvironment(...)
        this.client = new paypal.core.PayPalHttpClient(this.environment);
    }
    
    async createOrder(amount, currency = 'EUR', description = '') {
        const request = new paypal.orders.OrdersCreateRequest();
        
        request.requestBody({
            intent: 'CAPTURE',
            purchase_units: [{
                amount: {
                    currency_code: currency,
                    value: amount.toString()
                },
                description: description
            }],
            application_context: {
                return_url: `${process.env.BASE_URL}/success`,
                cancel_url: `${process.env.BASE_URL}/cancel`,
                brand_name: 'Your Store Name',
                user_action: 'PAY_NOW'
            }
        });
        
        try {
            const response = await this.client.execute(request);
            return {
                id: response.result.id,
                status: response.result.status,
                links: response.result.links
            };
        } catch (error) {
            console.error('PayPal order creation failed:', error);
            throw new Error('Payment order creation failed');
        }
    }
    
    async captureOrder(orderId) {
        const request = new paypal.orders.OrdersCaptureRequest(orderId);
        
        try {
            const response = await this.client.execute(request);
            
            return {
                id: response.result.id,
                status: response.result.status,
                payer: response.result.payer,
                purchase_units: response.result.purchase_units
            };
        } catch (error) {
            console.error('PayPal order capture failed:', error);
            throw new Error('Payment capture failed');
        }
    }
    
    async createSubscription(planId, subscriberInfo) {
        const request = new paypal.subscriptions.SubscriptionsCreateRequest();
        
        request.requestBody({
            plan_id: planId,
            subscriber: {
                name: {
                    given_name: subscriberInfo.firstName,
                    surname: subscriberInfo.lastName
                },
                email_address: subscriberInfo.email
            },
            application_context: {
                brand_name: 'Your SaaS',
                user_action: 'SUBSCRIBE_NOW',
                return_url: `${process.env.BASE_URL}/subscription/success`,
                cancel_url: `${process.env.BASE_URL}/subscription/cancel`
            }
        });
        
        try {
            const response = await this.client.execute(request);
            return response.result;
        } catch (error) {
            console.error('PayPal subscription creation failed:', error);
            throw new Error('Subscription creation failed');
        }
    }
    
    async handleWebhook(headers, body) {
        const webhookId = process.env.PAYPAL_WEBHOOK_ID;
        
        const request = new paypal.webhooks.WebhookVerifySignature();
        request.requestBody({
            auth_algo: headers['paypal-auth-algo'],
            cert_id: headers['paypal-cert-id'],
            transmission_id: headers['paypal-transmission-id'],
            transmission_sig: headers['paypal-transmission-sig'],
            transmission_time: headers['paypal-transmission-time'],
            webhook_id: webhookId,
            webhook_event: body
        });
        
        try {
            const response = await this.client.execute(request);
            
            if (response.result.verification_status === 'SUCCESS') {
                return this.processWebhookEvent(body);
            } else {
                throw new Error('Webhook verification failed');
            }
        } catch (error) {
            console.error('PayPal webhook verification failed:', error);
            return false;
        }
    }
    
    processWebhookEvent(event) {
        switch (event.event_type) {
            case 'PAYMENT.CAPTURE.COMPLETED':
                console.log('Payment completed:', event.resource);
                // Update order status, send confirmation email, etc.
                break;
                
            case 'BILLING.SUBSCRIPTION.ACTIVATED':
                console.log('Subscription activated:', event.resource);
                // Activate user account, grant access, etc.
                break;
                
            case 'BILLING.SUBSCRIPTION.CANCELLED':
                console.log('Subscription cancelled:', event.resource);
                // Handle subscription cancellation
                break;
                
            default:
                console.log('Unhandled webhook event:', event.event_type);
        }
        
        return true;
    }
}

// Usage
const paypalService = new PayPalService();

// Express.js routes
app.post('/api/paypal/create-order', async (req, res) => {
    try {
        const { amount, description } = req.body;
        const order = await paypalService.createOrder(amount, 'EUR', description);
        res.json(order);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

app.post('/api/paypal/capture-order', async (req, res) => {
    try {
        const { orderId } = req.body;
        const result = await paypalService.captureOrder(orderId);
        res.json(result);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});