// Amazon Selling Partner API integration
const { SellingPartnerAPI } = require('@whitebox-co/amazon-sp-api');

class AmazonFBAService {
    constructor(credentials) {
        this.spApi = new SellingPartnerAPI(credentials);
        this.marketplaceId = credentials.marketplaceId;
    }
    
    async getInventoryLevels() {
        try {
            const response = await this.spApi.callAPI({
                operation: 'getFbaInventorySummaries',
                endpoint: 'fbaInventory',
                query: {
                    granularityType: 'Marketplace',
                    granularityId: this.marketplaceId,
                    marketplaceIds: [this.marketplaceId]
                }
            });
            
            return response.data.inventorySummaries.map(item => ({
                asin: item.asin,
                fnSku: item.fnSku,
                sellerSku: item.sellerSku,
                condition: item.condition,
                totalQuantity: item.totalQuantity,
                inStockSupplyQuantity: item.inStockSupplyQuantity,
                reservedQuantity: item.reservedQuantity || 0,
                researchingQuantity: item.researchingQuantity || 0,
                unfulfillableQuantity: item.unfulfillableQuantity || 0
            }));
        } catch (error) {
            console.error('Failed to get inventory levels:', error);
            throw new Error('Inventory data retrieval failed');
        }
    }
    
    async createInboundShipment(shipmentData) {
        try {
            // Step 1: Create inbound shipment plan
            const planResponse = await this.spApi.callAPI({
                operation: 'createInboundShipmentPlan',
                endpoint: 'fulfillmentInbound',
                body: {
                    shipFromAddress: shipmentData.shipFromAddress,
                    labelPrepPreference: shipmentData.labelPrepPreference || 'SELLER_LABEL',
                    inboundShipmentPlanRequestItems: shipmentData.items.map(item => ({
                        sellerSku: item.sellerSku,
                        asin: item.asin,
                        condition: item.condition || 'NewItem',
                        quantity: item.quantity,
                        quantityInCase: item.quantityInCase || 1,
                        prepDetailsList: item.prepDetailsList || []
                    }))
                }
            });
            
            const shipmentPlan = planResponse.data.inboundShipmentPlans[0];
            
            // Step 2: Create inbound shipment
            const shipmentResponse = await this.spApi.callAPI({
                operation: 'createInboundShipment',
                endpoint: 'fulfillmentInbound',
                path: {
                    shipmentId: shipmentPlan.shipmentId
                },
                body: {
                    inboundShipmentHeader: {
                        shipmentName: shipmentData.shipmentName,
                        shipFromAddress: shipmentData.shipFromAddress,
                        destinationFulfillmentCenterId: shipmentPlan.destinationFulfillmentCenterId,
                        shipmentStatus: 'WORKING',
                        labelPrepPreference: shipmentData.labelPrepPreference || 'SELLER_LABEL',
                        areCasesRequired: shipmentData.areCasesRequired || false
                    },
                    inboundShipmentItems: shipmentPlan.items.map(item => ({
                        shipmentId: shipmentPlan.shipmentId,
                        sellerSku: item.sellerSku,
                        fulfillmentNetworkSku: item.fulfillmentNetworkSku,
                        quantityShipped: item.quantity,
                        quantityReceived: 0,
                        quantityInCase: item.quantityInCase || 1,
                        releaseDate: shipmentData.releaseDate,
                        prepDetailsList: item.prepDetailsList || []
                    }))
                }
            });
            
            return {
                shipmentId: shipmentPlan.shipmentId,
                destinationFulfillmentCenter: shipmentPlan.destinationFulfillmentCenterId,
                shipmentItems: shipmentPlan.items,
                estimatedBoxContentsFee: shipmentPlan.estimatedBoxContentsFee
            };
        } catch (error) {
            console.error('Inbound shipment creation failed:', error);
            throw new Error('Failed to create inbound shipment');
        }
    }
    
    async getShipmentLabels(shipmentId, pageType = 'PackageLabel_Letter_6') {
        try {
            const response = await this.spApi.callAPI({
                operation: 'getLabels',
                endpoint: 'fulfillmentInbound',
                path: {
                    shipmentId: shipmentId
                },
                query: {
                    pageType: pageType,
                    labelType: 'BARCODE_2D',
                    numberOfPackages: 1
                }
            });
            
            return {
                downloadURL: response.data.downloadURL,
                labelDimensions: response.data.labelDimensions
            };
        } catch (error) {
            console.error('Label generation failed:', error);
            throw new Error('Failed to generate shipping labels');
        }
    }
    
    async trackInboundShipment(shipmentId) {
        try {
            const response = await this.spApi.callAPI({
                operation: 'getInboundShipment',
                endpoint: 'fulfillmentInbound',
                path: {
                    shipmentId: shipmentId
                }
            });
            
            const shipment = response.data;
            
            return {
                shipmentId: shipment.shipmentId,
                shipmentName: shipment.shipmentName,
                shipmentStatus: shipment.shipmentStatus,
                destinationFulfillmentCenterId: shipment.destinationFulfillmentCenterId,
                shipFromAddress: shipment.shipFromAddress,
                createdDate: shipment.createdDate,
                lastUpdatedDate: shipment.lastUpdatedDate,
                boxContentsSource: shipment.boxContentsSource
            };
        } catch (error) {
            console.error('Shipment tracking failed:', error);
            throw new Error('Unable to track inbound shipment');
        }
    }
    
    async getFBAFees(asinList) {
        try {
            const response = await this.spApi.callAPI({
                operation: 'getMyFeesEstimateForASIN',
                endpoint: 'productFees',
                body: {
                    feesEstimateRequest: {
                        marketplaceId: this.marketplaceId,
                        isAmazonFulfilled: true,
                        priceToEstimateFees: {
                            listingPrice: { currencyCode: 'EUR', amount: 0 }
                        },
                        identifier: asinList[0] // Single ASIN for simplicity
                    }
                }
            });
            
            return response.data.feesEstimate.feesEstimateResult.feesEstimate.totalFeesEstimate;
        } catch (error) {
            console.error('FBA fees calculation failed:', error);
            throw new Error('Unable to calculate FBA fees');
        }
    }
    
    async getStorageFees(startDate, endDate) {
        try {
            const response = await this.spApi.callAPI({
                operation: 'getFbaInventoryAndStorageFeesReport',
                endpoint: 'reports',
                body: {
                    reportType: 'GET_FBA_STORAGE_FEE_CHARGES_DATA',
                    dataStartTime: startDate,
                    dataEndTime: endDate,
                    marketplaceIds: [this.marketplaceId]
                }
            });
            
            return {
                reportId: response.data.reportId,
                reportType: response.data.reportType,
                processingStatus: response.data.processingStatus
            };
        } catch (error) {
            console.error('Storage fees report failed:', error);
            throw new Error('Unable to retrieve storage fees');
        }
    }
    
    async optimizeInventoryPlacement(items) {
        try {
            const response = await this.spApi.callAPI({
                operation: 'getInboundGuidance',
                endpoint: 'fulfillmentInbound',
                body: {
                    marketplaceId: this.marketplaceId,
                    asinList: items.map(item => item.asin)
                }
            });
            
            return response.data.asinInboundGuidanceList.map(guidance => ({
                asin: guidance.asin,
                inboundGuidance: guidance.inboundGuidance,
                guidanceReasonList: guidance.guidanceReasonList || []
            }));
        } catch (error) {
            console.error('Inventory guidance failed:', error);
            throw new Error('Unable to get inventory placement guidance');
        }
    }
}

// Usage example
const fbaService = new AmazonFBAService({
    region: 'eu-west-1',
    refresh_token: process.env.AMAZON_REFRESH_TOKEN,
    client_id: process.env.AMAZON_CLIENT_ID,
    client_secret: process.env.AMAZON_CLIENT_SECRET,
    marketplaceId: 'A1RKKUPIHCS9HS' // Amazon.es
});

// Create inbound shipment
async function createFBAShipment(productData) {
    try {
        const shipmentData = {
            shipmentName: `Inbound-${Date.now()}`,
            shipFromAddress: {
                name: 'Your Company',
                addressLine1: '123 Business Street',
                city: 'Madrid',
                countryCode: 'ES',
                stateOrProvinceCode: 'MD',
                postalCode: '28001'
            },
            items: productData.items,
            labelPrepPreference: 'SELLER_LABEL',
            areCasesRequired: false
        };
        
        const result = await fbaService.createInboundShipment(shipmentData);
        console.log('FBA shipment created:', result.shipmentId);
        
        // Generate and download labels
        const labels = await fbaService.getShipmentLabels(result.shipmentId);
        console.log('Labels available at:', labels.downloadURL);
        
        return result;
    } catch (error) {
        console.error('FBA shipment creation failed:', error);
        throw error;
    }
}