// Complete flow: item → offer → publish
async function listSingleItem() {
  const sku = 'WIDGET-001';

  // 1. Create inventory item
  await mcp.useTool('inventory_createOrReplaceInventoryItem', {
    sku,
    product: {
      title: 'Premium Blue Widget - Model X',
      description: 'High-quality widget perfect for home and office use',
      aspects: {
        Brand: ['WidgetCo'],
        Color: ['Blue'],
        Model: ['X'],
        Condition: ['New']
      },
      imageUrls: [
        'https://example.com/widget-front.jpg',
        'https://example.com/widget-side.jpg'
      ]
    },
    condition: 'NEW',
    availability: {
      shipToLocationAvailability: {
        quantity: 50
      }
    }
  });

  // 2. Create offer
  const offer = await mcp.useTool('inventory_createOffer', {
    sku,
    marketplace_id: 'EBAY_US',
    format: 'FIXED_PRICE',
    listing_duration: 'GTC', // Good 'Til Cancelled
    available_quantity: 50,
    category_id: '1234', // eBay category ID
    listing_policies: {
      payment_policy_id: 'payment_policy_id',
      return_policy_id: 'return_policy_id',
      fulfillment_policy_id: 'fulfillment_policy_id'
    },
    pricingSummary: {
      price: {
        value: '29.99',
        currency: 'USD'
      }
    }
  });

  // 3. Publish offer
  const listing = await mcp.useTool('inventory_publishOffer', {
    offer_id: offer.offerId
  });

  console.log(`✅ Listed successfully! Listing ID: ${listing.listingId}`);
  return listing;
}

await listSingleItem();

// Upload 100+ items efficiently
async function bulkUploadInventory(products) {
  const requests = products.map(product => ({
    sku: product.sku,
    product: {
      title: product.title,
      description: product.description,
      aspects: product.aspects,
      imageUrls: product.images
    },
    condition: product.condition || 'NEW',
    availability: {
      shipToLocationAvailability: {
        quantity: product.quantity
      }
    }
  }));

  // Upload in batches of 25 (API limit)
  const batchSize = 25;
  const results = [];

  for (let i = 0; i < requests.length; i += batchSize) {
    const batch = requests.slice(i, i + batchSize);

    const response = await mcp.useTool('inventory_bulkCreateOrReplaceInventoryItem', {
      requests: batch
    });

    results.push(...response.responses);
    console.log(`Uploaded batch ${i / batchSize + 1} of ${Math.ceil(requests.length / batchSize)}`);
  }

  const successful = results.filter(r => r.statusCode === 200).length;
  console.log(`✅ Successfully uploaded ${successful}/${products.length} items`);

  return results;
}

// Create a variation listing (e.g., T-shirt in multiple sizes/colors)
async function createVariationListing() {
  const baseTitle = 'Premium Cotton T-Shirt';

  // 1. Create inventory items for each variation
  const sizes = ['S', 'M', 'L', 'XL'];
  const colors = ['Red', 'Blue', 'Green'];
  const variations = [];

  for (const size of sizes) {
    for (const color of colors) {
      const sku = `TSHIRT-${color.toUpperCase()}-${size}`;

      await mcp.useTool('inventory_createOrReplaceInventoryItem', {
        sku,
        product: {
          title: `${baseTitle} - ${color} ${size}`,
          aspects: {
            Size: [size],
            Color: [color],
            Brand: ['YourBrand']
          },
          imageUrls: [`https://example.com/tshirt-${color.toLowerCase()}.jpg`]
        },
        condition: 'NEW',
        availability: {
          shipToLocationAvailability: {
            quantity: 25
          }
        }
      });

      variations.push({ sku, size, color });
    }
  }

  // 2. Create inventory item group
  const group = await mcp.useTool('inventory_createOrReplaceInventoryItemGroup', {
    inventory_item_group_key: 'TSHIRT-GROUP',
    title: baseTitle,
    description: 'Premium quality cotton t-shirt available in multiple sizes and colors',
    imageUrls: [
      'https://example.com/tshirt-main.jpg',
      'https://example.com/tshirt-detail.jpg'
    ],
    variesBy: {
      specifications: [
        { name: 'Size', values: sizes },
        { name: 'Color', values: colors }
      ]
    },
    variantSKUs: variations.map(v => v.sku)
  });

  // 3. Create offer for the group
  const offer = await mcp.useTool('inventory_createOffer', {
    sku: variations[0].sku, // Use first variation SKU
    marketplace_id: 'EBAY_US',
    format: 'FIXED_PRICE',
    category_id: '15687', // T-shirts category
    listing_policies: {
      payment_policy_id: 'payment_policy_id',
      return_policy_id: 'return_policy_id',
      fulfillment_policy_id: 'fulfillment_policy_id'
    },
    pricingSummary: {
      price: { value: '19.99', currency: 'USD' }
    }
  });

  // 4. Publish variation listing
  const listing = await mcp.useTool('inventory_publishOfferByInventoryItemGroup', {
    inventory_item_group_key: 'TSHIRT-GROUP',
    marketplace_id: 'EBAY_US'
  });

  console.log(`✅ Variation listing published! ${variations.length} variations`);
  return listing;
}

async function syncInventoryDaily() {
  // 1. Get all eBay inventory
  const ebayInventory = await mcp.useTool('inventory_getInventoryItems', {
    limit: 100
  });

  // 2. Get warehouse inventory
  const warehouseInventory = await getWarehouseInventory();

  // 3. Find discrepancies
  const updates = [];

  for (const ebayItem of ebayInventory.inventoryItems) {
    const warehouseItem = warehouseInventory.find(w => w.sku === ebayItem.sku);

    if (warehouseItem && warehouseItem.quantity !== ebayItem.availability.shipToLocationAvailability.quantity) {
      updates.push({
        sku: ebayItem.sku,
        shipToLocationAvailability: {
          quantity: warehouseItem.quantity
        }
      });
    }
  }

  // 4. Bulk update quantities
  if (updates.length > 0) {
    await mcp.useTool('inventory_bulkUpdatePriceQuantity', {
      requests: updates
    });

    console.log(`✅ Updated ${updates.length} inventory quantities`);
  } else {
    console.log('✅ Inventory is in sync');
  }
}

async function seasonalPriceAdjustment(discountPercentage) {
  // Get all active offers
  const offers = await mcp.useTool('inventory_getOffers', {
    limit: 100,
    marketplace_id: 'EBAY_US'
  });

  const updates = [];

  for (const offer of offers.offers) {
    const currentPrice = parseFloat(offer.pricingSummary.price.value);
    const newPrice = (currentPrice * (1 - discountPercentage / 100)).toFixed(2);

    updates.push({
      offerId: offer.offerId,
      pricingSummary: {
        price: {
          value: newPrice,
          currency: 'USD'
        },
        // Set original price for strike-through display
        originalRetailPrice: {
          value: currentPrice.toFixed(2),
          currency: 'USD'
        }
      }
    });
  }

  // Update prices in batches
  for (const update of updates) {
    await mcp.useTool('inventory_updateOffer', update);
  }

  console.log(`✅ Applied ${discountPercentage}% discount to ${updates.length} listings`);
}

// Apply 20% off for holiday sale
await seasonalPriceAdjustment(20);