// Actual response schema from the POST /api/commerce/inventory/v5/inventory endpoint
[
  {
        "locationName": "Dallas FC",
        "locationCode": "DFW1",
        "active": true,
        "tenantID": 100041,
        "onHand": 3,
        "available": 3,
        "allocated": 0,
        "pending": 0,
        "upc": "41020990357584",
        "blockAssignment": false,
        "holdBlockAssignment": false,
        "ltd": 0,
        "floor": 0,
        "safetyStock": 0,
        "distance": 0.003743714,
        "directShip": true,
        "deliveryEnabled": false,
        "transferEnabled": false,
        "pickup": false,
        "countryCode": "US",
        "attributes": []
    },
    {
        "locationName": "Dallas FC",
        "locationCode": "DFW1",
        "active": true,
        "tenantID": 100041,
        "onHand": 1000,
        "available": 996,
        "allocated": 4,
        "pending": 0,
        "upc": "CampStove_003",
        "blockAssignment": false,
        "holdBlockAssignment": false,
        "ltd": 0,
        "floor": 0,
        "safetyStock": 0,
        "distance": 0.003743714,
        "directShip": true,
        "deliveryEnabled": false,
        "transferEnabled": false,
        "pickup": false,
        "countryCode": "US",
        "attributes": []
    },
]

// We'll build this step by step:
// 1. **Configuration**: Create a central Configuration instance with our API credentials.
// 2. **API Client Instantiation**: Create a dedicated client for the Inventory resource.
// 3. **Data Preparation**: Construct the 'InventoryRequest' object with the products and locations we want to query.
// 4. **API Call**: Use the 'InventoryApi' client to call the 'postQueryInventory' method.

// Essential imports for Inventory operations.
// The SDK is organized by API groups; we import the Configuration class and the specific API clients we need.
import { Configuration } from "@kibocommerce/rest-sdk";
import { InventoryApi } from "@kibocommerce/rest-sdk/clients/Inventory";
import { InventoryRequest } from "@kibocommerce/rest-sdk/models/Inventory";

// Configuration setup - this single object is reused for all API clients.
const configuration = new Configuration({
    tenantId: process.env.KIBO_TENANT_ID,
    siteId: process.env.KIBO_SITE_ID,
    clientId: process.env.KIBO_CLIENT_ID,
    sharedSecret: process.env.KIBO_SHARED_SECRET,
    authHost: process.env.KIBO_AUTH_HOST,
});

// Complete working example that ACTUALLY WORKS with the Kibo API
// This function checks inventory for specific products at given locations.

async function checkProductInventory() {
    // 1. Instantiate a dedicated client for the Inventory API.
    const inventoryApi = new InventoryApi(configuration);

    // 2. Prepare the request body.
    //    This object must match the 'InventoryRequest' schema defined in the Kibo API documentation.
    const payload: InventoryRequest = {
        type: "ANY",    
        items: [
            { partNumber: "SHIRT-BLUE-SM", upc: "111222333444", quantity: "1" },
            { partNumber: "PANTS-BLK-32", upc: "555666777888", quantity: "1" },
        ],
        locationCodes: ["WAREHOUSE-01", "STORE-AUSTIN"],
        // You can set 'includeNegativeInventory' to true if needed
    };

    console.log("Attempting to fetch inventory for multiple items...");

    // 3. Call the 'postQueryInventory' method on the client.
    try {
        const inventoryCollection = await inventoryApi.postQueryInventory({
            inventoryRequest: payload,
        });

        console.log("Success: Inventory data received:");
        inventoryCollection.items?.forEach(locationInventory => {
            console.log(`\n--- Location: ${locationInventory.locationCode} ---`);
            locationInventory.items?.forEach(item => {
                console.log(`  - Product: ${item.partNumber}, Available: ${item.available}`);
            });
        });
        return inventoryCollection;
    } catch (error: any) {
        console.error("API Error:", JSON.stringify(error, null, 2));
    }
}

checkProductInventory();

// Wrong (inefficient) - This makes one API call per product/location combo.
for (const product of products) {
    for (const location of locations) {
       // await inventoryApi.getInventory({ locationCode: location, partNumber: product.partNumber });
    }
}

// Correct - Use the bulk endpoint for much better performance.
const inventory = await inventoryApi.postQueryInventory({ inventoryRequest: { items, locationCodes } });

// ... imports and configuration setup ...
import { InventoryApi } from "@kibocommerce/rest-sdk/clients/Inventory";
import { InventoryAdjustment } from "@kibocommerce/rest-sdk/models/Inventory";

async function adjustStockQuantity() {
    const inventoryApi = new InventoryApi(configuration);
    
    // Prepare a list of adjustments.
    // A positive quantity increases stock, a negative quantity decreases it.
    const adjustments: InventoryAdjustment[] = [{
       "locationCode": "WAREHOUSE-01",
       "items": [
          {
            "upc": "PANTS-BLK-32", //mandatory field
            "quantity": 10, //+ve adjustment as a result of cyclecount
            "safetyStock": 2 //increasing safety stock by 2
          },
          {
            "upc": "PANTS-BLK-33",
            "quantity": -2, //negative adjustment, found damaged product
            "safetyStock": 0 // no change in safety stock
          }
       ]
    }];

    console.log("Submitting inventory adjustment...");
    try {
        await inventoryApi.adjust({ inventoryAdjustment: adjustments });
        console.log("Success: Inventory adjustment completed.");
    } catch (error: any)
    {
        console.error("API Error:", JSON.stringify(error, null, 2));
    }
}

// adjustStockQuantity();

// ... imports and configuration setup ...
import { InventoryApi } from "@kibocommerce/rest-sdk/clients/Inventory";
import { RefreshRequest } from "@kibocommerce/rest-sdk/models/Inventory";

async function refreshStockLevels() {
    const inventoryApi = new InventoryApi(configuration);

    // Prepare a refresh request. This will SET the onHand quantity to the specified value.
    const payload: RefreshRequest = {
        locationCode: "WAREHOUSE-01",
        items: [{
            partNumber: "PANTS-BLK-32",
            upc: "PANTS-BLK-32",
            sku: "PANTS-BLK-32",
            ltd: 0,
            floor: 0,
            quantity: 250, // Our ERP says we have exactly 250 units.
            safetyStock: 0, //Represents qty for balancing minimum qty at location
            condition: "", //Any particular tags used for inventory like damaged
            deliveryDate: "", //Date at which particular qty is expected, often used along with condition
            externalID: "", //Any reference number like purchase order 
        }]
    };
    
    console.log("Refreshing inventory from source of truth...");
    try {
        await inventoryApi.refresh({ refreshRequest: payload });
        console.log("Success: Inventory refresh completed.");
    } catch (error: any) {
        console.error("API Error:", JSON.stringify(error, null, 2));
    }
}

// refreshStockLevels();

// ... imports and configuration setup ...
import { ExportSettingsApi } from "@kibocommerce/rest-sdk/clients/Inventory";
import { ExportSettings } from "@kibocommerce/rest-sdk/models/Inventory";

async function createDailyExport() {
    // Note: We use the dedicated 'ExportSettingsApi' for this.
    const exportApi = new ExportSettingsApi(configuration);

    const exportConfig: ExportSettings = {
        exportSettings: {
        name: "Daily_ERP_Inventory_Sync", // Must be unique
        fileFormat: "CSV", //supported format are XML, CSV
        exportType: "AGGREGATE", //Type can be LOCATION, AGGREGATE
        ftpInformation: {
          name: "client ftp"
          ftpServer: "ftp.my-erp.com",
          ftpPort: "22",
          ftpUser: "kibo-ftp-user",
          ftpPassword: "SecurePassword123", // Use secrets management in production
          ftpDirectory: "/incoming/inventory/"
        }
        }
    };
    console.log(`Creating export settings: ${exportConfig.name}`);
    try {
        const newExport = await exportApi.createExportSettings({ exportSettings: exportConfig });
        console.log("Success: Created new export settings with name:", newExport.name);
        return newExport;
    } catch (error: any) {
        console.error("API Error:", JSON.stringify(error, null, 2));
    }
}

// createDailyExport();

// ... imports and configuration setup ...
import { JobApi } from "@kibocommerce/rest-sdk/clients/Inventory";

async function checkRecentJobs() {
    // Note: We use the 'JobApi' for this operation.
    const jobApi = new JobApi(configuration);
    
    console.log("Fetching recent inventory jobs...");
    try {
        const jobCollection = await jobApi.getJobs({ pageSize: 5 }); // Get the 5 most recent
        
        console.log(`Success: Found ${jobCollection.totalCount} total jobs.`);
        jobCollection.items?.forEach(job => {
            console.log(`
  - Job ID: ${job.jobID}, Type: ${job.type}, Status: ${job.status}
            `);
        });
        return jobCollection;
    } catch (error: any) {
        console.error("API Error:", JSON.stringify(error, null, 2));
    }
}

// checkRecentJobs();

// ... imports and configuration setup ...
import { FetchFileConfigApi } from "@kibocommerce/rest-sdk/clients/Inventory";
import { FetchFileConfig } from "@kibocommerce/rest-sdk/models/Inventory";

async function setupInventoryImport() {
    const fetchApi = new FetchFileConfigApi(configuration);
    
    const fetchConfig: FetchFileConfig = {
        active: "true",
        ftpServer: "sftp.my-wms.com",
        ftpUsername: "kibo-sftp",
        ftpPassword: "123*",
        ftpPort: "22",
        // In a real scenario, you'd use SFTP private key authentication
        ftpRemotePath: "/outgoing/kibo-updates/*.csv",
        ftpRemotePathArchive: "/outgoing/kibo-updates/archive/",
        lockName: "inventory.lock",
        postProcessAction: "1", //1 - move to archive, 2 - delete, 0 - do nothing

    };

    console.log("Saving fetch file configuration...");
    try {
        const newConfig = await fetchApi.saveFetchFileConfig({ fetchFileConfig: fetchConfig });
        console.log("Success: Configuration saved.", newConfig);
        return newConfig;
    } catch (error: any) {
        console.error("API Error:", JSON.stringify(error, null, 2));
    }
}

// setupInventoryImport();

// Actual error structure from Kibo API documentation
interface KiboApiError {
  body: {
    message: string;
    errorCode: string;           // e.g., "ITEM_NOT_FOUND"
    correlationId: string;
    // For some errors, additional context is provided
    items?: Array<{
        name: string;
        errorCode: string;
        message: string;
    }>
  }
}