tuna/PurchaseFlowService.ts at e75424aac07d11f84d491dcf6aedc104cb2c9f48

 import { PricingCalculation } from './PricingService';
 export interface PurchaseStep {
   id: string;
   title: string;
   description: string;
   completed: boolean;
   current: boolean;
   error?: string;
 }
 export interface PurchaseFlowState {
   currentStep: number;
   steps: PurchaseStep[];
   calculation: PricingCalculation | null;
   paymentIntentId: string | null;
   clientSecret: string | null;
   error: any;
   isProcessing: boolean;
 }
 export class PurchaseFlowService {
   private static readonly STEPS: Omit<PurchaseStep, 'completed' | 'current' | 'error'>[] = [
     {
       id: 'quantity-selection',
       title: 'Select Tokens',
       description: 'Choose the number of tokens you want to purchase'
     },
     {
       id: 'pricing-calculation',
       title: 'Calculate Price',
       description: 'Review pricing and available discounts'
     },
     {
       id: 'payment-method',
       title: 'Payment Method',
       description: 'Select your preferred payment method'
     },
     {
       id: 'payment-processing',
       title: 'Process Payment',
       description: 'Complete your payment securely'
     },
     {
       id: 'confirmation',
       title: 'Confirmation',
       description: 'Payment successful and tokens allocated'
     }
   ];
   /**
    * Initialize the purchase flow
    */
   static initializeFlow(): PurchaseFlowState {
     const steps = this.STEPS.map((step, index) => ({
       ...step,
       completed: false,
       current: index === 0,
       error: undefined
     }));
     return {
       currentStep: 0,
       steps,
       calculation: null,
       paymentIntentId: null,
       clientSecret: null,
       error: null,
       isProcessing: false
     };
   }
   /**
    * Move to the next step
    */
   static nextStep(state: PurchaseFlowState): PurchaseFlowState {
     const newState = { ...state };
     if (newState.currentStep < newState.steps.length - 1) {
       // Mark current step as completed
       newState.steps[newState.currentStep] = {
         ...newState.steps[newState.currentStep],
         completed: true,
         current: false
       };
       // Move to next step
       newState.currentStep += 1;
       newState.steps[newState.currentStep] = {
         ...newState.steps[newState.currentStep],
         current: true
       };
     }
     return newState;
   }
   /**
    * Move to the previous step
    */
   static previousStep(state: PurchaseFlowState): PurchaseFlowState {
     const newState = { ...state };
     if (newState.currentStep > 0) {
       // Mark current step as not current
       newState.steps[newState.currentStep] = {
         ...newState.steps[newState.currentStep],
         current: false
       };
       // Move to previous step
       newState.currentStep -= 1;
       newState.steps[newState.currentStep] = {
         ...newState.steps[newState.currentStep],
         current: true,
         completed: false // Allow editing previous step
       };
     }
     return newState;
   }
   /**
    * Jump to a specific step
    */
   static goToStep(state: PurchaseFlowState, stepIndex: number): PurchaseFlowState {
     const newState = { ...state };
     if (stepIndex >= 0 && stepIndex < newState.steps.length) {
       // Reset all steps
       newState.steps = newState.steps.map((step, index) => ({
         ...step,
         completed: index < stepIndex,
         current: index === stepIndex,
         error: undefined
       }));
       newState.currentStep = stepIndex;
     }
     return newState;
   }
   /**
    * Set error for current step
    */
   static setStepError(state: PurchaseFlowState, error: any): PurchaseFlowState {
     const newState = { ...state };
     newState.steps[newState.currentStep] = {
       ...newState.steps[newState.currentStep],
       error: error?.message || 'An error occurred'
     };
     newState.error = error;
     return newState;
   }
   /**
    * Clear error for current step
    */
   static clearStepError(state: PurchaseFlowState): PurchaseFlowState {
     const newState = { ...state };
     newState.steps[newState.currentStep] = {
       ...newState.steps[newState.currentStep],
       error: undefined
     };
     newState.error = null;
     return newState;
   }
   /**
    * Set processing state
    */
   static setProcessing(state: PurchaseFlowState, isProcessing: boolean): PurchaseFlowState {
     return {
       ...state,
       isProcessing
     };
   }
   /**
    * Set calculation data
    */
   static setCalculation(state: PurchaseFlowState, calculation: PricingCalculation): PurchaseFlowState {
     return {
       ...state,
       calculation
     };
   }
   /**
    * Set payment intent data
    */
   static setPaymentIntent(state: PurchaseFlowState, paymentIntentId: string, clientSecret: string): PurchaseFlowState {
     return {
       ...state,
       paymentIntentId,
       clientSecret
     };
   }
   /**
    * Complete the purchase flow
    */
   static completeFlow(state: PurchaseFlowState): PurchaseFlowState {
     const newState = { ...state };
     // Mark all steps as completed
     newState.steps = newState.steps.map(step => ({
       ...step,
       completed: true,
       current: false
     }));
     newState.isProcessing = false;
     newState.error = null;
     return newState;
   }
   /**
    * Reset the flow to initial state
    */
   static resetFlow(): PurchaseFlowState {
     return this.initializeFlow();
   }
   /**
    * Get current step info
    */
   static getCurrentStep(state: PurchaseFlowState): PurchaseStep | null {
     return state.steps[state.currentStep] || null;
   }
   /**
    * Check if flow can proceed to next step
    */
   static canProceed(state: PurchaseFlowState): boolean {
     const currentStep = this.getCurrentStep(state);
     if (!currentStep) return false;
     switch (currentStep.id) {
       case 'quantity-selection':
         return state.calculation !== null;
       case 'pricing-calculation':
         return state.calculation !== null;
       case 'payment-method':
         return true; // Payment method selection is always valid
       case 'payment-processing':
         return state.clientSecret !== null;
       case 'confirmation':
         return true; // Confirmation step is always valid
       default:
         return false;
     }
   }
   /**
    * Get progress percentage
    */
   static getProgress(state: PurchaseFlowState): number {
     const completedSteps = state.steps.filter(step => step.completed).length;
     return (completedSteps / state.steps.length) * 100;
   }
   /**
    * Check if flow is completed
    */
   static isCompleted(state: PurchaseFlowState): boolean {
     return state.steps.every(step => step.completed);
   }
   /**
    * Get step by ID
    */
   static getStepById(state: PurchaseFlowState, stepId: string): PurchaseStep | null {
     return state.steps.find(step => step.id === stepId) || null;
   }
   /**
    * Validate current step
    */
   static validateCurrentStep(state: PurchaseFlowState): {
     isValid: boolean;
     error?: string;
   } {
     const currentStep = this.getCurrentStep(state);
     if (!currentStep) {
       return { isValid: false, error: 'Invalid step' };
     }
     switch (currentStep.id) {
       case 'quantity-selection':
         if (!state.calculation) {
           return { isValid: false, error: 'Please select a quantity' };
         }
         break;
       case 'pricing-calculation':
         if (!state.calculation) {
           return { isValid: false, error: 'Please calculate pricing first' };
         }
         break;
       case 'payment-method':
         // Payment method selection is always valid
         break;
       case 'payment-processing':
         if (!state.clientSecret) {
           return { isValid: false, error: 'Payment intent not created' };
         }
         break;
       case 'confirmation':
         // Confirmation step is always valid
         break;
     }
     return { isValid: true };
   }
 }