Recetas de Integración

// Paso 1: Buscar productos
const products = await searchProducts({
  query: userQuery,
  limit: 5
});

// Paso 2: Crear carrito
const cart = await createCart({
  merchantId: "demo-store"
});

// Paso 3: Agregar productos (obtén el ID del producto seleccionado)
// (Usar select_shipping_option después de obtener dirección)

// Paso 4: Obtener opciones de envío
const shippingRates = await getShippingRates({
  cartId: cart.cartId,
  address: {
    street: userAddress.street,
    city: userAddress.city,
    country: userAddress.country,
    postalCode: userAddress.postal
  }
});

// Paso 5: Seleccionar opción de envío
await selectShippingOption({
  cartId: cart.cartId,
  shippingId: shippingRates[0].id,
  address: { ... }
});

// Paso 6: Completar checkout
const order = await completeCheckout({
  cartId: cart.cartId,
  buyerInfo: {
    name: userName,
    email: userEmail,
    phone: userPhone
  }
});

// Flujo: búsqueda → descuento → checkout

async function purchaseWithDiscount(productQuery, discountCode) {
  // 1. Buscar producto
  const products = await searchProducts({
    query: productQuery,
    limit: 3
  });

  // 2. Crear carrito
  const cart = await createCart({ merchantId: "demo-store" });

  // 3. Aplicar descuento (códigos válidos: TEST*, WELCOME*)
  try {
    const discount = await applyDiscount({
      cartId: cart.cartId,
      code: discountCode
    });
    console.log(`Descuento aplicado: -${discount.discountAmount}`);
  } catch (e) {
    console.log("Código inválido, continuando sin descuento");
  }

  // 4. Obtener tasas de envío
  const rates = await getShippingRates({
    cartId: cart.cartId,
    address: userAddress
  });

  // 5. Seleccionar envío
  await selectShippingOption({
    cartId: cart.cartId,
    shippingId: rates[0].id,
    address: userAddress
  });

  // 6. Previsualizacar antes de confirmar
  const preview = await previewCheckout({ cartId: cart.cartId });
  console.log(`Total con descuento: $${preview.total}`);

  // 7. Completar
  return await completeCheckout({
    cartId: cart.cartId,
    buyerInfo: userInfo
  });
}

// Búsqueda con múltiples filtros

async function smartSearch(criteria) {
  const results = await searchProducts({
    query: criteria.keywords,
    limit: 10,
    filters: {
      category: criteria.category,        // ej: "electronics"
      priceRange: {
        min: criteria.minPrice ?? 0,
        max: criteria.maxPrice ?? 10000
      },
      rating: criteria.minRating ?? 0,    // 0-5 stars
      inStock: true
    }
  });

  // Ordenar por relevancia/precio
  return results.sort((a, b) => {
    if (criteria.sortBy === "price") {
      return a.price - b.price;
    } else if (criteria.sortBy === "rating") {
      return b.rating - a.rating;
    }
    return 0;
  });
}

// Uso
const laptops = await smartSearch({
  keywords: "gaming laptop",
  category: "electronics",
  minPrice: 1000,
  maxPrice: 3000,
  minRating: 4,
  sortBy: "price"
});

async function validateBeforeCheckout(cartId, address) {
  // Paso 1: Obtener detalles del carrito
  // (Pueden necesitar llamar a get_cart si existe)

  // Paso 2: Verificar tasas de envío disponibles
  const shippingRates = await getShippingRates({
    cartId,
    address
  });

  if (!shippingRates || shippingRates.length === 0) {
    throw new Error("No shipping available for this address");
  }

  // Paso 3: Revisar preview del checkout
  const preview = await previewCheckout({ cartId });

  // Validaciones
  const validations = {
    hasItems: preview.items?.length > 0,
    hasShipping: preview.shippingMethod !== null,
    totalGreaterThanZero: preview.total > 0,
    addressComplete: address.street && address.city &&
                     address.country && address.postalCode,
  };

  // Retornar estado
  const isValid = Object.values(validations).every(v => v);

  return {
    isValid,
    validations,
    preview,
    recommendedShipping: shippingRates[0] // Más rápido/económico
  };
}

// Uso
const validation = await validateBeforeCheckout(cartId, address);
if (validation.isValid) {
  await completeCheckout({ cartId, buyerInfo });
} else {
  console.error("Validation failed:", validation.validations);
}

// Manejo robusto de errores

async function safeCheckout(cartId, buyerInfo, address) {
  const maxRetries = 3;
  let attempts = 0;

  while (attempts < maxRetries) {
    try {
      // Paso 1: Validar estado
      const preview = await previewCheckout({ cartId });
      if (!preview.items?.length) {
        throw new Error("Cart is empty");
      }

      // Paso 2: Obtener envío
      const rates = await getShippingRates({
        cartId,
        address
      });
      if (!rates?.length) {
        throw new Error("No shipping available");
      }

      // Paso 3: Seleccionar envío
      await selectShippingOption({
        cartId,
        shippingId: rates[0].id,
        address
      });

      // Paso 4: Completar (intentar)
      const order = await completeCheckout({
        cartId,
        buyerInfo
      });

      return { success: true, orderId: order.id };

    } catch (error) {
      attempts++;

      if (error.code === "PAYMENT_FAILED" && attempts < maxRetries) {
        // Reintentar pago
        console.log(`Reintentando pago (${attempts}/${maxRetries})`);
        await new Promise(r => setTimeout(r, 1000 * attempts));
        continue;
      }

      if (error.code === "OUT_OF_STOCK") {
        // Notificar al usuario
        return {
          success: false,
          error: "Item out of stock"
        };
      }

      throw error;
    }
  }

  return { success: false, error: "Checkout failed after retries" };
}

// Búsqueda en múltiples tiendas (futura)

async function searchAcrossStores(productQuery) {
  const stores = [
    "demo-store",
    // "store-2",
    // "store-3",
  ];

  const results = await Promise.all(
    stores.map(storeId =>
      searchProducts({
        query: productQuery,
        limit: 5,
        // Nota: storeId será un parámetro futuro
      }).catch(e => {
        console.warn(`Store ${storeId} failed:`, e.message);
        return [];
      })
    )
  );

  // Combinar y ordenar por precio
  return results
    .flat()
    .sort((a, b) => a.price - b.price)
    .slice(0, 10);
}

// Actual: usar demo-store para demostración
const products = await searchProducts({
  query: "laptop",
  limit: 10
});