// DHL Express API integration
const axios = require('axios');

class DHLExpressService {
    constructor(apiKey, apiSecret, accountNumber, environment = 'production') {
        this.apiKey = apiKey;
        this.apiSecret = apiSecret;
        this.accountNumber = accountNumber;
        this.baseURL = environment === 'production' 
            ? 'https://express.api.dhl.com'
            : 'https://express.api.dhl.com/mydhlapi/test';
        this.authToken = null;
    }
    
    async authenticate() {
        try {
            const credentials = Buffer.from(`${this.apiKey}:${this.apiSecret}`).toString('base64');
            
            const response = await axios.post(`${this.baseURL}/v1/oauth/token`, {
                grant_type: 'client_credentials'
            }, {
                headers: {
                    'Authorization': `Basic ${credentials}`,
                    'Content-Type': 'application/x-www-form-urlencoded'
                }
            });
            
            this.authToken = response.data.access_token;
            
            // Auto-refresh token before expiration
            setTimeout(() => this.authenticate(), (response.data.expires_in - 300) * 1000);
            
            return this.authToken;
        } catch (error) {
            console.error('DHL authentication failed:', error.response?.data || error.message);
            throw new Error('Authentication failed');
        }
    }
    
    async getRates(shipmentData) {
        if (!this.authToken) await this.authenticate();
        
        try {
            const payload = {
                customerDetails: {
                    shipperDetails: {
                        postalAddress: {
                            cityName: shipmentData.origin.city,
                            countryCode: shipmentData.origin.country,
                            postalCode: shipmentData.origin.postalCode
                        }
                    },
                    receiverDetails: {
                        postalAddress: {
                            cityName: shipmentData.destination.city,
                            countryCode: shipmentData.destination.country,
                            postalCode: shipmentData.destination.postalCode
                        }
                    }
                },
                accounts: [{
                    typeCode: 'shipper',
                    number: this.accountNumber
                }],
                productCode: 'P', // All products
                packages: shipmentData.packages.map(pkg => ({
                    weight: pkg.weight,
                    dimensions: {
                        length: pkg.dimensions.length,
                        width: pkg.dimensions.width,
                        height: pkg.dimensions.height
                    }
                })),
                plannedShippingDateAndTime: new Date().toISOString(),
                unitOfMeasurement: 'metric',
                isCustomsDeclarable: shipmentData.isInternational || false,
                monetaryAmount: shipmentData.declaredValue || 100,
                currency: shipmentData.currency || 'EUR'
            };
            
            const response = await axios.post(
                `${this.baseURL}/v1/rates`,
                payload,
                {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            return this.processRates(response.data.products);
        } catch (error) {
            console.error('DHL rate request failed:', error.response?.data || error.message);
            throw new Error('Unable to calculate rates');
        }
    }
    
    async createShipment(rateSelection, shipmentDetails) {
        if (!this.authToken) await this.authenticate();
        
        try {
            const payload = {
                plannedShippingDateAndTime: new Date().toISOString(),
                pickup: {
                    isRequested: true,
                    closeTime: "18:00",
                    location: "reception",
                    specialInstructions: shipmentDetails.pickupInstructions || []
                },
                productCode: rateSelection.productCode,
                localProductCode: rateSelection.localProductCode,
                accounts: [{
                    typeCode: 'shipper',
                    number: this.accountNumber
                }],
                customerDetails: {
                    shipperDetails: {
                        postalAddress: {
                            streetLines: [shipmentDetails.shipper.street1, shipmentDetails.shipper.street2].filter(Boolean),
                            cityName: shipmentDetails.shipper.city,
                            stateOrProvinceCode: shipmentDetails.shipper.state,
                            postalCode: shipmentDetails.shipper.postalCode,
                            countryCode: shipmentDetails.shipper.country
                        },
                        contactInformation: {
                            companyName: shipmentDetails.shipper.company,
                            fullName: shipmentDetails.shipper.name,
                            phone: shipmentDetails.shipper.phone,
                            email: shipmentDetails.shipper.email
                        }
                    },
                    receiverDetails: {
                        postalAddress: {
                            streetLines: [shipmentDetails.receiver.street1, shipmentDetails.receiver.street2].filter(Boolean),
                            cityName: shipmentDetails.receiver.city,
                            stateOrProvinceCode: shipmentDetails.receiver.state,
                            postalCode: shipmentDetails.receiver.postalCode,
                            countryCode: shipmentDetails.receiver.country
                        },
                        contactInformation: {
                            companyName: shipmentDetails.receiver.company,
                            fullName: shipmentDetails.receiver.name,
                            phone: shipmentDetails.receiver.phone,
                            email: shipmentDetails.receiver.email
                        }
                    }
                },
                content: {
                    packages: shipmentDetails.packages.map((pkg, index) => ({
                        typeCode: pkg.type || "3BX",
                        weight: pkg.weight,
                        dimensions: {
                            length: pkg.dimensions.length,
                            width: pkg.dimensions.width,
                            height: pkg.dimensions.height
                        },
                        customerReferences: [{
                            value: shipmentDetails.reference || `PKG${index + 1}`,
                            typeCode: "CU"
                        }]
                    })),
                    isCustomsDeclarable: shipmentDetails.isInternational,
                    declaredValue: shipmentDetails.declaredValue,
                    declaredValueCurrency: shipmentDetails.currency,
                    exportDeclaration: shipmentDetails.isInternational ? {
                        lineItems: shipmentDetails.items.map(item => ({
                            number: item.lineNumber || 1,
                            description: item.description,
                            price: item.unitPrice,
                            quantity: {
                                value: item.quantity,
                                unitOfMeasurement: "pcs"
                            },
                            commodityCodes: [{
                                typeCode: "outbound",
                                value: item.hsCode
                            }],
                            weight: {
                                netValue: item.weight,
                                grossValue: item.weight
                            },
                            categoryCode: "91",
                            brand: item.brand || "",
                            countryOfOrigin: item.countryOfOrigin || shipmentDetails.shipper.country
                        }))
                    } : undefined
                },
                documentImages: [{
                    typeCode: "INV", // Invoice
                    imageFormat: "PDF",
                    content: shipmentDetails.invoiceBase64 // Base64 encoded invoice
                }],
                onDemandDelivery: {
                    deliveryOption: "servicepoint",
                    location: shipmentDetails.deliveryOption?.location || "recipient"
                },
                requestOndemandDeliveryURL: true,
                shipmentNotification: [{
                    typeCode: "email",
                    receiverId: "1",
                    languageCode: shipmentDetails.language || "en",
                    languageCountryCode: shipmentDetails.shipper.country,
                    bespokeMessage: shipmentDetails.notificationMessage || ""
                }],
                prepaidCharges: rateSelection.totalPrice
            };
            
            const response = await axios.post(
                `${this.baseURL}/v1/shipments`,
                payload,
                {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            return {
                shipmentTrackingNumber: response.data.shipmentTrackingNumber,
                trackingUrl: response.data.trackingUrl,
                dispatchConfirmationNumber: response.data.dispatchConfirmationNumber,
                packages: response.data.packages.map(pkg => ({
                    trackingNumber: pkg.trackingNumber,
                    labelUrl: pkg.documents[0]?.imageFormat === 'PDF' ? pkg.documents[0].content : null
                })),
                pickupDate: response.data.pickupDetails?.readyByTime,
                estimatedDelivery: response.data.estimatedDeliveryDate
            };
        } catch (error) {
            console.error('DHL shipment creation failed:', error.response?.data || error.message);
            throw new Error('Shipment creation failed');
        }
    }
    
    async trackShipment(trackingNumber) {
        if (!this.authToken) await this.authenticate();
        
        try {
            const response = await axios.get(
                `${this.baseURL}/v1/shipments/${trackingNumber}/tracking`,
                {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`,
                        'Accept': 'application/json'
                    }
                }
            );
            
            const shipment = response.data.shipments[0];
            
            return {
                trackingNumber: shipment.shipmentTrackingNumber,
                status: shipment.status,
                service: shipment.service,
                origin: shipment.origin,
                destination: shipment.destination,
                estimatedDelivery: shipment.estimatedTimeOfDelivery,
                events: shipment.events.map(event => ({
                    timestamp: new Date(event.date + 'T' + event.time),
                    location: event.location?.address,
                    status: event.description,
                    serviceArea: event.serviceArea?.description
                }))
            };
        } catch (error) {
            console.error('DHL tracking failed:', error.response?.data || error.message);
            throw new Error('Unable to track shipment');
        }
    }
    
    async schedulePickup(pickupDetails) {
        if (!this.authToken) await this.authenticate();
        
        try {
            const payload = {
                plannedPickupDateAndTime: pickupDetails.plannedDate,
                closeTime: pickupDetails.closeTime || "18:00",
                location: pickupDetails.location || "reception",
                locationType: pickupDetails.locationType || "business",
                accounts: [{
                    typeCode: 'shipper',
                    number: this.accountNumber
                }],
                customerDetails: {
                    shipperDetails: {
                        postalAddress: {
                            streetLines: [pickupDetails.address.street1, pickupDetails.address.street2].filter(Boolean),
                            cityName: pickupDetails.address.city,
                            stateOrProvinceCode: pickupDetails.address.state,
                            postalCode: pickupDetails.address.postalCode,
                            countryCode: pickupDetails.address.country
                        },
                        contactInformation: {
                            companyName: pickupDetails.contact.company,
                            fullName: pickupDetails.contact.name,
                            phone: pickupDetails.contact.phone,
                            email: pickupDetails.contact.email
                        }
                    }
                },
                shipmentDetails: pickupDetails.shipments.map(shipment => ({
                    productCode: shipment.productCode,
                    packages: shipment.packages,
                    plannedShippingDate: shipment.plannedDate,
                    unitOfMeasurement: "metric"
                })),
                specialInstructions: pickupDetails.specialInstructions || []
            };
            
            const response = await axios.post(
                `${this.baseURL}/v1/pickups`,
                payload,
                {
                    headers: {
                        'Authorization': `Bearer ${this.authToken}`,
                        'Content-Type': 'application/json'
                    }
                }
            );
            
            return {
                dispatchConfirmationNumber: response.data.dispatchConfirmationNumber,
                readyByTime: response.data.readyByTime,
                nextPickupDate: response.data.nextPickupDate,
                warnings: response.data.warnings || []
            };
        } catch (error) {
            console.error('DHL pickup scheduling failed:', error.response?.data || error.message);
            throw new Error('Pickup scheduling failed');
        }
    }
    
    processRates(products) {
        return products
            .filter(product => product.totalPrice && product.totalPrice.length > 0)
            .map(product => ({
                productCode: product.productCode,
                localProductCode: product.localProductCode,
                productName: product.productName,
                serviceName: product.localProductName,
                totalPrice: parseFloat(product.totalPrice[0].price),
                currency: product.totalPrice[0].currency,
                deliveryCapabilities: {
                    deliveryTypeCode: product.deliveryCapabilities?.deliveryTypeCode,
                    estimatedDeliveryDateAndTime: product.deliveryCapabilities?.estimatedDeliveryDateAndTime,
                    destinationServiceAreaCode: product.deliveryCapabilities?.destinationServiceAreaCode,
                    deliveryAdditionalDays: product.deliveryCapabilities?.deliveryAdditionalDays,
                    deliveryDayOfWeek: product.deliveryCapabilities?.deliveryDayOfWeek
                },
                items: product.items?.map(item => ({
                    name: item.name,
                    price: parseFloat(item.price),
                    currency: item.priceCurrency
                })) || []
            }))
            .sort((a, b) => a.totalPrice - b.totalPrice);
    }
}

// Usage example
const dhlExpress = new DHLExpressService(
    process.env.DHL_API_KEY,
    process.env.DHL_API_SECRET,
    process.env.DHL_ACCOUNT_NUMBER,
    'production'
);

async function createExpressShipment(orderData) {
    try {
        // Calculate rates first
        const rates = await dhlExpress.getRates({
            origin: {
                city: 'Paris',
                country: 'FR',
                postalCode: '75001'
            },
            destination: {
                city: 'New York',
                country: 'US',
                postalCode: '10001'
            },
            packages: [{
                weight: 2.5,
                dimensions: { length: 30, width: 20, height: 15 }
            }],
            isInternational: true,
            declaredValue: 299.99,
            currency: 'EUR'
        });
        
        // Select Express 10:30 service if available
        const selectedRate = rates.find(rate => 
            rate.productName.includes('10:30')) || rates[0];
        
        // Create shipment
        const shipment = await dhlExpress.createShipment(selectedRate, {
            shipper: {
                name: 'OSCLOAD Store',
                company: 'OSCLOAD SAS',
                street1: '123 Business Street',
                city: 'Paris',
                postalCode: '75001',
                country: 'FR',
                phone: '+33123456789',
                email: 'shipping@oscload.com'
            },
            receiver: orderData.receiver,
            packages: orderData.packages,
            items: orderData.items,
            isInternational: true,
            declaredValue: orderData.value,
            currency: 'EUR',
            reference: orderData.orderNumber
        });
        
        console.log('DHL Express shipment created:', shipment.shipmentTrackingNumber);
        return shipment;
    } catch (error) {
        console.error('Express shipment failed:', error);
        throw error;
    }
}