// Easyship API integration
const EasyshipAPI = require('@easyship/easyship-node');

class EasyshipService {
    constructor(apiToken, environment = 'production') {
        this.client = new EasyshipAPI({
            access_token: apiToken,
            environment: environment // 'sandbox' or 'production'
        });
    }
    
    async getRates(shipmentData) {
        try {
            const rates = await this.client.rate.create({
                origin_country_alpha2: shipmentData.origin.country,
                origin_postal_code: shipmentData.origin.postalCode,
                destination_country_alpha2: shipmentData.destination.country,
                destination_postal_code: shipmentData.destination.postalCode,
                taxes_duties_paid_by: 'Sender', // or 'Receiver'
                is_insured: true,
                items: shipmentData.items.map(item => ({
                    actual_weight: item.weight,
                    height: item.dimensions.height,
                    length: item.dimensions.length,
                    width: item.dimensions.width,
                    category: item.category,
                    declared_currency: item.currency,
                    declared_customs_value: item.value,
                    description: item.description,
                    hs_code: item.hsCode || null,
                    origin_country_alpha2: shipmentData.origin.country,
                    quantity: item.quantity,
                    sku: item.sku
                }))
            });
            
            // Sort rates by price and transit time
            return this.processRates(rates.rates);
        } catch (error) {
            console.error('Rate calculation failed:', error);
            throw new Error('Unable to calculate shipping rates');
        }
    }
    
    async createShipment(selectedRate, shipmentDetails) {
        try {
            const shipment = await this.client.shipment.create({
                selected_courier_id: selectedRate.courier_id,
                
                // Origin address
                origin_name: shipmentDetails.origin.name,
                origin_company_name: shipmentDetails.origin.company,
                origin_street_1: shipmentDetails.origin.street1,
                origin_street_2: shipmentDetails.origin.street2,
                origin_city: shipmentDetails.origin.city,
                origin_state: shipmentDetails.origin.state,
                origin_postal_code: shipmentDetails.origin.postalCode,
                origin_country_alpha2: shipmentDetails.origin.country,
                origin_phone: shipmentDetails.origin.phone,
                origin_email: shipmentDetails.origin.email,
                
                // Destination address
                destination_name: shipmentDetails.destination.name,
                destination_company_name: shipmentDetails.destination.company,
                destination_street_1: shipmentDetails.destination.street1,
                destination_street_2: shipmentDetails.destination.street2,
                destination_city: shipmentDetails.destination.city,
                destination_state: shipmentDetails.destination.state,
                destination_postal_code: shipmentDetails.destination.postalCode,
                destination_country_alpha2: shipmentDetails.destination.country,
                destination_phone: shipmentDetails.destination.phone,
                destination_email: shipmentDetails.destination.email,
                
                // Shipment details
                set_as_residential: shipmentDetails.isResidential,
                consignee_tax_id: shipmentDetails.destination.taxId,
                incoterms: 'DDU', // Delivered Duty Unpaid
                insurance: {
                    is_insured: true,
                    insured_amount: shipmentDetails.declaredValue,
                    insured_currency: shipmentDetails.currency
                },
                
                // Items
                items: shipmentDetails.items.map(item => ({
                    actual_weight: item.weight,
                    height: item.dimensions.height,
                    length: item.dimensions.length,
                    width: item.dimensions.width,
                    category: item.category,
                    declared_currency: item.currency,
                    declared_customs_value: item.value,
                    description: item.description,
                    hs_code: item.hsCode,
                    origin_country_alpha2: shipmentDetails.origin.country,
                    quantity: item.quantity,
                    sku: item.sku
                }))
            });
            
            return {
                shipmentId: shipment.shipment.easyship_shipment_id,
                trackingNumber: shipment.shipment.tracking_number,
                labelUrl: shipment.shipment.label_url,
                courierName: shipment.shipment.selected_courier.name,
                estimatedDelivery: shipment.shipment.delivery_time
            };
        } catch (error) {
            console.error('Shipment creation failed:', error);
            throw new Error('Failed to create shipment');
        }
    }
    
    async trackShipment(shipmentId) {
        try {
            const tracking = await this.client.shipment.retrieve(shipmentId);
            
            return {
                status: tracking.shipment.tracking.status,
                trackingNumber: tracking.shipment.tracking_number,
                courierName: tracking.shipment.selected_courier.name,
                trackingUrl: tracking.shipment.tracking_url,
                events: tracking.shipment.tracking.checkpoints.map(checkpoint => ({
                    status: checkpoint.status,
                    description: checkpoint.status_details,
                    location: checkpoint.city,
                    timestamp: new Date(checkpoint.created_at)
                }))
            };
        } catch (error) {
            console.error('Tracking failed:', error);
            throw new Error('Unable to retrieve tracking information');
        }
    }
    
    async validateAddress(address) {
        try {
            const validation = await this.client.address.validate({
                street_1: address.street1,
                street_2: address.street2,
                city: address.city,
                state: address.state,
                postal_code: address.postalCode,
                country_alpha2: address.country
            });
            
            return {
                isValid: validation.is_valid,
                correctedAddress: validation.is_valid ? validation : null,
                errors: validation.errors || []
            };
        } catch (error) {
            console.error('Address validation failed:', error);
            return { isValid: false, errors: ['Validation service unavailable'] };
        }
    }
    
    processRates(rates) {
        return rates
            .filter(rate => rate.available_handover_options.length > 0)
            .map(rate => ({
                courierId: rate.courier_id,
                courierName: rate.courier_name,
                serviceName: rate.courier_display_name,
                totalCharge: rate.shipment_charge_total,
                currency: rate.currency,
                transitTimeMin: rate.min_delivery_time,
                transitTimeMax: rate.max_delivery_time,
                isInsured: rate.is_insured,
                trackingAvailable: rate.tracking_available,
                dutyTaxCharge: rate.duty_tax_charge || 0,
                fuelSurcharge: rate.fuel_surcharge || 0,
                remoteSurcharge: rate.remote_area_surcharge || 0
            }))
            .sort((a, b) => a.totalCharge - b.totalCharge);
    }
}

// Usage example
const easyship = new EasyshipService(process.env.EASYSHIP_API_TOKEN);

// Calculate shipping rates
async function calculateShippingRates(orderData) {
    const shipmentData = {
        origin: {
            country: 'US',
            postalCode: '10001'
        },
        destination: {
            country: 'FR',
            postalCode: '75001'
        },
        items: [{
            weight: 0.5,
            dimensions: { length: 20, width: 15, height: 5 },
            value: 49.99,
            currency: 'USD',
            description: 'T-shirt cotton',
            category: 'fashion',
            quantity: 1,
            sku: 'TSHIRT-001'
        }]
    };
    
    const rates = await easyship.getRates(shipmentData);
    console.log('Available rates:', rates);
    
    return rates;
}

// Easyship Shopify webhook integration
const express = require('express');
const crypto = require('crypto');

class EasyshipShopifyIntegration {
    constructor(easyshipService, shopifyConfig) {
        this.easyship = easyshipService;
        this.shopifyConfig = shopifyConfig;
        this.app = express();
        this.setupWebhooks();
    }
    
    setupWebhooks() {
        this.app.use(express.json());
        
        // Shopify order creation webhook
        this.app.post('/webhook/shopify/orders/create', 
            this.verifyShopifyWebhook.bind(this),
            this.handleOrderCreated.bind(this)
        );
        
        // Easyship tracking updates
        this.app.post('/webhook/easyship/tracking', 
            this.handleTrackingUpdate.bind(this)
        );
    }
    
    verifyShopifyWebhook(req, res, next) {
        const hmac = req.get('X-Shopify-Hmac-Sha256');
        const body = req.body;
        const hash = crypto
            .createHmac('sha256', this.shopifyConfig.webhookSecret)
            .update(JSON.stringify(body), 'utf8')
            .digest('base64');
            
        if (hash === hmac) {
            next();
        } else {
            res.status(401).send('Unauthorized');
        }
    }
    
    async handleOrderCreated(req, res) {
        const order = req.body;
        
        try {
            // Skip if not international order
            if (this.isInternationalOrder(order)) {
                await this.processInternationalOrder(order);
            }
            
            res.status(200).send('OK');
        } catch (error) {
            console.error('Order processing failed:', error);
            res.status(500).send('Error processing order');
        }
    }
    
    async processInternationalOrder(order) {
        // Convert Shopify order to Easyship format
        const shipmentData = this.convertShopifyOrder(order);
        
        // Calculate rates for customer
        const rates = await this.easyship.getRates(shipmentData);
        
        // Auto-select best rate based on criteria
        const selectedRate = this.selectOptimalRate(rates);
        
        // Create shipment if auto-shipping enabled
        if (this.shopifyConfig.autoShip) {
            const shipment = await this.easyship.createShipment(selectedRate, shipmentData);
            
            // Update Shopify order with tracking
            await this.updateShopifyTracking(order.id, shipment);
        }
    }
    
    convertShopifyOrder(order) {
        return {
            origin: {
                name: this.shopifyConfig.origin.name,
                company: this.shopifyConfig.origin.company,
                street1: this.shopifyConfig.origin.street1,
                city: this.shopifyConfig.origin.city,
                state: this.shopifyConfig.origin.state,
                postalCode: this.shopifyConfig.origin.postalCode,
                country: this.shopifyConfig.origin.country,
                phone: this.shopifyConfig.origin.phone,
                email: this.shopifyConfig.origin.email
            },
            destination: {
                name: `${order.shipping_address.first_name} ${order.shipping_address.last_name}`,
                company: order.shipping_address.company,
                street1: order.shipping_address.address1,
                street2: order.shipping_address.address2,
                city: order.shipping_address.city,
                state: order.shipping_address.province,
                postalCode: order.shipping_address.zip,
                country: order.shipping_address.country_code,
                phone: order.shipping_address.phone
            },
            items: order.line_items.map(item => ({
                weight: item.grams / 1000, // Convert to kg
                dimensions: this.getProductDimensions(item.product_id),
                value: parseFloat(item.price),
                currency: order.currency,
                description: item.title,
                category: this.mapProductCategory(item.product_type),
                quantity: item.quantity,
                sku: item.sku
            })),
            isResidential: true,
            declaredValue: parseFloat(order.total_price)
        };
    }
    
    selectOptimalRate(rates) {
        // Priority: Balance of cost and speed
        return rates.find(rate => 
            rate.transitTimeMax <= 7 && 
            rate.totalCharge < rates[0].totalCharge * 1.2
        ) || rates[0];
    }
    
    async updateShopifyTracking(orderId, shipment) {
        const fulfillment = await this.createShopifyFulfillment(orderId, shipment);
        console.log('Shopify fulfillment created:', fulfillment.id);
    }
    
    isInternationalOrder(order) {
        return order.shipping_address.country_code !== this.shopifyConfig.origin.country;
    }
}

// Initialize integration
const integration = new EasyshipShopifyIntegration(
    easyship,
    {
        webhookSecret: process.env.SHOPIFY_WEBHOOK_SECRET,
        autoShip: true,
        origin: {
            name: 'OSCLOAD Store',
            company: 'OSCLOAD',
            street1: '123 Business St',
            city: 'New York',
            state: 'NY',
            postalCode: '10001',
            country: 'US',
            phone: '+1-555-0123',
            email: 'shipping@oscload.com'
        }
    }
);