@ticketboothapp/booking 1.2.123 → 1.2.124

package/src/components/booking/private-shuttle-checkout-controller.ts

@@ -0,0 +1,744 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import {
+  cancelReservation,
+  cancelReservationBestEffort,
+  confirmFreeBooking,
+  confirmPartnerBookingWithoutPayment,
+  createPaymentIntent,
+  describePrivateShuttleCapacityConflictMessage,
+  isInsufficientCapacityReserveError,
+  reportReserveCapacityConflictClientContext,
+  type AddOn,
+  type Availability,
+  type PricingConfig,
+} from '../../lib/booking-api';
+import type { OrderSummaryFeeLine } 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 {
+  findMergedPrivateShuttleAvailability,
+  privateShuttleBookingCutoffMessage,
+  privateShuttleStartTimeAllowed,
+} from './private-shuttle-availability';
+import {
+  buildPrivateShuttleCheckoutArtifacts,
+  type BuildPrivateShuttleCheckoutArtifactsParams,
+  type PrivateShuttleDepositInfo,
+} from './private-shuttle-checkout-builders';
+import type {
+  ProviderDashboardChangeBookingPayload,
+  ProviderDashboardInitialBooking,
+} from './provider-dashboard-change-booking';
+import {
+  reservePrivateShuttleForCheckout,
+  type PrivateShuttleAddOnSelection,
+  type PrivateShuttleCheckoutItineraryItem,
+  type ReservePrivateShuttleForCheckoutParams,
+} from './private-shuttle-reservation-runner';
+import { applyPrivateShuttleProviderChange } from './private-shuttle-provider-change-runner';
+import {
+  buildPrivateShuttleAdminChoiceData,
+  buildPrivateShuttlePaidCheckoutModalData,
+  buildPrivateShuttlePayNowCheckoutModalData,
+  confirmPrivateShuttleAdminBookingWithoutPayment,
+  type PrivateShuttleAdminChoiceData,
+  type PrivateShuttleCheckoutModalData,
+} from './private-shuttle-payment-choice-runner';
+import { BOOKING_FLOW_ABANDON_EVENT } from '../../providers/booking-dialog-provider';
+
+export interface UsePrivateShuttleCheckoutControllerParams {
+  selectedOption: string;
+  selectedDate: string;
+  selectedStartTime: string;
+  selectedAvailability: Availability | null;
+  companyTimezone: string;
+  bookingCutoffNow: Date;
+  bookingCutoffMinutes?: number | null;
+  productId: string;
+  currency: Currency;
+  bookingSourceAttribution: Partial<BookingSourceMetadata>;
+  partnerPortalBooking: boolean;
+  forceDashboardSource: boolean;
+  isAdmin: boolean;
+  isProviderChangeMode: boolean;
+  onChangeBooking?: (data: ProviderDashboardChangeBookingPayload) => Promise<void>;
+  initialBooking?: ProviderDashboardInitialBooking;
+  email: string;
+  firstName: string;
+  lastName: string;
+  phoneNumber: string;
+  passengerCount: number;
+  maxVacancies: number;
+  isSpecialRequest: boolean;
+  billableResourceCount: number;
+  resourceCount: number;
+  resourcePrice: number;
+  basePrice: number;
+  pricingConfig: PricingConfig | null;
+  refreshSelectedDateDetailsForCheckout: ReservePrivateShuttleForCheckoutParams['refreshSelectedDateDetailsForCheckout'];
+  reloadAvailabilitiesAfterReserveConflict: () => Promise<Availability[]>;
+  totalPrice: number;
+  subtotal: number;
+  activePromoCode: string | null;
+  cancellationPolicyId: string | null;
+  selectedCancellationPolicyLabel?: string;
+  cancellationPolicyFee: number;
+  addOnSelections: PrivateShuttleAddOnSelection[];
+  addOns: AddOn[];
+  additionalHoursCount: number;
+  additionalHoursAmount: number;
+  perBookingFeeLineItems: OrderSummaryFeeLine[];
+  effectiveTaxAmount: number;
+  taxRate: number;
+  effectivePromoDiscountAmount: number;
+  isGiftCard: boolean;
+  isTaxIncludedInPrice: boolean;
+  depositInfo: PrivateShuttleDepositInfo | null;
+  depositConfig?: BuildPrivateShuttleCheckoutArtifactsParams['depositConfig'];
+  balanceChargeDaysBefore?: number;
+  selectedPickupLocationName?: string | null;
+  customPickupAddress?: string | null;
+  pickupLocationId: string | null;
+  pickupLocationSkipped: boolean;
+  hasPickupLocations: boolean;
+  draftItineraryDestinations: string[];
+  draftItineraryPlanningNotes: string;
+  childSafetySeatsCount: number;
+  foodRestrictions: string;
+  itineraryDisplayItems: PrivateShuttleCheckoutItineraryItem[];
+  providerChangeAuthoritativeReceipt?: ProviderDashboardChangeBookingPayload['authoritativeReceipt'];
+  partnerDeferredInvoice: boolean;
+  termsAcceptedAt: string | null;
+  skipConfirmationCommunications: boolean;
+  disableAutoCommunications: boolean;
+  setLoading: (loading: boolean) => void;
+  setError: (error: string) => void;
+  onSuccess?: (data: { reservationReference: string; bookingReference?: string }) => void;
+  onShowManage?: (params: { ref: string; lastName: string }) => void;
+  t: (key: string) => string;
+}
+
+export function usePrivateShuttleCheckoutController({
+  selectedOption,
+  selectedDate,
+  selectedStartTime,
+  selectedAvailability,
+  companyTimezone,
+  bookingCutoffNow,
+  bookingCutoffMinutes,
+  productId,
+  currency,
+  bookingSourceAttribution,
+  partnerPortalBooking,
+  forceDashboardSource,
+  isAdmin,
+  isProviderChangeMode,
+  onChangeBooking,
+  initialBooking,
+  email,
+  firstName,
+  lastName,
+  phoneNumber,
+  passengerCount,
+  maxVacancies,
+  isSpecialRequest,
+  billableResourceCount,
+  resourceCount,
+  resourcePrice,
+  basePrice,
+  pricingConfig,
+  refreshSelectedDateDetailsForCheckout,
+  reloadAvailabilitiesAfterReserveConflict,
+  totalPrice,
+  subtotal,
+  activePromoCode,
+  cancellationPolicyId,
+  selectedCancellationPolicyLabel,
+  cancellationPolicyFee,
+  addOnSelections,
+  addOns,
+  additionalHoursCount,
+  additionalHoursAmount,
+  perBookingFeeLineItems,
+  effectiveTaxAmount,
+  taxRate,
+  effectivePromoDiscountAmount,
+  isGiftCard,
+  isTaxIncludedInPrice,
+  depositInfo,
+  depositConfig,
+  balanceChargeDaysBefore,
+  selectedPickupLocationName,
+  customPickupAddress,
+  pickupLocationId,
+  pickupLocationSkipped,
+  hasPickupLocations,
+  draftItineraryDestinations,
+  draftItineraryPlanningNotes,
+  childSafetySeatsCount,
+  foodRestrictions,
+  itineraryDisplayItems,
+  providerChangeAuthoritativeReceipt,
+  partnerDeferredInvoice,
+  termsAcceptedAt,
+  skipConfirmationCommunications,
+  disableAutoCommunications,
+  setLoading,
+  setError,
+  onSuccess,
+  onShowManage,
+  t,
+}: UsePrivateShuttleCheckoutControllerParams) {
+  const [showCheckoutModal, setShowCheckoutModal] = useState(false);
+  const [checkoutClientSecret, setCheckoutClientSecret] = useState('');
+  const [checkoutModalData, setCheckoutModalData] = useState<PrivateShuttleCheckoutModalData | null>(null);
+  const [showAdminPaymentChoice, setShowAdminPaymentChoice] = useState(false);
+  const [adminChoiceData, setAdminChoiceData] = useState<PrivateShuttleAdminChoiceData | 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 (!selectedDate || !selectedStartTime || passengerCount < 1) {
+      setError('Please select a date, start time, and passenger count');
+      return;
+    }
+    if (!availabilityForCheckout?.availabilityId) {
+      setError('Please choose an available date before continuing.');
+      return;
+    }
+    if (
+      !isAdmin &&
+      !privateShuttleStartTimeAllowed(
+        selectedDate,
+        selectedStartTime,
+        companyTimezone,
+        bookingCutoffNow,
+        bookingCutoffMinutes,
+      )
+    ) {
+      setError(privateShuttleBookingCutoffMessage(bookingCutoffMinutes));
+      return;
+    }
+    if (
+      hasPickupLocations &&
+      !pickupLocationId &&
+      !customPickupAddress &&
+      !pickupLocationSkipped
+    ) {
+      setError(t('booking.selectPickupLocation'));
+      return;
+    }
+    if (!isProviderChangeMode) {
+      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;
+      }
+    }
+
+    setLoading(true);
+    setError('');
+    paymentSubmitInFlightRef.current = false;
+
+    try {
+      if (!selectedOption) {
+        setError('No product option selected');
+        setLoading(false);
+        return;
+      }
+      if (isProviderChangeMode && onChangeBooking) {
+        await applyPrivateShuttleProviderChange({
+          onChangeBooking,
+          selectedOption,
+          selectedDate,
+          selectedStartTime,
+          billableResourceCount,
+          pickupLocationId,
+          selectedPickupLocationName,
+          customPickupAddress,
+          initialBooking,
+          passengerCount,
+          childSafetySeatsCount,
+          foodRestrictions,
+          addOnSelections,
+          cancellationPolicyId,
+          activePromoCode,
+          totalPrice,
+          additionalHoursCount,
+          isAdmin,
+          providerChangeAuthoritativeReceipt,
+        });
+        setLoading(false);
+        return;
+      }
+
+      const reserveResult = await reservePrivateShuttleForCheckout({
+        selectedOption,
+        selectedDate,
+        selectedStartTime,
+        selectedAvailability: availabilityForCheckout,
+        companyTimezone,
+        productId,
+        currency,
+        bookingSourceAttribution,
+        partnerPortalBooking,
+        forceDashboardSource,
+        isAdmin,
+        isSpecialRequest,
+        passengerCount,
+        maxVacancies,
+        billableResourceCount,
+        resourceCount,
+        pricingConfig,
+        refreshSelectedDateDetailsForCheckout,
+        totalPrice,
+        activePromoCode,
+        cancellationPolicyId,
+        addOnSelections,
+        additionalHoursCount,
+        selectedPickupLocationName,
+        customPickupAddress,
+        pickupLocationId,
+        draftItineraryDestinations,
+        draftItineraryPlanningNotes,
+        childSafetySeatsCount,
+        foodRestrictions,
+        itineraryDisplayItems,
+      });
+      if (reserveResult.kind === 'blocked') {
+        setError(reserveResult.message);
+        setLoading(false);
+        return;
+      }
+      const {
+        bookingSourceContext,
+        pricingV2Quote,
+        reservation,
+        itineraryDisplayForStorage,
+      } = reserveResult;
+      pendingReservationRef.current = { reservationReference: reservation.reservationReference };
+
+      const taxLabel = t('booking.tax') !== 'booking.tax' ? t('booking.tax') : 'Taxes and fees';
+      const {
+        checkoutBreakdown,
+        pricingV2SummaryOverride,
+        receiptTotal,
+        checkoutDepositInfo,
+        ticketLinesForModal,
+        feeLineItemsForModal,
+      } = buildPrivateShuttleCheckoutArtifacts({
+        resourceCount,
+        resourcePrice,
+        basePrice,
+        addOnSelections,
+        addOns,
+        additionalHoursAmount,
+        additionalHoursCount,
+        perBookingFeeLineItems,
+        cancellationPolicyFee,
+        cancellationPolicyLabel: selectedCancellationPolicyLabel,
+        effectiveTaxAmount,
+        taxLabel,
+        effectivePromoDiscountAmount,
+        activePromoCode,
+        discountLabel: t('booking.discount') || 'Discount',
+        promoLineType: isGiftCard ? 'GIFT_CARD' : 'PROMO_CODE',
+        depositInfo,
+        depositConfig,
+        totalPrice,
+        currency,
+        pricingV2Quote: pricingV2Quote?.quote,
+        roundingLabel: t('booking.rounding') || 'Rounding',
+      });
+
+      if (partnerDeferredInvoice) {
+        const depositAmount = checkoutDepositInfo ? checkoutDepositInfo.depositAmount : 0;
+        const balanceAmount = checkoutDepositInfo ? checkoutDepositInfo.balanceAmount : receiptTotal;
+        const confirmedBooking = await confirmPartnerBookingWithoutPayment({
+          reservationReference: reservation.reservationReference,
+          productId,
+          optionId: selectedOption,
+          date: selectedDate,
+          time: selectedStartTime,
+          customerEmail: email || undefined,
+          customerFirstName: firstName.trim() || undefined,
+          customerLastName: lastName.trim() || undefined,
+          ...optionalCheckoutContactFields(phoneNumber),
+          currency,
+          travelerHotel: selectedPickupLocationName || customPickupAddress || undefined,
+          pickupLocationId: pickupLocationId || undefined,
+          itineraryDisplay: itineraryDisplayForStorage,
+          termsAcceptedAt: termsAcceptedAt ?? undefined,
+          skipConfirmationCommunications: skipConfirmationCommunications ? true : undefined,
+          disableAutoCommunications: disableAutoCommunications ? true : undefined,
+          checkoutBreakdown,
+          depositAmount,
+          balanceAmount,
+          totalAmount: receiptTotal,
+          balanceChargeDaysBefore: checkoutDepositInfo ? (balanceChargeDaysBefore ?? 7) : undefined,
+          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 {
+          window.location.href = `/manage-booking?ref=${ref}&lastName=${encodeURIComponent(ln)}&booking_complete=1`;
+        }
+        setLoading(false);
+        return;
+      }
+
+      if (isAdmin && checkoutDepositInfo) {
+        const paymentIntent = await createPaymentIntent({
+          productId,
+          optionId: selectedOption,
+          date: selectedDate,
+          time: selectedStartTime,
+          quantity: resourceCount,
+          customerEmail: email,
+          customerFirstName: firstName.trim() || undefined,
+          customerLastName: lastName.trim() || undefined,
+          ...optionalCheckoutContactFields(phoneNumber),
+          currency,
+          reservationReference: reservation.reservationReference,
+          travelerHotel: selectedPickupLocationName || customPickupAddress || undefined,
+          pickupLocationId: pickupLocationId || undefined,
+          itineraryDisplay: itineraryDisplayForStorage,
+          termsAcceptedAt: termsAcceptedAt ?? undefined,
+          cancellationPolicyId: cancellationPolicyId || undefined,
+          promoCode: activePromoCode || undefined,
+          checkoutBreakdown,
+          paymentPlanType: 'DEPOSIT',
+          pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+          pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+          idempotencyKey: pricingV2Quote?.quote?.quoteId
+            ? `checkout-payment-intent:${reservation.reservationReference}:${pricingV2Quote.quote.quoteId}`
+            : undefined,
+          depositAmount: checkoutDepositInfo.depositAmount,
+          balanceAmount: checkoutDepositInfo.balanceAmount,
+          totalAmount: checkoutDepositInfo.totalPrice,
+          balanceChargeDaysBefore: balanceChargeDaysBefore ?? 7,
+          skipConfirmationCommunications: skipConfirmationCommunications ? true : undefined,
+          disableAutoCommunications: disableAutoCommunications ? true : undefined,
+          ...bookingSourceContext,
+        });
+        setAdminChoiceData(buildPrivateShuttleAdminChoiceData({
+          reservation,
+          checkoutBreakdown,
+          totalAmount: checkoutDepositInfo.totalPrice,
+          datePart: selectedDate,
+          timePart: selectedStartTime,
+          availabilityProductOptionId: selectedOption,
+          itineraryDisplay: itineraryDisplayForStorage,
+          clientSecret: paymentIntent.clientSecret ?? '',
+          ticketLinesForModal,
+          feeLineItems: feeLineItemsForModal,
+          cancellationPolicyFee,
+          cancellationPolicyLabel: selectedCancellationPolicyLabel,
+          subtotal,
+          tax: effectiveTaxAmount,
+          totalQuantity: resourceCount,
+          isTaxIncludedInPrice,
+          taxRate,
+          promoDiscountAmount: effectivePromoDiscountAmount > 0 ? effectivePromoDiscountAmount : 0,
+          discountLabel: activePromoCode ? `Promo: ${activePromoCode}` : undefined,
+          summaryOverride: pricingV2SummaryOverride,
+          pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+          pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+        }));
+        setShowAdminPaymentChoice(true);
+        setLoading(false);
+        return;
+      }
+
+      const paymentIntent = await createPaymentIntent({
+        productId,
+        optionId: selectedOption,
+        date: selectedDate,
+        time: selectedStartTime,
+        quantity: resourceCount,
+        customerEmail: email,
+        customerFirstName: firstName.trim() || undefined,
+        customerLastName: lastName.trim() || undefined,
+        ...optionalCheckoutContactFields(phoneNumber),
+        currency,
+        reservationReference: reservation.reservationReference,
+        travelerHotel: selectedPickupLocationName || customPickupAddress || undefined,
+        pickupLocationId: pickupLocationId || undefined,
+        itineraryDisplay: itineraryDisplayForStorage,
+        termsAcceptedAt: termsAcceptedAt ?? undefined,
+        cancellationPolicyId: cancellationPolicyId || undefined,
+        promoCode: activePromoCode || undefined,
+        checkoutBreakdown,
+        pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+        pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+        idempotencyKey: pricingV2Quote?.quote?.quoteId
+          ? `checkout-payment-intent:${reservation.reservationReference}:${pricingV2Quote.quote.quoteId}`
+          : undefined,
+        ...(checkoutDepositInfo && {
+          paymentPlanType: 'DEPOSIT' as const,
+          depositAmount: checkoutDepositInfo.depositAmount,
+          balanceAmount: checkoutDepositInfo.balanceAmount,
+          totalAmount: checkoutDepositInfo.totalPrice,
+          balanceChargeDaysBefore: balanceChargeDaysBefore ?? 7,
+        }),
+        skipConfirmationCommunications: skipConfirmationCommunications ? true : undefined,
+        disableAutoCommunications: disableAutoCommunications ? true : undefined,
+        ...bookingSourceContext,
+      });
+
+      if (paymentIntent.freeBooking) {
+        const freeResult = await confirmFreeBooking({
+          reservationReference: reservation.reservationReference,
+          productId,
+          optionId: selectedOption,
+          date: selectedDate,
+          time: selectedStartTime,
+          customerEmail: email || undefined,
+          customerFirstName: firstName.trim() || undefined,
+          customerLastName: lastName.trim() || undefined,
+          ...optionalCheckoutContactFields(phoneNumber),
+          currency,
+          travelerHotel: selectedPickupLocationName || customPickupAddress || undefined,
+          pickupLocationId: pickupLocationId || undefined,
+          itineraryDisplay: itineraryDisplayForStorage,
+          termsAcceptedAt: termsAcceptedAt ?? undefined,
+          skipConfirmationCommunications: skipConfirmationCommunications ? true : undefined,
+          disableAutoCommunications: disableAutoCommunications ? true : undefined,
+          pricingQuoteId: pricingV2Quote?.quote?.quoteId ?? undefined,
+          pricingQuoteInputsHash: pricingV2Quote?.quote?.inputsHash ?? undefined,
+          ...bookingSourceContext,
+        });
+        pendingReservationRef.current = null;
+        const ref = formatBookingRefForDisplay(freeResult.bookingReference);
+        onSuccess?.({ reservationReference: reservation.reservationReference });
+        if (onShowManage) {
+          onShowManage({ ref, lastName: lastName.trim() });
+        } else {
+          window.location.href = `/manage-booking?ref=${ref}&lastName=${encodeURIComponent(lastName.trim())}&booking_complete=1`;
+        }
+        setLoading(false);
+        return;
+      }
+
+      setCheckoutClientSecret(paymentIntent.clientSecret ?? '');
+      setCheckoutModalData(buildPrivateShuttlePaidCheckoutModalData({
+        reservation,
+        customerLastName: lastName.trim(),
+        bookingDate: selectedDate,
+        ticketLines: ticketLinesForModal,
+        feeLineItems: feeLineItemsForModal,
+        subtotal: checkoutDepositInfo ? checkoutDepositInfo.totalPrice : receiptTotal,
+        tax: effectiveTaxAmount,
+        total: checkoutDepositInfo ? checkoutDepositInfo.depositAmount : receiptTotal,
+        totalQuantity: resourceCount,
+        isTaxIncludedInPrice,
+        taxRate,
+        cancellationPolicyFee,
+        cancellationPolicyLabel: selectedCancellationPolicyLabel,
+        promoDiscountAmount: effectivePromoDiscountAmount > 0 ? effectivePromoDiscountAmount : 0,
+        discountLabel: activePromoCode ? `Promo: ${activePromoCode}` : undefined,
+        summaryOverride: pricingV2SummaryOverride,
+        isDepositPayment: !!checkoutDepositInfo,
+        balanceChargeDaysBefore: checkoutDepositInfo ? (balanceChargeDaysBefore ?? 7) : undefined,
+      }));
+      setShowCheckoutModal(true);
+      setLoading(false);
+    } catch (err) {
+      if (isInsufficientCapacityReserveError(err)) {
+        try {
+          const merged = await reloadAvailabilitiesAfterReserveConflict();
+          const slot = findMergedPrivateShuttleAvailability(
+            merged,
+            availabilityForCheckout,
+            selectedOption || null,
+            selectedDate || null,
+            companyTimezone
+          );
+          setError(
+            describePrivateShuttleCapacityConflictMessage({
+              passengersRequested: passengerCount,
+              vacancies: slot?.vacancies ?? null,
+            })
+          );
+          reportReserveCapacityConflictClientContext({
+            flow: 'private_shuttle',
+            productId,
+            selectedDate: selectedDate || null,
+            outboundDateTime: availabilityForCheckout?.dateTime ?? null,
+            outboundVacanciesAfterRefresh: slot?.vacancies ?? null,
+            returnVacanciesAfterRefresh: null,
+            partySizeOrPassengers: passengerCount,
+            hasReturnSelection: false,
+            returnAvailabilityId: null,
+            reloadAvailabilitiesSucceeded: true,
+          });
+        } catch (reloadErr) {
+          setError(
+            describePrivateShuttleCapacityConflictMessage({
+              passengersRequested: passengerCount,
+              vacancies: null,
+            })
+          );
+          reportReserveCapacityConflictClientContext({
+            flow: 'private_shuttle',
+            productId,
+            selectedDate: selectedDate || null,
+            outboundDateTime: availabilityForCheckout?.dateTime ?? null,
+            outboundVacanciesAfterRefresh: null,
+            returnVacanciesAfterRefresh: null,
+            partySizeOrPassengers: passengerCount,
+            hasReturnSelection: false,
+            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 confirmPrivateShuttleAdminBookingWithoutPayment({
+        adminChoiceData: choice,
+        bookingSourceAttribution,
+        partnerPortalBooking,
+        forceDashboardSource,
+        productId,
+        email,
+        firstName,
+        lastName,
+        phoneNumber,
+        currency,
+        travelerHotel: selectedPickupLocationName || customPickupAddress || undefined,
+        pickupLocationId: pickupLocationId || undefined,
+        termsAcceptedAt,
+        skipConfirmationCommunications,
+        disableAutoCommunications,
+      });
+      pendingReservationRef.current = null;
+      setShowAdminPaymentChoice(false);
+      setAdminChoiceData(null);
+      onSuccess?.({
+        reservationReference: choice.reservationReference,
+        bookingReference: result.bookingReference,
+      });
+      if (onShowManage) {
+        onShowManage({ ref: result.displayReference, lastName: result.lastName });
+      } else {
+        window.location.href = `/manage-booking?ref=${result.displayReference}&lastName=${encodeURIComponent(result.lastName)}&booking_complete=1`;
+      }
+    } 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(buildPrivateShuttlePayNowCheckoutModalData(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,
+  };
+}