@ticketboothapp/booking 1.2.122 → 1.2.124

package/src/components/booking/standard-booking-checkout-controller.ts

@@ -0,0 +1,659 @@
+import { useCallback, useEffect, useRef, useState, type Dispatch, type SetStateAction } from 'react';
+import {
+  cancelReservation,
+  cancelReservationBestEffort,
+  confirmFreeBooking,
+  createPaymentIntent,
+  confirmPartnerBookingWithoutPayment,
+  describeStandardTourCapacityConflictMessage,
+  isInsufficientCapacityReserveError,
+  reportReserveCapacityConflictClientContext,
+  type AddOn,
+  type Availability,
+  type ItineraryDisplayStep,
+  type PricingConfig,
+  type Product,
+  type ReturnOption,
+} from '../../lib/booking-api';
+import type { OrderSummary, OrderSummaryTicketLine } from '../../lib/booking/pricing';
+import type { BookingSourceMetadata } from '../../lib/booking/source-metadata';
+import { formatBookingRefForDisplay } from '../../lib/booking-ref';
+import { optionalCheckoutContactFields } from '../../lib/booking/checkout-contact';
+import type { Currency } from './CurrencySwitcher';
+import {
+  findMergedAvailabilityForSelection,
+  findMergedReturnVacancies,
+} from './standard-booking-availability';
+import { buildStandardBookingCheckoutArtifacts, type BuildStandardBookingCheckoutArtifactsParams } from './standard-booking-checkout-builders';
+import type { NewBookingFlowProps } from './booking-flow-types';
+import type { PriceSummaryLine } from './PriceSummary';
+import {
+  reserveStandardBookingForCheckout,
+  type ReserveStandardBookingForCheckoutParams,
+  type StandardAddOnSelection,
+} from './standard-booking-reservation-runner';
+import {
+  buildStandardAdminChoiceData,
+  buildStandardPaidCheckoutModalData,
+  buildStandardPayNowCheckoutModalData,
+  confirmStandardAdminBookingWithoutPayment,
+  type StandardAdminChoiceData,
+  type StandardCheckoutModalData,
+} from './standard-booking-payment-choice-runner';
+import { BOOKING_FLOW_ABANDON_EVENT } from '../../providers/booking-dialog-provider';
+
+export interface UseStandardBookingCheckoutControllerParams {
+  selectedAvailability: Availability | null;
+  setSelectedAvailability: Dispatch<SetStateAction<Availability | null>>;
+  selectedReturnOption: ReturnOption | null;
+  setSelectedReturnOption: Dispatch<SetStateAction<ReturnOption | null>>;
+  isPublicSelectableAvailability: (availability: Availability, now?: Date) => boolean;
+  totalQuantity: number;
+  t: (key: string) => string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  phoneNumber: string;
+  product: Product;
+  pickupLocationId: string | null;
+  pickupLocationSkipped: boolean;
+  hidePickupSkipOption: boolean;
+  validateBeforeCheckout?: NewBookingFlowProps['validateBeforeCheckout'];
+  selectedDate: string;
+  computeItineraryDisplay: () => ItineraryDisplayStep[] | null;
+  computeItineraryDisplayForStorage: () => ItineraryDisplayStep[] | null;
+  quantities: Record<string, number>;
+  bookingSourceAttribution: Partial<BookingSourceMetadata>;
+  partnerPortalBooking: boolean;
+  forceDashboardSource: boolean;
+  isAdmin: boolean;
+  pricingConfig: PricingConfig | null;
+  refreshSelectedDateDetailsForCheckout: ReserveStandardBookingForCheckoutParams['refreshSelectedDateDetailsForCheckout'];
+  displayTotalPrice: number;
+  displaySubtotal: number;
+  totalPrice: number;
+  currency: Currency;
+  appliedPromoCode: string | null;
+  cancellationPolicyId: string | null;
+  addOnSelections: StandardAddOnSelection[];
+  dependentAddOnSelection?: NewBookingFlowProps['dependentAddOnSelection'];
+  ticketLineItems: OrderSummaryTicketLine[];
+  pricing: BuildStandardBookingCheckoutArtifactsParams['pricing'];
+  getPriceBreakdown: BuildStandardBookingCheckoutArtifactsParams['getPriceBreakdown'];
+  checkoutReturnLineAmount: number;
+  cancellationPolicyFee: number;
+  effectiveCancellationPolicyLabel: string;
+  addOns: AddOn[];
+  feeLineItems: OrderSummary['feeLineItems'];
+  feeLineItemsWithAddOns: OrderSummary['feeLineItems'];
+  priceSummaryAugmentation?: {
+    lines?: PriceSummaryLine[];
+    subtotalAdjustment?: number;
+    totalAdjustment?: number;
+  } | null;
+  checkoutPriceSummaryLines: PriceSummaryLine[];
+  isTaxIncludedInPrice: boolean;
+  tax: number;
+  effectiveTax: number;
+  effectivePromoDiscountAmount: number;
+  isGiftCard: boolean;
+  partnerDeferredInvoice: boolean;
+  termsAcceptedAt: string | null;
+  skipConfirmationCommunications: boolean;
+  disableAutoCommunications: boolean;
+  reloadAvailabilitiesAfterReserveConflict: () => Promise<Availability[]>;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string) => void;
+  onSuccess?: NewBookingFlowProps['onSuccess'];
+  onShowManage?: (params: { ref: string; lastName: string }) => void;
+}
+
+export function useStandardBookingCheckoutController({
+  selectedAvailability,
+  setSelectedAvailability,
+  selectedReturnOption,
+  setSelectedReturnOption,
+  isPublicSelectableAvailability,
+  totalQuantity,
+  t,
+  email,
+  firstName,
+  lastName,
+  phoneNumber,
+  product,
+  pickupLocationId,
+  pickupLocationSkipped,
+  hidePickupSkipOption,
+  validateBeforeCheckout,
+  selectedDate,
+  computeItineraryDisplay,
+  computeItineraryDisplayForStorage,
+  quantities,
+  bookingSourceAttribution,
+  partnerPortalBooking,
+  forceDashboardSource,
+  isAdmin,
+  pricingConfig,
+  refreshSelectedDateDetailsForCheckout,
+  displayTotalPrice,
+  displaySubtotal,
+  totalPrice,
+  currency,
+  appliedPromoCode,
+  cancellationPolicyId,
+  addOnSelections,
+  dependentAddOnSelection,
+  ticketLineItems,
+  pricing,
+  getPriceBreakdown,
+  checkoutReturnLineAmount,
+  cancellationPolicyFee,
+  effectiveCancellationPolicyLabel,
+  addOns,
+  feeLineItems,
+  feeLineItemsWithAddOns,
+  priceSummaryAugmentation,
+  checkoutPriceSummaryLines,
+  isTaxIncludedInPrice,
+  tax,
+  effectiveTax,
+  effectivePromoDiscountAmount,
+  isGiftCard,
+  partnerDeferredInvoice,
+  termsAcceptedAt,
+  skipConfirmationCommunications,
+  disableAutoCommunications,
+  reloadAvailabilitiesAfterReserveConflict,
+  setLoading,
+  setError,
+  onSuccess,
+  onShowManage,
+}: UseStandardBookingCheckoutControllerParams) {
+  const [showCheckoutModal, setShowCheckoutModal] = useState(false);
+  const [checkoutClientSecret, setCheckoutClientSecret] = useState('');
+  const [checkoutModalData, setCheckoutModalData] = useState<StandardCheckoutModalData | null>(null);
+  const [showAdminPaymentChoice, setShowAdminPaymentChoice] = useState(false);
+  const [adminChoiceData, setAdminChoiceData] = useState<StandardAdminChoiceData | null>(null);
+  const pendingReservationRef = useRef<{ reservationReference: string } | null>(null);
+  const paymentSubmitInFlightRef = useRef(false);
+
+  const cancelPendingReservation = useCallback(() => {
+    if (paymentSubmitInFlightRef.current) return;
+    const pending = pendingReservationRef.current;
+    if (pending) {
+      pendingReservationRef.current = null;
+      cancelReservation(pending.reservationReference).catch(() => {});
+    }
+    setShowCheckoutModal(false);
+    setCheckoutModalData(null);
+    setCheckoutClientSecret('');
+  }, []);
+
+  const cancelPendingReservationBestEffort = useCallback(() => {
+    if (paymentSubmitInFlightRef.current) return;
+    const pending = pendingReservationRef.current;
+    if (pending) {
+      pendingReservationRef.current = null;
+      cancelReservationBestEffort(pending.reservationReference);
+    }
+    setShowCheckoutModal(false);
+    setCheckoutModalData(null);
+    setCheckoutClientSecret('');
+  }, []);
+
+  useEffect(() => {
+    const handleAbandon = () => {
+      cancelPendingReservation();
+    };
+    window.addEventListener(BOOKING_FLOW_ABANDON_EVENT, handleAbandon);
+    return () => window.removeEventListener(BOOKING_FLOW_ABANDON_EVENT, handleAbandon);
+  }, [cancelPendingReservation]);
+
+  useEffect(() => {
+    const handlePageHide = () => {
+      cancelPendingReservationBestEffort();
+    };
+    window.addEventListener('pagehide', handlePageHide);
+    return () => window.removeEventListener('pagehide', handlePageHide);
+  }, [cancelPendingReservationBestEffort]);
+
+  const handleCheckout = async () => {
+    const availabilityForCheckout = selectedAvailability;
+    if (!availabilityForCheckout || totalQuantity === 0) {
+      setError(t('booking.selectTimeAndTickets'));
+      return;
+    }
+    if (!isPublicSelectableAvailability(availabilityForCheckout, new Date())) {
+      setSelectedAvailability(null);
+      setSelectedReturnOption(null);
+      setError('This departure is no longer available online because it starts too soon. Please choose a later time.');
+      return;
+    }
+    if (!email) {
+      setError(t('booking.enterEmail') || 'Please enter your email address');
+      return;
+    }
+    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+      setError(t('booking.invalidEmail') || 'Please enter a valid email address');
+      return;
+    }
+    if (!firstName?.trim()) {
+      setError(t('booking.enterFirstName') || 'Please enter your first name');
+      return;
+    }
+    if (!lastName?.trim()) {
+      setError(t('booking.enterLastName') || 'Please enter your last name');
+      return;
+    }
+    if (
+      product.pickupLocations &&
+      product.pickupLocations.length > 0 &&
+      !pickupLocationId &&
+      (!pickupLocationSkipped || hidePickupSkipOption)
+    ) {
+      setError(t('booking.selectPickupLocation'));
+      return;
+    }
+    const externalValidationError = validateBeforeCheckout?.({
+      selectedDate: selectedDate || null,
+      selectedAvailability: availabilityForCheckout,
+      itineraryItems: computeItineraryDisplay(),
+    });
+    if (externalValidationError) {
+      setError(externalValidationError);
+      return;
+    }
+
+    setLoading(true);
+    setError('');
+    paymentSubmitInFlightRef.current = false;
+
+    try {
+      const reserveResult = await reserveStandardBookingForCheckout({
+        quantities,
+        selectedAvailability: availabilityForCheckout,
+        selectedReturnOption,
+        product,
+        pickupLocationId,
+        bookingSourceAttribution,
+        partnerPortalBooking,
+        forceDashboardSource,
+        isAdmin,
+        totalQuantity,
+        pricingConfig,
+        refreshSelectedDateDetailsForCheckout,
+        displayTotalPrice,
+        totalPrice,
+        currency,
+        appliedPromoCode,
+        cancellationPolicyId,
+        addOnSelections,
+        itineraryDisplay: computeItineraryDisplayForStorage() ?? computeItineraryDisplay(),
+      });
+      if (reserveResult.kind === 'blocked') {
+        setError(reserveResult.message);
+        setLoading(false);
+        return;
+      }
+      const {
+        availabilityProductOptionId,
+        bookingSourceContext,
+        selectedPickupLocation,
+        pricingV2Quote,
+        reservation,
+        datePart,
+        timePart,
+        itineraryDisplay,
+      } = reserveResult;
+      pendingReservationRef.current = { reservationReference: reservation.reservationReference };
+
+      const taxForBreakdown = effectivePromoDiscountAmount > 0 ? effectiveTax : tax;
+      const {
+        checkoutBreakdown,
+        pricingV2SummaryOverride,
+        amountDueForCheckout,
+        ticketLinesForModal,
+        feeLineItemsForModal,
+      } = buildStandardBookingCheckoutArtifacts({
+        ticketLineItems,
+        pricing,
+        getPriceBreakdown,
+        totalQuantity,
+        checkoutReturnLineAmount,
+        returnOptionLabel: t('booking.returnOption') || 'Return option',
+        personLabel: t('booking.person') || 'person',
+        peopleLabel: t('booking.people') || 'people',
+        cancellationPolicyFee,
+        cancellationPolicyLabel: effectiveCancellationPolicyLabel,
+        addOnSelections,
+        addOns,
+        feeLineItems,
+        feeLineItemsWithAddOns,
+        priceSummaryLines: priceSummaryAugmentation?.lines,
+        checkoutPriceSummaryLineCount: checkoutPriceSummaryLines.length,
+        isTaxIncludedInPrice,
+        taxForBreakdown,
+        taxLabel: t('booking.tax') !== 'booking.tax' ? t('booking.tax') : 'Taxes and fees',
+        effectivePromoDiscountAmount,
+        appliedPromoCode,
+        discountLabel: t('booking.discount') || 'Discount',
+        promoLineType: isGiftCard ? 'GIFT_CARD' : 'PROMO_CODE',
+        displayTotalPrice,
+        currency,
+        pricingV2Quote: pricingV2Quote?.quote,
+        roundingLabel: t('booking.rounding') || 'Rounding',
+      });
+
+      if (partnerDeferredInvoice) {
+        if (!reservation?.reservationReference) {
+          throw new Error('Missing reservation reference for partner booking confirmation');
+        }
+        const confirmedBooking = await confirmPartnerBookingWithoutPayment({
+          reservationReference: reservation.reservationReference,
+          productId: product.productId,
+          optionId: availabilityProductOptionId,
+          date: datePart,
+          time: timePart,
+          customerEmail: email || undefined,
+          customerFirstName: firstName.trim() || undefined,
+          customerLastName: lastName.trim() || undefined,
+          ...optionalCheckoutContactFields(phoneNumber),
+          currency,
+          travelerHotel: selectedPickupLocation?.name || undefined,
+          pickupLocationId: pickupLocationId || undefined,
+          itineraryDisplay: itineraryDisplay ?? undefined,
+          termsAcceptedAt: termsAcceptedAt ?? undefined,
+          skipConfirmationCommunications: isAdmin && skipConfirmationCommunications ? true : undefined,
+          disableAutoCommunications: isAdmin && disableAutoCommunications ? true : undefined,
+          checkoutBreakdown,
+          dependentAddOnSelection: dependentAddOnSelection || undefined,
+          depositAmount: 0,
+          balanceAmount: amountDueForCheckout,
+          totalAmount: amountDueForCheckout,
+          pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+          pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+          ...bookingSourceContext,
+        });
+        pendingReservationRef.current = null;
+        const ref = formatBookingRefForDisplay(confirmedBooking.bookingReference);
+        const ln = lastName.trim();
+        onSuccess?.({
+          reservationReference: reservation.reservationReference,
+          bookingReference: confirmedBooking.bookingReference,
+        });
+        if (onShowManage) {
+          onShowManage({ ref, lastName: ln });
+        } else {
+          const params = new URLSearchParams({ ref, lastName: ln, booking_complete: '1' });
+          window.location.href = `/manage-booking?${params.toString()}`;
+        }
+        setLoading(false);
+        return;
+      }
+
+      const paymentIntent = await createPaymentIntent({
+        productId: product.productId,
+        optionId: availabilityProductOptionId,
+        date: datePart,
+        time: timePart,
+        quantity: totalQuantity,
+        customerEmail: email,
+        customerFirstName: firstName.trim() || undefined,
+        customerLastName: lastName.trim() || undefined,
+        ...optionalCheckoutContactFields(phoneNumber),
+        currency,
+        reservationReference: reservation?.reservationReference,
+        travelerHotel: selectedPickupLocation?.name || undefined,
+        pickupLocationId: pickupLocationId || undefined,
+        itineraryDisplay: itineraryDisplay ?? undefined,
+        returnAvailabilityId: selectedReturnOption?.returnAvailabilityId,
+        promoCode: appliedPromoCode || undefined,
+        cancellationPolicyId: cancellationPolicyId || undefined,
+        termsAcceptedAt: termsAcceptedAt ?? undefined,
+        checkoutBreakdown,
+        dependentAddOnSelection: dependentAddOnSelection || undefined,
+        pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+        pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+        idempotencyKey: pricingV2Quote?.quote?.quoteId && reservation?.reservationReference
+          ? `checkout-payment-intent:${reservation.reservationReference}:${pricingV2Quote.quote.quoteId}`
+          : undefined,
+        skipConfirmationCommunications: isAdmin && skipConfirmationCommunications ? true : undefined,
+        disableAutoCommunications: isAdmin && disableAutoCommunications ? true : undefined,
+        ...bookingSourceContext,
+      });
+
+      if ('freeBooking' in paymentIntent && paymentIntent.freeBooking) {
+        if (!reservation?.reservationReference) {
+          throw new Error('Missing reservation reference for free booking confirmation');
+        }
+        const freeBookingResult = await confirmFreeBooking({
+          reservationReference: reservation?.reservationReference ?? '',
+          productId: product.productId,
+          optionId: availabilityProductOptionId,
+          date: datePart,
+          time: timePart,
+          customerEmail: email || undefined,
+          customerFirstName: firstName.trim() || undefined,
+          customerLastName: lastName.trim() || undefined,
+          ...optionalCheckoutContactFields(phoneNumber),
+          currency,
+          travelerHotel: selectedPickupLocation?.name || undefined,
+          pickupLocationId: pickupLocationId || undefined,
+          itineraryDisplay: itineraryDisplay ?? undefined,
+          termsAcceptedAt: termsAcceptedAt ?? undefined,
+          skipConfirmationCommunications: isAdmin && skipConfirmationCommunications ? true : undefined,
+          disableAutoCommunications: isAdmin && disableAutoCommunications ? true : undefined,
+          dependentAddOnSelection: dependentAddOnSelection || undefined,
+          pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+          pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+          ...bookingSourceContext,
+        });
+        pendingReservationRef.current = null;
+        const ref = formatBookingRefForDisplay(freeBookingResult.bookingReference);
+        const ln = lastName.trim();
+        onSuccess?.({ reservationReference: reservation?.reservationReference ?? '' });
+        if (onShowManage) {
+          onShowManage({ ref, lastName: ln });
+        } else {
+          const params = new URLSearchParams({ ref, lastName: ln, booking_complete: '1' });
+          window.location.href = `/manage-booking?${params.toString()}`;
+        }
+        setLoading(false);
+        return;
+      }
+
+      if (isAdmin) {
+        if (!reservation?.reservationReference) {
+          throw new Error('Missing reservation reference for admin payment flow');
+        }
+        setError('');
+        setAdminChoiceData(buildStandardAdminChoiceData({
+          reservation,
+          checkoutBreakdown,
+          totalAmount: amountDueForCheckout,
+          datePart,
+          timePart,
+          availabilityProductOptionId,
+          itineraryDisplay: itineraryDisplay ?? undefined,
+          clientSecret: paymentIntent.clientSecret ?? '',
+          ticketLinesForModal,
+          feeLineItems: feeLineItemsForModal,
+          returnPriceAdjustment: checkoutReturnLineAmount,
+          cancellationPolicyFee,
+          cancellationPolicyLabel: effectiveCancellationPolicyLabel,
+          subtotal: displaySubtotal,
+          tax: effectivePromoDiscountAmount > 0 ? effectiveTax : tax,
+          totalQuantity,
+          isTaxIncludedInPrice,
+          taxRate: pricingConfig?.taxRate ?? 0,
+          promoDiscountAmount: effectivePromoDiscountAmount > 0 ? effectivePromoDiscountAmount : 0,
+          discountLabel: appliedPromoCode ? `Promo: ${appliedPromoCode}` : undefined,
+          summaryOverride: pricingV2SummaryOverride,
+          pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+          pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+        }));
+        setShowAdminPaymentChoice(true);
+        setLoading(false);
+        return;
+      }
+
+      setCheckoutClientSecret(paymentIntent.clientSecret ?? '');
+      setCheckoutModalData(buildStandardPaidCheckoutModalData({
+        reservation,
+        customerLastName: lastName.trim(),
+        bookingDate: datePart,
+        ticketLines: ticketLinesForModal,
+        feeLineItems: feeLineItemsForModal,
+        returnPriceAdjustment: checkoutReturnLineAmount,
+        cancellationPolicyFee,
+        cancellationPolicyLabel: effectiveCancellationPolicyLabel,
+        subtotal: displaySubtotal,
+        tax: effectivePromoDiscountAmount > 0 ? effectiveTax : tax,
+        total: amountDueForCheckout,
+        totalQuantity,
+        isTaxIncludedInPrice,
+        taxRate: pricingConfig?.taxRate ?? 0,
+        promoDiscountAmount: effectivePromoDiscountAmount > 0 ? effectivePromoDiscountAmount : 0,
+        discountLabel: appliedPromoCode ? `Promo: ${appliedPromoCode}` : undefined,
+        summaryOverride: pricingV2SummaryOverride,
+      }));
+      setShowCheckoutModal(true);
+      setLoading(false);
+    } catch (err) {
+      if (isInsufficientCapacityReserveError(err)) {
+        try {
+          const merged = await reloadAvailabilitiesAfterReserveConflict();
+          const outbound = findMergedAvailabilityForSelection(merged, availabilityForCheckout);
+          const outboundVacancies = outbound?.vacancies ?? null;
+          const returnVacancies = findMergedReturnVacancies(outbound, selectedReturnOption);
+          setError(
+            describeStandardTourCapacityConflictMessage({
+              partySize: totalQuantity,
+              outboundVacancies,
+              returnVacancies,
+              hasReturnSelection: !!selectedReturnOption,
+            })
+          );
+          reportReserveCapacityConflictClientContext({
+            flow: 'standard_tour',
+            productId: product.productId,
+            selectedDate: selectedDate || null,
+            outboundDateTime: availabilityForCheckout.dateTime,
+            outboundVacanciesAfterRefresh: outboundVacancies,
+            returnVacanciesAfterRefresh: returnVacancies,
+            partySizeOrPassengers: totalQuantity,
+            hasReturnSelection: !!selectedReturnOption,
+            returnAvailabilityId: selectedReturnOption?.returnAvailabilityId ?? null,
+            reloadAvailabilitiesSucceeded: true,
+          });
+        } catch (reloadErr) {
+          setError(
+            describeStandardTourCapacityConflictMessage({
+              partySize: totalQuantity,
+              outboundVacancies: null,
+              returnVacancies: null,
+              hasReturnSelection: !!selectedReturnOption,
+            })
+          );
+          reportReserveCapacityConflictClientContext({
+            flow: 'standard_tour',
+            productId: product.productId,
+            selectedDate: selectedDate || null,
+            outboundDateTime: availabilityForCheckout.dateTime,
+            outboundVacanciesAfterRefresh: null,
+            returnVacanciesAfterRefresh: null,
+            partySizeOrPassengers: totalQuantity,
+            hasReturnSelection: !!selectedReturnOption,
+            returnAvailabilityId: selectedReturnOption?.returnAvailabilityId ?? null,
+            reloadAvailabilitiesSucceeded: false,
+            reloadErrorMessage:
+              reloadErr instanceof Error ? reloadErr.message : String(reloadErr),
+          });
+        }
+        setLoading(false);
+        return;
+      }
+      setError(err instanceof Error ? err.message : 'Something went wrong');
+      setLoading(false);
+    }
+  };
+
+  const handleConfirmWithoutPayment = async () => {
+    const choice = adminChoiceData;
+    if (!choice) return;
+    setLoading(true);
+    setError('');
+    try {
+      const result = await confirmStandardAdminBookingWithoutPayment({
+        adminChoiceData: choice,
+        bookingSourceAttribution,
+        partnerPortalBooking,
+        forceDashboardSource,
+        productId: product.productId,
+        email,
+        firstName,
+        lastName,
+        phoneNumber,
+        currency,
+        travelerHotel: product.pickupLocations?.find((loc) => loc.id === pickupLocationId)?.name || undefined,
+        pickupLocationId: pickupLocationId || undefined,
+        termsAcceptedAt,
+        skipConfirmationCommunications,
+        disableAutoCommunications,
+      });
+      pendingReservationRef.current = null;
+      setShowAdminPaymentChoice(false);
+      setAdminChoiceData(null);
+      onSuccess?.({ reservationReference: choice.reservationReference });
+      if (onShowManage) {
+        onShowManage({ ref: result.displayReference, lastName: result.lastName });
+      } else {
+        const params = new URLSearchParams({
+          ref: result.displayReference,
+          lastName: result.lastName,
+          booking_complete: '1',
+        });
+        window.location.href = `/manage-booking?${params.toString()}`;
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to confirm booking');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handlePayNow = () => {
+    const choice = adminChoiceData;
+    if (!choice) return;
+    setShowAdminPaymentChoice(false);
+    setCheckoutClientSecret(choice.clientSecret);
+    setCheckoutModalData(buildStandardPayNowCheckoutModalData(choice, lastName.trim()));
+    setShowCheckoutModal(true);
+    setAdminChoiceData(null);
+  };
+
+  const handleAdminPaymentChoiceCancel = () => {
+    setShowAdminPaymentChoice(false);
+    setAdminChoiceData(null);
+    setError('');
+  };
+
+  return {
+    showCheckoutModal,
+    checkoutClientSecret,
+    checkoutModalData,
+    showAdminPaymentChoice,
+    adminChoiceData,
+    cancelPendingReservation,
+    handleCheckout,
+    handleConfirmWithoutPayment,
+    handlePayNow,
+    handlePaymentSubmitStart: () => {
+      paymentSubmitInFlightRef.current = true;
+    },
+    handlePaymentSubmitError: () => {
+      paymentSubmitInFlightRef.current = false;
+    },
+    handleAdminPaymentChoiceCancel,
+  };
+}