// ShipStation API integration
class ShipStationAPI {
    constructor(apiKey, apiSecret) {
        this.baseUrl = 'https://ssapi.shipstation.com';
        this.credentials = Buffer.from(`${apiKey}:${apiSecret}`).toString('base64');
    }
    
    async makeRequest(endpoint, method = 'GET', data = null) {
        const options = {
            method: method,
            headers: {
                'Authorization': `Basic ${this.credentials}`,
                'Content-Type': 'application/json'
            }
        };
        
        if (data && method !== 'GET') {
            options.body = JSON.stringify(data);
        }
        
        const response = await fetch(`${this.baseUrl}${endpoint}`, options);
        
        if (!response.ok) {
            throw new Error(`ShipStation API error: ${response.statusText}`);
        }
        
        return response.json();
    }
    
    async getOrders(status = 'awaiting_shipment') {
        return await this.makeRequest(`/orders?orderStatus=${status}`);
    }
    
    async createShipment(orderData) {
        const shipmentData = {
            orderId: orderData.orderId,
            carrierCode: orderData.carrierCode,
            serviceCode: orderData.serviceCode,
            packageCode: orderData.packageCode,
            confirmation: orderData.confirmation || 'none',
            shipDate: new Date().toISOString().split('T')[0],
            weight: {
                value: orderData.weight,
                units: 'ounces'
            },
            dimensions: orderData.dimensions,
            shipFrom: orderData.shipFrom,
            shipTo: orderData.shipTo,
            insuranceOptions: orderData.insurance,
            internationalOptions: orderData.international
        };
        
        return await this.makeRequest('/shipments/createlabel', 'POST', shipmentData);
    }
    
    async getCarriers() {
        return await this.makeRequest('/carriers');
    }
    
    async getRates(rateData) {
        const request = {
            carrierCode: rateData.carrierCode,
            fromPostalCode: rateData.fromPostalCode,
            toState: rateData.toState,
            toPostalCode: rateData.toPostalCode,
            toCountry: rateData.toCountry,
            weight: {
                value: rateData.weight,
                units: 'ounces'
            },
            dimensions: rateData.dimensions,
            confirmation: rateData.confirmation || 'none'
        };
        
        return await this.makeRequest('/shipments/getrates', 'POST', request);
    }
    
    async trackPackage(carrierCode, trackingNumber) {
        return await this.makeRequest(`/shipments/track?carrierCode=${carrierCode}&trackingNumber=${trackingNumber}`);
    }
    
    async voidLabel(shipmentId) {
        return await this.makeRequest(`/shipments/voidlabel`, 'POST', { shipmentId });
    }
}

// Shipping automation service
class ShippingAutomation {
    constructor(shipStation) {
        this.shipStation = shipStation;
        this.automationRules = [];
    }
    
    addRule(rule) {
        this.automationRules.push(rule);
    }
    
    async processOrders() {
        try {
            const orders = await this.shipStation.getOrders();
            
            for (const order of orders.orders) {
                const shippingDecision = this.applyRules(order);
                
                if (shippingDecision.autoShip) {
                    await this.createAutomatedShipment(order, shippingDecision);
                }
            }
        } catch (error) {
            console.error('Order processing failed:', error);
        }
    }
    
    applyRules(order) {
        let decision = {
            carrierCode: 'usps',
            serviceCode: 'usps_priority_mail',
            packageCode: 'package',
            autoShip: false,
            insurance: null
        };
        
        for (const rule of this.automationRules) {
            if (rule.condition(order)) {
                decision = { ...decision, ...rule.action };
            }
        }
        
        return decision;
    }
    
    async createAutomatedShipment(order, decision) {
        try {
            const shipmentData = {
                orderId: order.orderId,
                carrierCode: decision.carrierCode,
                serviceCode: decision.serviceCode,
                packageCode: decision.packageCode,
                weight: this.calculateWeight(order.orderItems),
                dimensions: this.calculateDimensions(order.orderItems),
                shipFrom: this.getWarehouseAddress(),
                shipTo: order.shipTo,
                insurance: decision.insurance
            };
            
            const result = await this.shipStation.createShipment(shipmentData);
            
            if (result.shipmentId) {
                await this.sendShippingNotification(order, result);
            }
            
            return result;
        } catch (error) {
            console.error(`Automated shipment failed for order ${order.orderId}:`, error);
        }
    }
    
    calculateWeight(items) {
        return items.reduce((total, item) => {
            return total + (item.weight * item.quantity);
        }, 0);
    }
    
    calculateDimensions(items) {
        // Simplified dimension calculation
        const totalVolume = items.reduce((volume, item) => {
            return volume + (item.length * item.width * item.height * item.quantity);
        }, 0);
        
        // Convert to cubic packaging
        const side = Math.ceil(Math.pow(totalVolume, 1/3));
        
        return {
            units: 'inches',
            length: Math.max(side, 6),
            width: Math.max(side, 4),
            height: Math.max(side, 2)
        };
    }
    
    getWarehouseAddress() {
        return {
            name: 'Your Warehouse',
            street1: '123 Warehouse St',
            city: 'Los Angeles',
            state: 'CA',
            postalCode: '90210',
            country: 'US',
            phone: '555-0123'
        };
    }
    
    async sendShippingNotification(order, shipment) {
        // Send email/SMS notification to customer
        console.log(`Shipping notification sent for order ${order.orderNumber}`);
        console.log(`Tracking number: ${shipment.trackingNumber}`);
    }
}

// Usage example
const shipStation = new ShipStationAPI('your-api-key', 'your-api-secret');
const automation = new ShippingAutomation(shipStation);

// Add automation rules
automation.addRule({
    condition: (order) => order.orderTotal > 100,
    action: {
        carrierCode: 'fedex',
        serviceCode: 'fedex_2day',
        autoShip: true,
        insurance: { provider: 'carrier', insureShipment: true, insuredValue: order.orderTotal }
    }
});

automation.addRule({
    condition: (order) => order.orderTotal < 50,
    action: {
        carrierCode: 'usps',
        serviceCode: 'usps_first_class_mail',
        autoShip: true
    }
});

// Process orders daily
setInterval(async () => {
    await automation.processOrders();
}, 24 * 60 * 60 * 1000); // Run daily

// Shopify + ShipStation integration
class ShopifyShipStationSync {
    constructor(shopifyConfig, shipStationAPI) {
        this.shopify = shopifyConfig;
        this.shipStation = shipStationAPI;
        this.webhookEndpoints = [
            'orders/create',
            'orders/updated',
            'orders/cancelled'
        ];
    }
    
    async setupWebhooks() {
        for (const endpoint of this.webhookEndpoints) {
            await this.createWebhook(endpoint);
        }
    }
    
    async createWebhook(topic) {
        const webhook = {
            webhook: {
                topic: topic,
                address: `${process.env.BASE_URL}/webhooks/shopify/${topic.replace('/', '_')}`,
                format: 'json'
            }
        };
        
        // Create webhook in Shopify
        // Implementation depends on Shopify API client
    }
    
    async handleOrderCreated(orderData) {
        try {
            // Transform Shopify order to ShipStation format
            const shipStationOrder = this.transformOrder(orderData);
            
            // Create order in ShipStation
            await this.shipStation.makeRequest('/orders/createorder', 'POST', shipStationOrder);
            
        } catch (error) {
            console.error('Order sync failed:', error);
        }
    }
    
    transformOrder(shopifyOrder) {
        return {
            orderNumber: shopifyOrder.order_number,
            orderKey: shopifyOrder.id.toString(),
            orderDate: shopifyOrder.created_at,
            paymentDate: shopifyOrder.processed_at,
            shipByDate: this.calculateShipByDate(shopifyOrder.created_at),
            orderStatus: this.mapOrderStatus(shopifyOrder.fulfillment_status),
            customerId: shopifyOrder.customer.id,
            customerUsername: shopifyOrder.customer.email,
            customerEmail: shopifyOrder.customer.email,
            billTo: this.transformAddress(shopifyOrder.billing_address),
            shipTo: this.transformAddress(shopifyOrder.shipping_address),
            items: shopifyOrder.line_items.map(item => this.transformLineItem(item)),
            orderTotal: parseFloat(shopifyOrder.total_price),
            amountPaid: parseFloat(shopifyOrder.total_price),
            taxAmount: parseFloat(shopifyOrder.total_tax),
            shippingAmount: parseFloat(shopifyOrder.total_shipping_price_set.shop_money.amount),
            customerNotes: shopifyOrder.note,
            internalNotes: `Shopify Order ID: ${shopifyOrder.id}`,
            gift: shopifyOrder.note && shopifyOrder.note.toLowerCase().includes('gift'),
            giftMessage: this.extractGiftMessage(shopifyOrder.note)
        };
    }
    
    transformAddress(address) {
        if (!address) return null;
        
        return {
            name: `${address.first_name} ${address.last_name}`,
            company: address.company || '',
            street1: address.address1,
            street2: address.address2 || '',
            city: address.city,
            state: address.province_code,
            postalCode: address.zip,
            country: address.country_code,
            phone: address.phone || ''
        };
    }
    
    transformLineItem(item) {
        return {
            lineItemKey: item.id.toString(),
            sku: item.sku || item.variant_id.toString(),
            name: item.name,
            imageUrl: item.image?.src || '',
            weight: {
                value: item.grams || 16, // Default 1 oz
                units: 'grams'
            },
            quantity: item.quantity,
            unitPrice: parseFloat(item.price),
            taxAmount: 0, // Calculated separately
            shippingAmount: 0,
            warehouseLocation: 'Default',
            options: item.variant_title ? [{ name: 'Variant', value: item.variant_title }] : [],
            productId: item.product_id,
            fulfillmentSku: item.sku,
            adjustment: false,
            upc: item.barcode || ''
        };
    }
    
    mapOrderStatus(fulfillmentStatus) {
        const statusMap = {
            null: 'awaiting_shipment',
            'partial': 'awaiting_shipment',
            'fulfilled': 'shipped'
        };
        
        return statusMap[fulfillmentStatus] || 'awaiting_shipment';
    }
    
    calculateShipByDate(orderDate) {
        const order = new Date(orderDate);
        const shipBy = new Date(order);
        
        // Add 2 business days
        let daysToAdd = 2;
        while (daysToAdd > 0) {
            shipBy.setDate(shipBy.getDate() + 1);
            // Skip weekends
            if (shipBy.getDay() !== 0 && shipBy.getDay() !== 6) {
                daysToAdd--;
            }
        }
        
        return shipBy.toISOString();
    }
    
    extractGiftMessage(note) {
        if (!note) return '';
        
        const giftMatch = note.match(/gift message:\s*(.+)/i);
        return giftMatch ? giftMatch[1].trim() : '';
    }
}