// Actual response schema from the suggestRouting endpoint
{
  "suggestionId": "e1f2b6e1-...",
  "orderId": "065c71b12476b7000184b123",
  "shipments": [
    {
      "locationCode": "WAREHOUSE-01",
      "items": [
        {
          "lineId": 1,
          "productCode": "SHIRT-BLUE-SM",
          "quantity": 1
        }
      ]
    }
  ],
  "warnings": []
}

// 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 Order Routing resource.
// 3. **Data Preparation**: Construct the 'SuggestionRequest' object, which primarily contains the order ID.
// 4. **API Call**: Use the 'OrderRoutingApi' client to call the 'suggestRouting' method.

// Essential imports for Order Routing operations.
// The SDK client for this is found under the 'Fulfillment' group.
import { Configuration } from "@kibocommerce/rest-sdk";
import { OrderRoutingApi } from "@kibocommerce/rest-sdk/clients/Fulfillment";
import { SuggestionRequest } from "@kibocommerce/rest-sdk/models/Fulfillment";

// 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 gets the optimal fulfillment plan for a given order ID.

async function getFulfillmentSuggestion(orderId: string) {
    // 1. Instantiate a dedicated client for the Order Routing API.
    const orderRoutingApi = new OrderRoutingApi(configuration);

    // 2. Prepare the request body.
    //    The schema requires a 'SuggestionRequest' object.
    const payload: SuggestionRequest = {
        orderId: orderId,
        // You can optionally specify which line items to route,
        // but by default, it will route all unfulfilled items.
    };

    console.log(`Attempting to get routing suggestion for Order ID: ${orderId}`);

    // 3. Call the 'suggestRouting' method.
    try {
        const suggestion = await orderRoutingApi.suggestRouting({
            suggestionRequest: payload,
        });

        if (suggestion.shipments && suggestion.shipments.length > 0) {
            console.log("Success: Success! Optimal route found:");
            suggestion.shipments.forEach((shipment, index) => {
                console.log(`  - Shipment ${index + 1}: Fulfill from Location '${shipment.locationCode}'`);
                shipment.items?.forEach(item => {
                    console.log(`    - Item: ${item.productCode}, Quantity: ${item.quantity}`);
                });
            });
        } else {
            console.warn("Warning: Could not find a valid route. The order may be unfulfillable.");
            suggestion.warnings?.forEach(warning => console.warn(`   - Warning: ${warning.message}`));
        }
        return suggestion;
    } catch (error: any) {
        console.error("Error: API Error:", JSON.stringify(error, null, 2));
    }
}

// Usage with a real, pending Order ID from your Kibo tenant
// getFulfillmentSuggestion("065c71b12476b7000184b123");

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

async function getFulfillmentCandidates(orderId: string) {
    const orderRoutingApi = new OrderRoutingApi(configuration);
    console.log(`Fetching all fulfillment candidates for Order ID: ${orderId}`);
    
    try {
        // The payload is the same SuggestionRequest as suggestRouting
        const candidatesResponse = await orderRoutingApi.suggestCandidates({ 
            suggestionRequest: { orderId: orderId } 
        });

        console.log(`Success: Found ${candidatesResponse.candidates?.length} candidates.`);
        candidatesResponse.candidates?.forEach(candidate => {
            console.log(`
  - Location '${candidate.locationCode}' can fulfill:
    ${candidate.items?.map(i => `  - ${i.quantity}x ${i.productCode}`).join('\n')}
            `);
        });
        return candidatesResponse;
    } catch (error: any) {
        console.error("Error: API Error:", JSON.stringify(error, null, 2));
    }
}

// Usage
// getFulfillmentCandidates("065c71b12476b7000184b123");

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

async function getRoutingDebugLog(suggestionId: string) {
    const orderRoutingApi = new OrderRoutingApi(configuration);
    console.log(`Fetching suggestion log for Suggestion ID: ${suggestionId}`);
    
    try {
        // Note: This endpoint requires the suggestionId, not the orderId.
        const logs = await orderRoutingApi.getSuggestionLog({ suggestionId: suggestionId });
        
        console.log("Success: Success! Log retrieved.");
        logs.forEach(log => {
            console.log(`[${log.logLevel}] ${log.message}`);
        });
        return logs;

    } catch (error: any) {
        console.error("Error: API Error:", JSON.stringify(error, null, 2));
    }
}

// First, get a suggestion to have a suggestionId
async function debugRouting(orderId: string) {
    const suggestion = await getFulfillmentSuggestion(orderId);
    if (suggestion?.suggestionId) {
        await getRoutingDebugLog(suggestion.suggestionId);
    }
}

// Usage
// debugRouting("065c71b12476b7000184b123");

// ... imports and configuration setup ...
import { OrderRoutingApi } from "@kibocommerce/rest-sdk/clients/Fulfillment";
import { SuggestionRequest } from "@kibocommerce/rest-sdk/models/Fulfillment";

async function getFastestFulfillmentSuggestion(orderId: string) {
    const orderRoutingApi = new OrderRoutingApi(configuration);
    
    const payload: SuggestionRequest = { orderId: orderId };
    console.log(`Getting EDD-aware routing suggestion for Order ID: ${orderId}`);
    
    try {
        // This endpoint has the same request shape but uses different underlying logic.
        const suggestion = await orderRoutingApi.suggestRoutingWithEDD({
            suggestionRequest: payload
        });
        
        // The response shape is the same as the standard suggestRouting
        if (suggestion.shipments && suggestion.shipments.length > 0) {
            console.log("Success: Success! EDD-optimized route found:", suggestion.shipments);
        } else {
            console.warn("Warning: Could not find a valid EDD-aware route.");
        }
        return suggestion;
    } catch (error: any) {
        console.error("Error: API Error:", JSON.stringify(error, null, 2));
    }
}

// Usage
// getFastestFulfillmentSuggestion("065c71b12476b7000184b123");

// ... imports and configuration setup ...
// We need both OrderRoutingApi and ShipmentApi for this!
import { OrderRoutingApi, ShipmentApi } from "@kibocommerce/rest-sdk/clients/Fulfillment";
import { Shipment } from "@kibocommerce/rest-sdk/models/Fulfillment";

async function routeAndFulfillOrder(orderId: string) {
    const orderRoutingApi = new OrderRoutingApi(configuration);
    const shipmentApi = new ShipmentApi(configuration);

    // Step 1: Get the routing suggestion
    const suggestion = await orderRoutingApi.suggestRouting({ 
        suggestionRequest: { orderId: orderId } 
    });

    if (!suggestion || !suggestion.shipments || suggestion.shipments.length === 0) {
        console.error("Routing failed or produced no shipments. Halting fulfillment.");
        return;
    }

    console.log("Suggestion received. Creating shipments...");

    // Step 2: Loop through the suggested shipments and create each one.
    for (const suggestedShipment of suggestion.shipments) {
        try {
            const shipmentPayload: Shipment = {
                orderId: orderId,
                locationCode: suggestedShipment.locationCode,
                items: suggestedShip-ment.items,
                // You would set other properties like shippingMethodCode here
            };
            const newShipment = await shipmentApi.createShipment({ shipment: shipmentPayload });
            console.log(`Created Shipment ${newShipment.shipmentNumber} for Location ${newShipment.locationCode}`);
        } catch(error: any) {
            console.error(`Failed to create shipment for location ${suggestedShipment.locationCode}:`, error);
        }
    }
}

// Usage
// routeAndFulfillOrder("065c71b12476b7000184b123");

// Actual error structure from Kibo API documentation
interface KiboApiError {
  body: {
    message: string;
    errorCode: string;           // e.g., "ITEM_NOT_FOUND"
    correlationId: string;
  }
}