// Alma JavaScript integration
class AlmaPaymentService {
    constructor(merchantId, environment = 'test') {
        this.merchantId = merchantId;
        this.apiUrl = environment === 'live' 
            ? 'https://api.getalma.eu' 
            : 'https://api.sandbox.getalma.eu';
        this.widgetUrl = environment === 'live'
            ? 'https://cdn.getalma.eu/widget.js'
            : 'https://cdn.sandbox.getalma.eu/widget.js';
        this.loadWidget();
    }
    
    loadWidget() {
        if (!document.getElementById('alma-widget-script')) {
            const script = document.createElement('script');
            script.id = 'alma-widget-script';
            script.src = this.widgetUrl;
            script.async = true;
            document.head.appendChild(script);
        }
    }
    
    async getEligiblePlans(amount, currency = 'EUR') {
        try {
            const response = await fetch(`${this.apiUrl}/v1/payments/eligibility`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    merchant_id: this.merchantId,
                    purchase_amount: Math.round(amount * 100), // Convert to cents
                    currency: currency,
                    locale: 'fr_FR'
                })
            });
            
            const data = await response.json();
            
            return data.eligibility.map(plan => ({
                installments_count: plan.installments_count,
                deferred_days: plan.deferred_days,
                deferred_months: plan.deferred_months,
                customer_total_cost_amount: plan.customer_total_cost_amount,
                customer_fee_amount: plan.customer_fee_amount,
                monthly_amount: plan.monthly_amount
            }));
        } catch (error) {
            console.error('Alma eligibility check failed:', error);
            throw new Error('Unable to get payment plans');
        }
    }
    
    showPaymentWidget(containerId, options = {}) {
        const config = {
            merchant_id: this.merchantId,
            amount: Math.round(options.amount * 100),
            currency: options.currency || 'EUR',
            locale: options.locale || 'fr_FR',
            customer: {
                email: options.customerEmail,
                first_name: options.customerFirstName,
                last_name: options.customerLastName,
                phone: options.customerPhone
            },
            billing_address: options.billingAddress,
            shipping_address: options.shippingAddress,
            custom_data: options.customData || {},
            return_url: options.returnUrl || `${window.location.origin}/payment/success`,
            failure_return_url: options.failureUrl || `${window.location.origin}/payment/failed`,
            ipn_callback_url: options.webhookUrl,
            onPaymentCreated: this.handlePaymentCreated.bind(this),
            onPaymentCompleted: this.handlePaymentCompleted.bind(this),
            onPaymentFailed: this.handlePaymentFailed.bind(this)
        };
        
        if (window.Alma) {
            window.Alma.createWidget(containerId, config);
        } else {
            console.error('Alma widget not loaded');
        }
    }
    
    showEligibilityWidget(containerId, amount, options = {}) {
        const config = {
            merchant_id: this.merchantId,
            amount: Math.round(amount * 100),
            locale: options.locale || 'fr_FR',
            container: containerId,
            theme: options.theme || 'default',
            show_if_not_eligible: options.showIfNotEligible !== false
        };
        
        if (window.Alma) {
            window.Alma.createEligibilityWidget(config);
        }
    }
    
    handlePaymentCreated(payment) {
        console.log('Alma payment created:', payment.id);
        
        // Store payment ID for tracking
        localStorage.setItem('alma_payment_id', payment.id);
        
        // Optional: Send to analytics
        if (typeof gtag !== 'undefined') {
            gtag('event', 'alma_payment_created', {
                payment_id: payment.id,
                amount: payment.amount / 100,
                installments: payment.installments_count
            });
        }
    }
    
    handlePaymentCompleted(payment) {
        console.log('Alma payment completed:', payment.id);
        
        // Clear stored payment ID
        localStorage.removeItem('alma_payment_id');
        
        // Redirect to success page
        window.location.href = payment.return_url || '/payment/success';
    }
    
    handlePaymentFailed(payment, error) {
        console.error('Alma payment failed:', payment.id, error);
        
        // Show error message
        this.showError('Le paiement a échoué. Veuillez réessayer.');
        
        // Optional: Send to analytics
        if (typeof gtag !== 'undefined') {
            gtag('event', 'alma_payment_failed', {
                payment_id: payment.id,
                error_code: error.code
            });
        }
    }
    
    showError(message) {
        const errorDiv = document.createElement('div');
        errorDiv.className = 'alma-error';
        errorDiv.style.cssText = `
            background: #fee;
            color: #c33;
            padding: 15px;
            border: 1px solid #fcc;
            border-radius: 4px;
            margin: 15px 0;
        `;
        errorDiv.textContent = message;
        
        const container = document.querySelector('#alma-payment-container');
        if (container) {
            container.prepend(errorDiv);
            setTimeout(() => errorDiv.remove(), 5000);
        }
    }
}

// Usage example
const almaService = new AlmaPaymentService('merchant_12345', 'test');

// Show payment options on product page
async function showAlmaOptions() {
    const productPrice = 299.99;
    
    try {
        const plans = await almaService.getEligiblePlans(productPrice);
        
        if (plans.length > 0) {
            almaService.showEligibilityWidget('#alma-eligibility', productPrice, {
                theme: 'clean',
                locale: 'fr_FR'
            });
        }
    } catch (error) {
        console.error('Failed to load Alma options:', error);
    }
}

// Initialize payment on checkout page
function initializeAlmaCheckout(orderData) {
    almaService.showPaymentWidget('#alma-payment-container', {
        amount: orderData.total,
        customerEmail: orderData.customer.email,
        customerFirstName: orderData.customer.firstName,
        customerLastName: orderData.customer.lastName,
        customerPhone: orderData.customer.phone,
        billingAddress: orderData.billingAddress,
        shippingAddress: orderData.shippingAddress,
        customData: {
            order_id: orderData.id,
            cart_items: orderData.items
        },
        returnUrl: '/payment/alma/success',
        failureUrl: '/payment/alma/failed',
        webhookUrl: '/webhooks/alma'
    });
}

<?php
// Alma server-side integration
class AlmaPaymentService 
{
    private $apiKey;
    private $apiUrl;
    
    public function __construct($apiKey, $environment = 'test') 
    {
        $this->apiKey = $apiKey;
        $this->apiUrl = $environment === 'live' 
            ? 'https://api.getalma.eu' 
            : 'https://api.sandbox.getalma.eu';
    }
    
    public function createPayment($paymentData) 
    {
        $data = [
            'purchase_amount' => $paymentData['amount'] * 100, // Convert to cents
            'currency' => $paymentData['currency'] ?? 'EUR',
            'installments_count' => $paymentData['installments_count'] ?? 3,
            'locale' => $paymentData['locale'] ?? 'fr_FR',
            'customer' => [
                'email' => $paymentData['customer']['email'],
                'first_name' => $paymentData['customer']['first_name'],
                'last_name' => $paymentData['customer']['last_name'],
                'phone' => $paymentData['customer']['phone'] ?? null
            ],
            'billing_address' => $paymentData['billing_address'],
            'shipping_address' => $paymentData['shipping_address'] ?? null,
            'merchant_reference' => $paymentData['merchant_reference'],
            'return_url' => $paymentData['return_url'],
            'failure_return_url' => $paymentData['failure_return_url'],
            'ipn_callback_url' => $paymentData['webhook_url'],
            'custom_data' => $paymentData['custom_data'] ?? []
        ];
        
        return $this->makeApiRequest('POST', '/v1/payments', $data);
    }
    
    public function getPaymentStatus($paymentId) 
    {
        return $this->makeApiRequest('GET', "/v1/payments/{$paymentId}");
    }
    
    public function refundPayment($paymentId, $amount = null) 
    {
        $data = [];
        if ($amount !== null) {
            $data['amount'] = $amount * 100; // Convert to cents
        }
        
        return $this->makeApiRequest('POST', "/v1/payments/{$paymentId}/refunds", $data);
    }
    
    public function handleWebhook($rawPayload, $signature) 
    {
        if (!$this->verifyWebhookSignature($rawPayload, $signature)) {
            throw new Exception('Invalid webhook signature');
        }
        
        $payload = json_decode($rawPayload, true);
        
        switch ($payload['type']) {
            case 'payment.created':
                $this->handlePaymentCreated($payload['data']);
                break;
                
            case 'payment.completed':
                $this->handlePaymentCompleted($payload['data']);
                break;
                
            case 'payment.failed':
                $this->handlePaymentFailed($payload['data']);
                break;
                
            case 'payment.refunded':
                $this->handlePaymentRefunded($payload['data']);
                break;
                
            default:
                error_log("Unhandled Alma webhook event: " . $payload['type']);
        }
        
        return true;
    }
    
    private function handlePaymentCreated($payment) 
    {
        // Payment has been created but not yet completed
        error_log("Alma payment created: " . $payment['id']);
        
        // Update order status to pending
        // $this->updateOrderStatus($payment['merchant_reference'], 'pending');
    }
    
    private function handlePaymentCompleted($payment) 
    {
        // Payment has been completed successfully
        error_log("Alma payment completed: " . $payment['id']);
        
        // Update order status to completed
        // Trigger fulfillment
        // Send confirmation email
        // $this->updateOrderStatus($payment['merchant_reference'], 'completed');
    }
    
    private function handlePaymentFailed($payment) 
    {
        // Payment has failed
        error_log("Alma payment failed: " . $payment['id']);
        
        // Update order status to failed
        // Send failure notification
        // $this->updateOrderStatus($payment['merchant_reference'], 'failed');
    }
    
    private function handlePaymentRefunded($payment) 
    {
        // Payment has been refunded
        error_log("Alma payment refunded: " . $payment['id']);
        
        // Update order status to refunded
        // Process refund logic
        // $this->updateOrderStatus($payment['merchant_reference'], 'refunded');
    }
    
    private function verifyWebhookSignature($payload, $signature) 
    {
        $expectedSignature = base64_encode(hash_hmac('sha256', $payload, $this->apiKey, true));
        return hash_equals($expectedSignature, $signature);
    }
    
    private function makeApiRequest($method, $endpoint, $data = null) 
    {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $this->apiUrl . $endpoint);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        curl_setopt($ch, CURLOPT_HTTPHEADER, [
            'Authorization: Bearer ' . $this->apiKey,
            'Content-Type: application/json',
            'User-Agent: Alma-PHP-SDK/1.0'
        ]);
        
        if ($method === 'POST') {
            curl_setopt($ch, CURLOPT_POST, true);
            if ($data) {
                curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
            }
        }
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        if ($httpCode >= 400) {
            throw new Exception("API request failed with status $httpCode: $response");
        }
        
        return json_decode($response, true);
    }
}

// Usage example
$almaService = new AlmaPaymentService($_ENV['ALMA_API_KEY'], 'test');

// Handle webhook
if ($_SERVER['REQUEST_METHOD'] === 'POST' && $_SERVER['REQUEST_URI'] === '/webhooks/alma') {
    try {
        $rawPayload = file_get_contents('php://input');
        $signature = $_SERVER['HTTP_X_ALMA_SIGNATURE'] ?? '';
        
        $almaService->handleWebhook($rawPayload, $signature);
        http_response_code(200);
        echo 'OK';
    } catch (Exception $e) {
        http_response_code(400);
        echo 'Error: ' . $e->getMessage();
    }
}
?>