// Coinbase Commerce JavaScript integration
import { ChargeResource, Webhook } from 'coinbase-commerce-node';

class CoinbaseCommerceService {
    constructor(apiKey, webhookSecret) {
        this.apiKey = apiKey;
        this.webhookSecret = webhookSecret;
        ChargeResource.init(apiKey);
    }
    
    async createCharge(orderData) {
        try {
            const chargeData = {
                name: orderData.productName,
                description: orderData.description,
                local_price: {
                    amount: orderData.amount.toString(),
                    currency: orderData.currency || 'USD'
                },
                pricing_type: 'fixed_price',
                metadata: {
                    customer_id: orderData.customerId,
                    customer_name: orderData.customerName,
                    order_id: orderData.orderId
                },
                redirect_url: `${process.env.BASE_URL}/payment/success`,
                cancel_url: `${process.env.BASE_URL}/payment/cancel`
            };
            
            const charge = await ChargeResource.create(chargeData);
            
            return {
                id: charge.id,
                hosted_url: charge.hosted_url,
                code: charge.code,
                expires_at: charge.expires_at,
                pricing: charge.pricing
            };
        } catch (error) {
            console.error('Coinbase Commerce charge creation failed:', error);
            throw new Error('Crypto payment initialization failed');
        }
    }
    
    async retrieveCharge(chargeId) {
        try {
            const charge = await ChargeResource.retrieve(chargeId);
            
            return {
                id: charge.id,
                code: charge.code,
                name: charge.name,
                description: charge.description,
                timeline: charge.timeline,
                metadata: charge.metadata,
                pricing: charge.pricing,
                payments: charge.payments,
                addresses: charge.addresses
            };
        } catch (error) {
            console.error('Charge retrieval failed:', error);
            throw new Error('Unable to retrieve charge information');
        }
    }
    
    verifyWebhook(rawBody, signature) {
        try {
            return Webhook.verifySigHeader(rawBody, signature, this.webhookSecret);
        } catch (error) {
            console.error('Webhook verification failed:', error);
            return false;
        }
    }
    
    async handleWebhookEvent(event) {
        const { type, data } = event;
        
        switch (type) {
            case 'charge:created':
                console.log('Charge created:', data.id);
                await this.handleChargeCreated(data);
                break;
                
            case 'charge:confirmed':
                console.log('Payment confirmed:', data.id);
                await this.handlePaymentConfirmed(data);
                break;
                
            case 'charge:failed':
                console.log('Payment failed:', data.id);
                await this.handlePaymentFailed(data);
                break;
                
            case 'charge:delayed':
                console.log('Payment delayed:', data.id);
                await this.handlePaymentDelayed(data);
                break;
                
            case 'charge:pending':
                console.log('Payment pending:', data.id);
                await this.handlePaymentPending(data);
                break;
                
            case 'charge:resolved':
                console.log('Payment resolved:', data.id);
                await this.handlePaymentResolved(data);
                break;
                
            default:
                console.log('Unhandled event type:', type);
        }
    }
    
    async handleChargeCreated(charge) {
        // Update order status to pending
        // Send payment instructions to customer
        console.log('Charge created for order:', charge.metadata.order_id);
    }
    
    async handlePaymentConfirmed(charge) {
        // Payment has sufficient confirmations
        // Fulfill order, grant access, send confirmation
        console.log('Payment confirmed for order:', charge.metadata.order_id);
        
        // Example: Update database
        // await updateOrderStatus(charge.metadata.order_id, 'completed');
        // await sendConfirmationEmail(charge.metadata.customer_id);
    }
    
    async handlePaymentFailed(charge) {
        // Payment failed (expired, underpaid, etc.)
        // Update order status, notify customer
        console.log('Payment failed for order:', charge.metadata.order_id);
    }
    
    async handlePaymentDelayed(charge) {
        // Payment detected but needs more confirmations
        // Keep order in processing state
        console.log('Payment delayed for order:', charge.metadata.order_id);
    }
    
    async handlePaymentPending(charge) {
        // Payment submitted to network but not confirmed
        // Show "processing" status to customer
        console.log('Payment pending for order:', charge.metadata.order_id);
    }
    
    async handlePaymentResolved(charge) {
        // Final resolution (after being delayed/pending)
        // Check final status and take appropriate action
        console.log('Payment resolved for order:', charge.metadata.order_id);
        
        const lastPayment = charge.payments[charge.payments.length - 1];
        if (lastPayment && lastPayment.status === 'CONFIRMED') {
            await this.handlePaymentConfirmed(charge);
        }
    }
}

// Usage example
const coinbaseService = new CoinbaseCommerceService(
    process.env.COINBASE_COMMERCE_API_KEY,
    process.env.COINBASE_COMMERCE_WEBHOOK_SECRET
);

// Create charge for product purchase
async function createCryptoPayment(orderData) {
    try {
        const charge = await coinbaseService.createCharge({
            productName: 'Premium Subscription',
            description: 'Monthly premium access',
            amount: 49.99,
            currency: 'USD',
            customerId: 'cust_123',
            customerName: 'John Doe',
            orderId: 'order_456'
        });
        
        console.log('Charge created:', charge);
        
        // Redirect customer to hosted checkout
        return {
            success: true,
            checkout_url: charge.hosted_url,
            charge_id: charge.id
        };
    } catch (error) {
        console.error('Crypto payment creation failed:', error);
        return {
            success: false,
            error: error.message
        };
    }
}

// Express.js webhook integration
const express = require('express');
const app = express();

// Middleware to capture raw body for webhook verification
app.use('/webhooks/coinbase', express.raw({ type: 'application/json' }));
app.use(express.json());

app.post('/webhooks/coinbase', async (req, res) => {
    try {
        const signature = req.headers['x-cc-webhook-signature'];
        const rawBody = req.body;
        
        // Verify webhook authenticity
        const event = coinbaseService.verifyWebhook(rawBody, signature);
        
        if (event) {
            await coinbaseService.handleWebhookEvent(JSON.parse(rawBody));
            res.status(200).send('OK');
        } else {
            res.status(400).send('Invalid signature');
        }
    } catch (error) {
        console.error('Webhook processing error:', error);
        res.status(500).send('Webhook processing failed');
    }
});

// API endpoint to create charge
app.post('/api/crypto-payment', async (req, res) => {
    try {
        const result = await createCryptoPayment(req.body);
        res.json(result);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// API endpoint to check charge status
app.get('/api/charge/:chargeId', async (req, res) => {
    try {
        const charge = await coinbaseService.retrieveCharge(req.params.chargeId);
        res.json(charge);
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});