// Klarna Payments SDK integration
window.klarnaAsyncCallback = function() {
    try {
        // Initialize Klarna Payments
        Klarna.Payments.init({
            client_token: 'CLIENT_TOKEN_FROM_SERVER'
        });
        
        // Load payment method (Pay in 4)
        Klarna.Payments.load({
            container: '#klarna-payments-container',
            payment_method_category: 'pay_in_4'
        }, function(res) {
            if (res.show_form) {
                // Payment method loaded successfully
                document.getElementById('klarna-pay-button').style.display = 'block';
            }
        });
        
        // Handle payment authorization
        document.getElementById('klarna-pay-button').addEventListener('click', function() {
            // Collect customer data
            const billingData = {
                billing_address: {
                    given_name: document.getElementById('first-name').value,
                    family_name: document.getElementById('last-name').value,
                    email: document.getElementById('email').value,
                    street_address: document.getElementById('address').value,
                    postal_code: document.getElementById('zip').value,
                    city: document.getElementById('city').value,
                    country: 'FR'
                }
            };
            
            // Authorize payment
            Klarna.Payments.authorize({
                payment_method_category: 'pay_in_4'
            }, billingData, function(res) {
                if (res.approved) {
                    // Payment approved, process on server
                    processKlarnaPayment(res.authorization_token);
                } else if (res.show_form) {
                    // Additional customer data needed
                    console.log('Additional form data required');
                } else {
                    // Payment declined
                    showPaymentError('Payment was declined');
                }
            });
        });
        
    } catch (e) {
        console.error('Klarna Payments initialization failed:', e);
    }
};

async function processKlarnaPayment(authToken) {
    try {
        const response = await fetch('/api/klarna/create-order', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
            },
            body: JSON.stringify({
                authorization_token: authToken,
                order_data: {
                    purchase_currency: 'EUR',
                    order_amount: 9999, // 99.99 EUR in minor units
                    order_lines: [{
                        name: 'Premium Subscription',
                        quantity: 1,
                        unit_price: 9999,
                        total_amount: 9999
                    }]
                }
            }),
        });
        
        const result = await response.json();
        
        if (result.success) {
            window.location.href = result.redirect_url;
        } else {
            showPaymentError(result.error);
        }
    } catch (error) {
        console.error('Order creation failed:', error);
        showPaymentError('Payment processing failed');
    }
}

function showPaymentError(message) {
    document.getElementById('payment-error').textContent = message;
    document.getElementById('payment-error').style.display = 'block';
}

// Load Klarna Payments script
(function() {
    var script = document.createElement('script');
    script.src = 'https://x.klarnacdn.net/kp/lib/v1/api.js';
    script.async = true;
    document.head.appendChild(script);
})();

// Klarna server-side integration (Node.js)
const axios = require('axios');

class KlarnaPaymentService {
    constructor() {
        this.baseUrl = process.env.KLARNA_ENVIRONMENT === 'production' 
            ? 'https://api.klarna.com'
            : 'https://api.playground.klarna.com';
        
        this.credentials = Buffer.from(
            `${process.env.KLARNA_USERNAME}:${process.env.KLARNA_PASSWORD}`
        ).toString('base64');
    }
    
    async createSession(orderData) {
        try {
            const response = await axios.post(
                `${this.baseUrl}/payments/v1/sessions`,
                {
                    purchase_country: 'FR',
                    purchase_currency: 'EUR',
                    locale: 'fr-FR',
                    order_amount: orderData.total_amount,
                    order_tax_amount: orderData.tax_amount || 0,
                    order_lines: orderData.order_lines,
                    merchant_urls: {
                        terms: `${process.env.BASE_URL}/terms`,
                        checkout: `${process.env.BASE_URL}/checkout`,
                        confirmation: `${process.env.BASE_URL}/confirmation`,
                        push: `${process.env.BASE_URL}/api/klarna/push`
                    }
                },
                {
                    headers: {
                        'Authorization': `Basic ${this.credentials}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            return {
                session_id: response.data.session_id,
                client_token: response.data.client_token
            };
        } catch (error) {
            console.error('Klarna session creation failed:', error.response?.data);
            throw new Error('Failed to create Klarna session');
        }
    }
    
    async createOrder(authToken, orderData) {
        try {
            const response = await axios.post(
                `${this.baseUrl}/payments/v1/authorizations/${authToken}/order`,
                {
                    purchase_currency: orderData.purchase_currency,
                    order_amount: orderData.order_amount,
                    order_lines: orderData.order_lines,
                    merchant_reference1: `ORDER_${Date.now()}`,
                    merchant_reference2: orderData.customer_id || '',
                    merchant_data: JSON.stringify({
                        customer_id: orderData.customer_id,
                        order_id: orderData.order_id
                    })
                },
                {
                    headers: {
                        'Authorization': `Basic ${this.credentials}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            return {
                order_id: response.data.order_id,
                redirect_url: response.data.redirect_url,
                fraud_status: response.data.fraud_status
            };
        } catch (error) {
            console.error('Klarna order creation failed:', error.response?.data);
            throw new Error('Failed to create Klarna order');
        }
    }
    
    async captureOrder(orderId, captureData) {
        try {
            const response = await axios.post(
                `${this.baseUrl}/ordermanagement/v1/orders/${orderId}/captures`,
                {
                    captured_amount: captureData.amount,
                    description: captureData.description || 'Order fulfillment',
                    order_lines: captureData.order_lines,
                    shipping_info: captureData.shipping_info
                },
                {
                    headers: {
                        'Authorization': `Basic ${this.credentials}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            return response.data;
        } catch (error) {
            console.error('Klarna order capture failed:', error.response?.data);
            throw new Error('Failed to capture Klarna order');
        }
    }
    
    async refundOrder(orderId, refundData) {
        try {
            const response = await axios.post(
                `${this.baseUrl}/ordermanagement/v1/orders/${orderId}/refunds`,
                {
                    refunded_amount: refundData.amount,
                    description: refundData.reason || 'Customer refund',
                    order_lines: refundData.order_lines
                },
                {
                    headers: {
                        'Authorization': `Basic ${this.credentials}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            return response.data;
        } catch (error) {
            console.error('Klarna refund failed:', error.response?.data);
            throw new Error('Failed to process Klarna refund');
        }
    }
    
    async handleWebhook(eventData) {
        // Handle Klarna webhooks (order status updates, etc.)
        switch (eventData.event_type) {
            case 'ORDER_PENDING':
                await this.handleOrderPending(eventData.order_id);
                break;
            case 'ORDER_CAPTURED':
                await this.handleOrderCaptured(eventData.order_id);
                break;
            case 'ORDER_CANCELLED':
                await this.handleOrderCancelled(eventData.order_id);
                break;
            default:
                console.log(`Unhandled Klarna event: ${eventData.event_type}`);
        }
    }
    
    async handleOrderPending(orderId) {
        console.log(`Klarna order pending: ${orderId}`);
        // Update order status in database
    }
    
    async handleOrderCaptured(orderId) {
        console.log(`Klarna order captured: ${orderId}`);
        // Fulfill order, send confirmation email
    }
    
    async handleOrderCancelled(orderId) {
        console.log(`Klarna order cancelled: ${orderId}`);
        // Handle cancellation, update inventory
    }
}

// Express.js routes
const klarnaService = new KlarnaPaymentService();

app.post('/api/klarna/create-session', async (req, res) => {
    try {
        const session = await klarnaService.createSession(req.body);
        res.json(session);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

app.post('/api/klarna/create-order', async (req, res) => {
    try {
        const { authorization_token, order_data } = req.body;
        const order = await klarnaService.createOrder(authorization_token, order_data);
        
        res.json({ 
            success: true, 
            redirect_url: order.redirect_url,
            order_id: order.order_id
        });
    } catch (error) {
        res.status(500).json({ 
            success: false, 
            error: error.message 
        });
    }
});

app.post('/api/klarna/webhook', async (req, res) => {
    try {
        await klarnaService.handleWebhook(req.body);
        res.status(200).send('OK');
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});