// Adyen Web Components integration
import AdyenCheckout from '@adyen/adyen-web';
import '@adyen/adyen-web/dist/adyen.css';

class AdyenPaymentService {
    constructor(environment, clientKey) {
        this.environment = environment; // 'test' or 'live'
        this.clientKey = clientKey;
        this.checkout = null;
    }
    
    async initializeCheckout(containerId, amount, currency = 'EUR') {
        // Get payment methods from server
        const paymentMethods = await this.getPaymentMethods(amount, currency);
        
        const configuration = {
            environment: this.environment,
            clientKey: this.clientKey,
            paymentMethodsResponse: paymentMethods,
            locale: 'fr-FR',
            
            onSubmit: async (state, dropin) => {
                try {
                    const payment = await this.makePayment(state.data);
                    this.handlePaymentResponse(payment, dropin);
                } catch (error) {
                    console.error('Payment failed:', error);
                    dropin.setStatus('error', { message: error.message });
                }
            },
            
            onAdditionalDetails: async (state, dropin) => {
                try {
                    const details = await this.submitAdditionalDetails(state.data);
                    this.handlePaymentResponse(details, dropin);
                } catch (error) {
                    console.error('Payment details submission failed:', error);
                }
            }
        };
        
        this.checkout = new AdyenCheckout(configuration);
        this.checkout.create('dropin').mount(containerId);
    }
    
    async getPaymentMethods(amount, currency) {
        const response = await fetch('/api/adyen/paymentMethods', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                merchantAccount: 'YOUR_MERCHANT_ACCOUNT',
                countryCode: 'FR',
                amount: {
                    currency: currency,
                    value: Math.round(amount * 100) // Convert to minor units
                },
                channel: 'Web',
                shopperLocale: 'fr-FR'
            })
        });
        
        return response.json();
    }
    
    async makePayment(paymentData) {
        const response = await fetch('/api/adyen/payments', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify({
                ...paymentData,
                merchantAccount: 'YOUR_MERCHANT_ACCOUNT',
                returnUrl: `${window.location.origin}/payment/result`,
                reference: `ORDER_${Date.now()}`,
                additionalData: {
                    'allow3DS2': true
                }
            })
        });
        
        if (!response.ok) {
            throw new Error(`Payment request failed: ${response.statusText}`);
        }
        
        return response.json();
    }
    
    async submitAdditionalDetails(details) {
        const response = await fetch('/api/adyen/payments/details', {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body: JSON.stringify(details)
        });
        
        return response.json();
    }
    
    handlePaymentResponse(response, component) {
        if (response.resultCode === 'Authorised') {
            window.location.href = '/payment/success';
        } else if (response.resultCode === 'Pending' || response.resultCode === 'Received') {
            window.location.href = '/payment/pending';
        } else if (response.resultCode === 'RedirectShopper') {
            component.handleAction(response.action);
        } else {
            window.location.href = '/payment/failed';
        }
    }
}

// Initialize Adyen checkout
const adyenService = new AdyenPaymentService('test', 'YOUR_CLIENT_KEY');
adyenService.initializeCheckout('#adyen-checkout', 99.99, 'EUR');

// Adyen server-side integration
const { Client, Config, CheckoutAPI, ManagementAPI } = require('@adyen/api-library');

class AdyenServerService {
    constructor() {
        const config = new Config();
        config.apiKey = process.env.ADYEN_API_KEY;
        config.merchantAccount = process.env.ADYEN_MERCHANT_ACCOUNT;
        config.environment = process.env.ADYEN_ENVIRONMENT; // 'TEST' or 'LIVE'
        
        const client = new Client({ config });
        this.checkout = new CheckoutAPI(client);
        this.management = new ManagementAPI(client);
    }
    
    async getPaymentMethods(request) {
        try {
            const response = await this.checkout.paymentMethods({
                merchantAccount: this.config.merchantAccount,
                ...request
            });
            
            return response;
        } catch (error) {
            console.error('Get payment methods failed:', error);
            throw new Error('Failed to retrieve payment methods');
        }
    }
    
    async makePayment(paymentRequest) {
        try {
            const response = await this.checkout.payments({
                merchantAccount: this.config.merchantAccount,
                ...paymentRequest
            });
            
            // Log transaction for reconciliation
            this.logTransaction(paymentRequest, response);
            
            return response;
        } catch (error) {
            console.error('Payment failed:', error);
            throw new Error('Payment processing failed');
        }
    }
    
    async handleWebhook(notification) {
        const notificationItems = notification.notificationItems;
        
        for (const item of notificationItems) {
            const notificationRequestItem = item.NotificationRequestItem;
            
            try {
                // Verify webhook authenticity
                if (this.verifyWebhook(notificationRequestItem)) {
                    await this.processNotification(notificationRequestItem);
                }
            } catch (error) {
                console.error('Webhook processing failed:', error);
            }
        }
        
        return '[accepted]';
    }
    
    async processNotification(notification) {
        const { eventCode, merchantReference, pspReference, success } = notification;
        
        switch (eventCode) {
            case 'AUTHORISATION':
                if (success === 'true') {
                    await this.handleSuccessfulPayment(merchantReference, pspReference);
                } else {
                    await this.handleFailedPayment(merchantReference, notification.reason);
                }
                break;
                
            case 'CAPTURE':
                await this.handlePaymentCapture(merchantReference, pspReference);
                break;
                
            case 'REFUND':
                await this.handleRefund(merchantReference, pspReference);
                break;
                
            case 'CHARGEBACK':
                await this.handleChargeback(merchantReference, pspReference);
                break;
                
            default:
                console.log(`Unhandled event: ${eventCode}`);
        }
    }
    
    async capturePayment(pspReference, amount) {
        try {
            const response = await this.checkout.paymentsCapture(pspReference, {
                merchantAccount: this.config.merchantAccount,
                amount: amount
            });
            
            return response;
        } catch (error) {
            console.error('Payment capture failed:', error);
            throw new Error('Failed to capture payment');
        }
    }
    
    async refundPayment(pspReference, amount) {
        try {
            const response = await this.checkout.paymentsRefund(pspReference, {
                merchantAccount: this.config.merchantAccount,
                amount: amount,
                reference: `REFUND_${Date.now()}`
            });
            
            return response;
        } catch (error) {
            console.error('Refund failed:', error);
            throw new Error('Failed to process refund');
        }
    }
    
    verifyWebhook(notification) {
        // Implement HMAC verification
        const hmacKey = process.env.ADYEN_HMAC_KEY;
        // ... HMAC verification logic
        return true; // Simplified for example
    }
    
    logTransaction(request, response) {
        console.log('Transaction logged:', {
            merchantReference: request.reference,
            pspReference: response.pspReference,
            resultCode: response.resultCode,
            timestamp: new Date().toISOString()
        });
    }
}

// Express.js routes
const adyenService = new AdyenServerService();

app.post('/api/adyen/paymentMethods', async (req, res) => {
    try {
        const paymentMethods = await adyenService.getPaymentMethods(req.body);
        res.json(paymentMethods);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

app.post('/api/adyen/payments', async (req, res) => {
    try {
        const payment = await adyenService.makePayment(req.body);
        res.json(payment);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

app.post('/api/adyen/webhooks', async (req, res) => {
    try {
        const result = await adyenService.handleWebhook(req.body);
        res.status(200).send(result);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});