Cart Operations & Checkout

const result = await api.cart.createOrUpdateCart({
  cart: {
    activity: 'activity-uuid',
    duration: 'duration-uuid',
    date: '2025-07-15',
    timeSlotStart: '10:00',
    timeSlotEnd: '11:00',
    equipment: [
      {
        equipmentUuid: 'equipment-uuid',
        quantity: 1,
        seats: 2,
        addons: [
          {
            addonUuid: 'addon-uuid',
            quantity: 1,
            equipmentUuid: 'equipment-uuid'
          }
        ]
      }
    ]
  }
});

if (result.success) {
  console.log('Cart ID:', result.cartId);
  console.log('Total:', result.cart.total);
  console.log('Stripe account:', result.operatorAccountId);
}

const updated = await api.cart.createOrUpdateCart({
  cartId: 'existing-cart-id',
  cart: {
    activity: 'activity-uuid',
    duration: 'duration-uuid',
    date: '2025-07-15',
    timeSlotStart: '14:00',
    timeSlotEnd: '15:00',
    equipment: [
      { equipmentUuid: 'equipment-uuid', quantity: 1, seats: 4 }
    ]
  }
});

const result = await api.cart.updateCustomer({
  customer: {
    fullName: 'Jane Smith',
    email: 'jane@example.com',
    phone: '5551234567',
    countryCode: '1',
    country: 'US'
  },
  cartId: 'cart-id' // optional if using session-based cart
});

const result = await api.cart.applyCoupon({
  couponCode: 'SUMMER20',
  cartId: 'cart-id'
});

const result = await api.cart.removeCoupon({
  cartId: 'cart-id'
});

const result = await api.cart.applyGiftCard({
  giftCardCode: 'GC-ABC123',
  cartId: 'cart-id'
});

if (result.success) {
  console.log('Balance available:', result.availableBalance);
}

const result = await api.cart.removeGiftCard({
  cartId: 'cart-id'
});

const result = await api.cart.updateVouchers({
  cart: currentCart,          // the same ClientShoppingCart you sync
  cartId: 'cart-id',
  voucherCodes: ['AV0123456789ABCDEF0123456789ABCDEF'],
  retainedVoucherIds: []      // ids from a previous response's cart.vouchers[] to keep
});

if (result.success) {
  result.cart.vouchers.forEach(v =>
    console.log(`${v.name} ····${v.suffix}: ${v.coverage.join(', ')}`)
  );
  console.log('Prepaid:', result.cart.voucherAmountApplied);
  console.log('Still due:', result.cart.dueNow);
} else if (result.errorCode === 29) {
  // VoucherInvalid — unknown, used, expired, wrong activity/duration/equipment,
  // outside its season or blackout window. result.message says which. Nothing
  // was applied or silently dropped.
}

// Add a second voucher, keeping the first
await api.cart.updateVouchers({
  cart, cartId,
  voucherCodes: ['AV...SECOND'],
  retainedVoucherIds: [first.cart.vouchers[0].id]
});

// Remove every voucher
await api.cart.updateVouchers({ cart, cartId, voucherCodes: [] });

const preview = await api.cart.getTripProtectionPreview({
  cartId: 'cart-id'
});

if (preview.success && preview.available) {
  console.log(`${preview.title}: $${preview.price}`);
  console.log(preview.description);
}

const result = await api.checkout.checkout({
  cart: {
    activity: 'activity-uuid',
    duration: 'duration-uuid',
    date: '2025-07-15',
    timeSlotStart: '10:00',
    timeSlotEnd: '11:00',
    equipment: [
      { equipmentUuid: 'equip-uuid', quantity: 1, seats: 2 }
    ],
    customer: {
      fullName: 'Jane Smith',
      email: 'jane@example.com',
      phone: '5551234567'
    },
    tripProtectionSelected: false
  },
  stripeConfirmationToken: 'tok_xxx', // from Stripe.js
  agreements: ['agreement-uuid-1'],
  customFields: [
    { uuid: 'field-uuid', answer: 'Some answer' }
  ],
  demographics: [
    { demographicUuid: 'demo-uuid', uuid: 'value-uuid', value: 2 }
  ],
  smsOptIn: true
});

if (result.success) {
  console.log('Confirmation:', result.confirmation);
} else if (result.clientSecret) {
  // Stripe requires additional action (3D Secure, etc.)
  // Use Stripe.js to handle the next action, then retry
  console.log('Payment requires additional action');
}

const settings = await api.giftCardPurchase.getSettings();

if (settings.success && settings.isAvailable) {
  console.log('Flat amounts:', settings.flatAmounts);
  console.log('Variable:', settings.allowVariableAmounts,
    `$${settings.variableMinAmount}-$${settings.variableMaxAmount}`);
}

const result = await api.giftCardPurchase.purchase({
  amount: 50,
  purchaserName: 'John Doe',
  purchaserEmail: 'john@example.com',
  recipientName: 'Jane Smith',
  recipientEmail: 'jane@example.com',
  customMessage: 'Happy birthday!',
  stripeConfirmationToken: 'tok_xxx'
});

if (result.success) {
  console.log('Gift card code:', result.giftCardCode);
  console.log('Amount:', result.giftCardAmount);
  console.log('Expires:', result.expiresAt);
}

const quote = await api.voucherPurchase.getOffer('black-friday-kayak', 2);

if (quote.success) {
  const { offerId, revisionId, settings, pricing, activity, timeZone } = quote.data;
  console.log(settings.name, settings.description);
  console.log('Covers:', settings.terms.activityName, settings.terms.durationMinutes, 'min');
  console.log('Season:', settings.terms.experienceStartsOn, '→', settings.terms.experienceEndsOn);
  console.log('Total for 2:', pricing.grandTotal, pricing.currency);
}

const identity = api.voucherPurchase.newRequestIdentity();
// { requestId: '<uuid>', accessToken: '<43-char base64url>' }
sessionStorage.setItem('voucher-attempt', JSON.stringify({ identity, offerId, revisionId, quantity, expectedTotal }));

let result = await api.voucherPurchase.purchase({
  ...identity,
  offerId,
  revisionId,
  quantity: 2,
  expectedTotal: pricing.grandTotal,
  purchaserName: 'Alex Morgan',
  purchaserEmail: 'alex@example.com',
  recipientName: 'Jamie Lee',          // optional — makes it a gift
  recipientEmail: 'jamie@example.com',
  acceptTerms: true,
  stripeConfirmationToken: confirmationToken.id
});

const request = { ...identity, offerId, revisionId, quantity: 2, expectedTotal, purchaserName, purchaserEmail, acceptTerms: true };

if (result.success && result.data.action === 'next_action') {
  // 3D Secure: complete it, then continue with the intent id and NO token
  await stripe.handleNextAction({ clientSecret: result.data.clientSecret });
  result = await api.voucherPurchase.purchase({ ...request, handledNextAction: result.data.paymentIntentId });
}

while (result.success && result.data.action === 'processing') {
  await new Promise(r => setTimeout(r, 2000));
  result = await api.voucherPurchase.purchase({ ...request, handledNextAction: result.data.paymentIntentId });
}

if (result.success && result.data.action === 'success') {
  const order = result.data.order;
  if (order.fulfillmentStatus === 1) {
    order.vouchers.forEach(v => console.log('Code:', v.code, 'paid', v.paidAmount));
  } else if (order.fulfillmentStatus === 2) {
    // Paid but held for operator review; codes withheld and nothing is emailed
    // until the operator resolves the order. Show order.orderId as the reference.
  }
  sessionStorage.removeItem('voucher-attempt');
} else if (result.success && result.data.action === 'payment_error') {
  // Card declined. Keep the SAME identity, collect a new token, call purchase again.
  showError(result.data.message);
} else if (!result.success) {
  switch (result.errorCode) {
    case 'QuoteChanged':   // operator edited the offer — drop the attempt and re-quote
    case 'SoldOut':
    case 'OrderExpired':   // 20 minutes passed without payment — start a new identity
      sessionStorage.removeItem('voucher-attempt');
      break;
    case 'PaymentUnavailable':
      // Stripe was unreachable. Retry the same request; do not mint a new identity.
      break;
  }
}

const code = api.voucherRedemption.normalizeCode(input.value);  // 'AV…' or null

const result = await api.voucherRedemption.inspect(code, cartId);

if (result.success) {
  const { suffix, settings, timeZone } = result.data;
  console.log(`${settings.name} (ending ${suffix}) covers ${settings.terms.activityName}`);
  // Send the customer to pick a date for settings.terms.activityUuid
} else {
  console.log(result.message);  // unknown, used, voided, refunded, outside its booking window…
}

const status = await api.voucherRedemption.checkoutStatus(cartId);

switch (status.data?.state) {
  case 'confirmed':  // booking exists — status.data.confirmation is its code
    break;
  case 'resume':     // re-post the IDENTICAL checkout request, adding
                     // handledNextAction: status.data.paymentIntentId when present
    break;
  case 'resolving':  // the server is reconciling — wait 2s and call again
    break;
  case 'resolved':   // closed without a booking — the customer may start a new cart
    break;
  case 'unknown':    // nothing saved for this cart
    break;
}

const closed = await api.voucherRedemption.closeCheckout(cartId);
if (closed.success && closed.data.state === 'resolved') {
  // start a fresh cart
}

const api = new ResytechApi();

// 1. Initialize
const init = await api.initialization.initialize({
  identifier: 'checkout-flow'
});

const activity = init.activities[0];
const equipment = activity.equipment[0];
const duration = activity.durations[0];

// 2. Create cart
const cartResult = await api.cart.createOrUpdateCart({
  cart: {
    activity: activity.uuid,
    duration: duration.uuid,
    date: '2025-07-15',
    timeSlotStart: '10:00',
    timeSlotEnd: '11:00',
    equipment: [
      {
        equipmentUuid: equipment.uuid,
        quantity: 1,
        seats: 2
      }
    ]
  }
});

if (!cartResult.success) {
  console.error('Cart failed:', cartResult.message, 'Code:', cartResult.errorCode);
  return;
}

const cartId = cartResult.cartId;
console.log('Cart created:', cartId);
console.log('Subtotal:', cartResult.cart.subtotal);

// 3. Update customer info
await api.cart.updateCustomer({
  cartId: cartId,
  customer: {
    fullName: 'Jane Smith',
    email: 'jane@example.com',
    phone: '5551234567',
    countryCode: '1'
  }
});

// 4. Apply a coupon
const couponResult = await api.cart.applyCoupon({
  cartId: cartId,
  couponCode: 'SUMMER20'
});

if (couponResult.success) {
  console.log('Coupon applied!');
}

// 5. Check trip protection
const tripPreview = await api.cart.getTripProtectionPreview({
  cartId: cartId
});

// 6. Process checkout
//    In a real app, collect the Stripe token via Stripe.js/Elements
const checkout = await api.checkout.checkout({
  cart: {
    activity: activity.uuid,
    duration: duration.uuid,
    date: '2025-07-15',
    timeSlotStart: '10:00',
    timeSlotEnd: '11:00',
    equipment: [
      { equipmentUuid: equipment.uuid, quantity: 1, seats: 2 }
    ],
    customer: {
      fullName: 'Jane Smith',
      email: 'jane@example.com',
      phone: '5551234567'
    },
    tripProtectionSelected: tripPreview.available
  },
  cartId: cartId,
  stripeConfirmationToken: 'tok_from_stripe_js',
  agreements: ['agreement-uuid-1'],
  smsOptIn: true
});

if (checkout.success) {
  console.log('Booking confirmed!', checkout.confirmation);
  console.log('Total charged:', checkout.cart.total);
} else if (checkout.clientSecret) {
  // Handle Stripe 3D Secure or other next actions
  // After handling, retry with handledNextAction
  console.log('Additional payment verification required');
} else {
  console.error('Checkout failed:', checkout.message);
}