// core/domains/auth/initialization.ts
import { initializer, InitStage, InitTask } from '@/core/shared/app/initialization';
import { tokenService } from './tokenService';
import { authStore } from './store';
 
export const authInitialization: InitTask = {
  name: 'auth:token-retrieval',
  
  async execute(): Promise<void> {
    try {
      // Retrieve tokens from secure storage
      const token = await tokenService.getStoredAccessToken();
      const refreshToken = await tokenService.getStoredRefreshToken();
      
      // Update auth store
      if (token && refreshToken) {
        authStore.setTokens(token, refreshToken);
      }
    } catch (error) {
      console.error('Failed to initialize auth tokens:', error);
      // Non-blocking error - continue initialization
    }
  }
};
 
// Register task with initializer
initializer.registerTask(InitStage.PRE_UI, authInitialization);

// core/shared/app/initialization/events.ts
import { EventEmitter } from '@/core/shared/utils/events';
import { InitStage } from './initializer';
 
export type InitEvents = {
  'stage:complete': InitStage;
  'initialization:complete': void;
  'initialization:error': Error;
};
 
export const initEvents = new EventEmitter<InitEvents>();

// core/shared/app/initialization/InitializationProvider.tsx
import React, { createContext, useContext, useState, useEffect } from 'react';
import { initializer, InitStage } from './initializer';
import { initEvents } from './events';
 
interface InitializationState {
  initialized: boolean;
  currentStage: InitStage | null;
  error: Error | null;
  initializer: typeof initializer; // Expose initializer for direct usage
}
 
const InitializationContext = createContext<InitializationState>({
  initialized: false,
  currentStage: null,
  error: null,
  initializer
});
 
export const useInitialization = () => useContext(InitializationContext);
 
export function InitializationProvider({ children }: { children: React.ReactNode }) {
  const [state, setState] = useState<InitializationState>({
    initialized: false,
    currentStage: null,
    error: null,
    initializer
  });
  
  useEffect(() => {
    const stageListener = (stage: InitStage) => {
      setState(prev => ({ ...prev, currentStage: stage }));
    };
    
    const completeListener = () => {
      setState(prev => ({ ...prev, initialized: true }));
    };
    
    const errorListener = (error: Error) => {
      setState(prev => ({ ...prev, error }));
    };
    
    initEvents.on('stage:complete', stageListener);
    initEvents.on('initialization:complete', completeListener);
    initEvents.on('initialization:error', errorListener);
    
    // Note: We don't automatically start initialization here anymore
    // This is now handled in the root navigation component
    
    return () => {
      initEvents.off('stage:complete', stageListener);
      initEvents.off('initialization:complete', completeListener);
      initEvents.off('initialization:error', errorListener);
    };
  }, []);
  
  return (
    <InitializationContext.Provider value={{...state, initializer}}>
      {children}
    </InitializationContext.Provider>
  );
}

// core/shared/app/initialization/types.ts
 
/**
 * Defines the distinct stages of the application initialization process.
 * Stages execute in the order defined here (Pre-UI → Initial UI → Background → Finalization).
 */
export enum InitStage {
  /** Critical blocking operations that must complete before any UI rendering */
  PRE_UI = 'preUI',
  
  /** Initial UI shell rendering and essential components */
  INITIAL_UI = 'initialUI',
  
  /** Non-blocking parallel operations that enhance user experience */
  BACKGROUND = 'background',
  
  /** Final tasks to complete initialization and transition to full interactivity */
  FINALIZATION = 'finalization'
}
 
/**
 * Priority levels for initialization tasks.
 * Primarily used for Background stage tasks to determine execution order.
 */
export type TaskPriority = 'high' | 'normal' | 'low';
 
/**
 * Interface defining an initialization task.
 */
export interface InitTask {
  /** Unique name identifying the task, using domain:feature-task format */
  name: string;
  
  /** The function to execute - must return a Promise */
  execute: () => Promise<void>;
  
  /** The initialization stage this task belongs to */
  stage: InitStage;
  
  /** Optional array of task names this task depends on */
  dependencies?: string[];
  
  /** Priority level (default: 'normal') */
  priority?: TaskPriority;
  
  /** Whether failure should halt initialization (default: false) */
  critical?: boolean;
  
  /** Timeout in milliseconds (default: 30000) */
  timeout?: number;
}
 
/**
 * Event types emitted during initialization.
 */
export type InitEventTypes = {
  'stage:started': { stage: InitStage };
  'stage:complete': { stage: InitStage };
  'task:started': { name: string; stage: InitStage };
  'task:completed': { name: string; stage: InitStage };
  'task:error': { name: string; stage: InitStage; error: Error };
  'initialization:complete': void;
  'initialization:error': Error;
};

// core/shared/app/initialization/initializer.ts
import { EventEmitter } from '@/core/shared/utils/events';
import { InitStage, InitTask, InitEventTypes, TaskPriority } from './types';
 
/**
 * Event emitter for initialization events.
 * Allows components to subscribe to initialization progress events.
 */
export const initEvents = new EventEmitter<InitEventTypes>();
 
/**
 * Core class that manages the application initialization process.
 * Handles registration, dependency resolution, and execution of initialization tasks.
 */
export class Initializer {
  /** Map of stages to their registered tasks */
  private stages: Map<InitStage, InitTask[]> = new Map();
  
  /** Tracks completed tasks by name */
  private completedTasks: Set<string> = new Set();
  
  /** Tracks whether specific stages have completed */
  private completedStages: Set<InitStage> = new Set();
  
  /** Tracks currently executing tasks */
  private executingTasks: Set<string> = new Set();
  
  /**
   * Registers an initialization task for a specific stage.
   * 
   * @param stage - The initialization stage this task belongs to
   * @param task - The task configuration object
   */
  registerTask(stage: InitStage, task: Omit<InitTask, 'stage'>): void {
    // Create the full task with stage information
    const fullTask: InitTask = {
      ...task,
      stage,
      priority: task.priority || 'normal',
      critical: task.critical ?? false,
      timeout: task.timeout ?? 30000 // Default 30 second timeout
    };
    
    // Initialize the stage array if needed
    if (!this.stages.has(stage)) {
      this.stages.set(stage, []);
    }
    
    // Add the task to the appropriate stage
    const stageTasks = this.stages.get(stage)!;
    
    // Check for duplicate task names
    if (stageTasks.some(t => t.name === fullTask.name)) {
      console.warn(`Task with name ${fullTask.name} already registered for stage ${stage}`);
      return;
    }
    
    stageTasks.push(fullTask);
  }
  
  /**
   * Executes all tasks for a specific stage sequentially, respecting dependencies.
   * Used for PRE_UI and INITIAL_UI stages that require ordered execution.
   * 
   * @param stage - The stage to execute
   * @returns Promise resolving when all tasks in the stage complete
   */
  async executeStage(stage: InitStage): Promise<void> {
    try {
      const tasks = this.stages.get(stage) || [];
      
      // Notify stage started
      initEvents.emit('stage:started', { stage });
      
      // Sort tasks to respect dependencies
      const sortedTasks = this.sortTasksByDependencies(tasks);
      
      // Execute tasks sequentially
      for (const task of sortedTasks) {
        await this.executeTask(task);
      }
      
      // Mark stage as completed
      this.completedStages.add(stage);
      
      // Notify stage complete
      initEvents.emit('stage:complete', { stage });
      
      // Check if all stages are complete
      this.checkInitializationComplete();
    } catch (error) {
      console.error(`Stage ${stage} execution failed:`, error);
      initEvents.emit('initialization:error', error as Error);
      throw error;
    }
  }
  
  /**
   * Executes tasks for a stage in parallel, grouped by priority.
   * Used for BACKGROUND and FINALIZATION stages where tasks can run concurrently.
   * 
   * @param stage - The stage to execute in parallel
   * @returns Promise resolving when all tasks in the stage complete
   */
  async executeParallelStage(stage: InitStage): Promise<void> {
    try {
      const tasks = this.stages.get(stage) || [];
      
      // Notify stage started
      initEvents.emit('stage:started', { stage });
      
      // Group tasks by priority
      const highPriorityTasks = tasks.filter(task => task.priority === 'high');
      const normalPriorityTasks = tasks.filter(task => task.priority === 'normal');
      const lowPriorityTasks = tasks.filter(task => task.priority === 'low');
      
      // Execute high priority tasks first
      await Promise.all(highPriorityTasks.map(task => this.executeTask(task)));
      
      // Then normal priority tasks
      await Promise.all(normalPriorityTasks.map(task => this.executeTask(task)));
      
      // Finally low priority tasks
      await Promise.all(lowPriorityTasks.map(task => this.executeTask(task)));
      
      // Mark stage as completed
      this.completedStages.add(stage);
      
      // Notify stage complete
      initEvents.emit('stage:complete', { stage });
      
      // Check if all stages are complete
      this.checkInitializationComplete();
    } catch (error) {
      console.error(`Stage ${stage} execution failed:`, error);
      initEvents.emit('initialization:error', error as Error);
      throw error;
    }
  }
  
  /**
   * Executes a single initialization task with timeout and error handling.
   * 
   * @param task - The task to execute
   * @returns Promise resolving when the task completes
   */
  private async executeTask(task: InitTask): Promise<void> {
    // Skip if dependencies aren't satisfied
    if (!this.areDependenciesSatisfied(task)) {
      throw new Error(
        `Task ${task.name} dependencies not satisfied. ` +
        `Missing: ${this.getMissingDependencies(task).join(', ')}`
      );
    }
    
    // Skip if already completed
    if (this.completedTasks.has(task.name)) {
      return;
    }
    
    // Mark as executing
    this.executingTasks.add(task.name);
    
    try {
      // Notify task started
      initEvents.emit('task:started', { name: task.name, stage: task.stage });
      
      // Create a timeout promise
      const timeoutPromise = new Promise<never>((_, reject) => {
        setTimeout(() => {
          reject(new Error(`Task ${task.name} timed out after ${task.timeout}ms`));
        }, task.timeout);
      });
      
      // Race between task execution and timeout
      await Promise.race([
        task.execute(),
        timeoutPromise
      ]);
      
      // Mark as completed
      this.completedTasks.add(task.name);
      this.executingTasks.delete(task.name);
      
      // Notify task completed
      initEvents.emit('task:completed', { name: task.name, stage: task.stage });
    } catch (error) {
      // Handle task error
      this.executingTasks.delete(task.name);
      console.error(`Task ${task.name} failed:`, error);
      initEvents.emit('task:error', { 
        name: task.name, 
        stage: task.stage, 
        error: error as Error 
      });
      
      // Rethrow critical errors, swallow non-critical ones
      if (task.critical) {
        throw error;
      }
    }
  }
  
  /**
   * Checks if all required dependencies for a task have been completed.
   * 
   * @param task - The task to check dependencies for
   * @returns True if all dependencies are satisfied
   */
  private areDependenciesSatisfied(task: InitTask): boolean {
    if (!task.dependencies || task.dependencies.length === 0) {
      return true;
    }
    
    return task.dependencies.every(dep => this.completedTasks.has(dep));
  }
  
  /**
   * Gets the list of dependencies that haven't been satisfied yet.
   * 
   * @param task - The task to check
   * @returns Array of missing dependency names
   */
  private getMissingDependencies(task: InitTask): string[] {
    if (!task.dependencies) {
      return [];
    }
    
    return task.dependencies.filter(dep => !this.completedTasks.has(dep));
  }
  
  /**
   * Sorts tasks based on their dependencies to ensure proper execution order.
   * Uses a topological sort algorithm.
   * 
   * @param tasks - Array of tasks to sort
   * @returns Sorted array of tasks respecting dependencies
   */
  private sortTasksByDependencies(tasks: InitTask[]): InitTask[] {
    // Build dependency graph
    const graph = new Map<string, string[]>();
    tasks.forEach(task => {
      graph.set(task.name, task.dependencies || []);
    });
    
    // Topological sort
    const result: InitTask[] = [];
    const visited = new Set<string>();
    const temp = new Set<string>();
    
    const visit = (taskName: string) => {
      if (temp.has(taskName)) {
        throw new Error(`Dependency cycle detected involving task ${taskName}`);
      }
      
      if (visited.has(taskName)) {
        return;
      }
      
      temp.add(taskName);
      
      const dependencies = graph.get(taskName) || [];
      for (const dep of dependencies) {
        visit(dep);
      }
      
      temp.delete(taskName);
      visited.add(taskName);
      
      const task = tasks.find(t => t.name === taskName);
      if (task) {
        result.push(task);
      }
    };
    
    // Visit all tasks
    for (const task of tasks) {
      if (!visited.has(task.name)) {
        visit(task.name);
      }
    }
    
    return result.reverse();
  }
  
  /**
   * Checks if all stages have completed and emits the initialization complete event.
   */
  private checkInitializationComplete(): void {
    const allStages = Object.values(InitStage);
    const registeredStages = Array.from(this.stages.keys());
    
    // Check if all registered stages are complete
    const allComplete = registeredStages.every(stage => 
      this.completedStages.has(stage)
    );
    
    if (allComplete && registeredStages.length > 0) {
      initEvents.emit('initialization:complete', undefined);
    }
  }
  
  /**
   * Resets the initializer state.
   * Primarily used for testing purposes.
   */
  reset(): void {
    this.stages = new Map();
    this.completedTasks = new Set();
    this.completedStages = new Set();
    this.executingTasks = new Set();
  }
}
 
// Create singleton instance
export const initializer = new Initializer();

// core/shared/app/initialization/InitializationProvider.tsx
import React, { createContext, useContext, useState, useEffect } from 'react';
import { initializer, InitStage } from './initializer';
import { initEvents } from './events';
 
interface InitializationState {
  initialized: boolean;
  currentStage: InitStage | null;
  error: Error | null;
  initializer: typeof initializer; // Expose initializer for direct usage
}
 
const InitializationContext = createContext<InitializationState>({
  initialized: false,
  currentStage: null,
  error: null,
  initializer
});
 
export const useInitialization = () => useContext(InitializationContext);
 
export function InitializationProvider({ children }: { children: React.ReactNode }) {
  const [state, setState] = useState<InitializationState>({
    initialized: false,
    currentStage: null,
    error: null,
    initializer
  });
  
  useEffect(() => {
    const stageListener = ({ stage }: { stage: InitStage }) => {
      setState(prev => ({ ...prev, currentStage: stage }));
    };
    
    const completeListener = () => {
      setState(prev => ({ ...prev, initialized: true }));
    };
    
    const errorListener = (error: Error) => {
      setState(prev => ({ ...prev, error }));
    };
    
    initEvents.on('stage:started', stageListener);
    initEvents.on('initialization:complete', completeListener);
    initEvents.on('initialization:error', errorListener);
    
    return () => {
      initEvents.off('stage:started', stageListener);
      initEvents.off('initialization:complete', completeListener);
      initEvents.off('initialization:error', errorListener);
    };
  }, []);
  
  return (
    <InitializationContext.Provider value={{...state, initializer}}>
      {children}
    </InitializationContext.Provider>
  );
}

// core/shared/initialization/ErrorBoundary.tsx
import React, { useState, useEffect } from 'react';
import { View, Text, StyleSheet, TouchableOpacity } from 'react-native';
import { InitErrorType, useInitialization } from '@/core/shared/app/initialization';
 
/**
 * Error screen displayed when initialization fails
 */
export function InitializationErrorScreen({ 
  error, 
  retry 
}: { 
  error: Error; 
  retry: () => void 
}) {
  // Determine error type to show appropriate guidance
  const errorType = error.name === 'NetworkError' 
    ? 'network' 
    : error.name === 'AuthError' 
      ? 'auth' 
      : 'unknown';
  
  return (
    <View style={styles.container}>
      <Text style={styles.title}>Unable to Start Application</Text>
      
      {errorType === 'network' && (
        <>
          <Text style={styles.message}>
            Please check your internet connection and try again.
          </Text>
          <View style={styles.iconContainer}>
            {/* Network error icon */}
          </View>
        </>
      )}
      
      {errorType === 'auth' && (
        <>
          <Text style={styles.message}>
            There was a problem with your account. Please log in again.
          </Text>
          <View style={styles.iconContainer}>
            {/* Auth error icon */}
          </View>
        </>
      )}
      
      {errorType === 'unknown' && (
        <>
          <Text style={styles.message}>
            An unexpected error occurred while starting the app.
          </Text>
          <View style={styles.iconContainer}>
            {/* Generic error icon */}
          </View>
        </>
      )}
      
      <TouchableOpacity 
        style={styles.button} 
        onPress={retry}
        activeOpacity={0.7}
      >
        <Text style={styles.buttonText}>Try Again</Text>
      </TouchableOpacity>
    </View>
  );
}
 
/**
 * Wrapper component that handles initialization errors
 */
export function InitializationErrorBoundary({ children }: { children: React.ReactNode }) {
  const { error, initializer } = useInitialization();
  const [retryCount, setRetryCount] = useState(0);
  
  // Retry initialization
  const handleRetry = () => {
    setRetryCount(count => count + 1);
    // Reset initializer state and try again
    initializer.reset();
    initializer.executeStage(InitStage.PRE_UI);
  };
  
  // If there's an initialization error, show the error screen
  if (error) {
    return <InitializationErrorScreen error={error} retry={handleRetry} />;
  }
  
  // No error, render children normally
  return <>{children}</>;
}
 
const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center',
    padding: 24,
    backgroundColor: '#FFFFFF'
  },
  title: {
    fontSize: 22,
    fontWeight: 'bold',
    marginBottom: 16,
    color: '#E53935'
  },
  message: {
    fontSize: 16,
    textAlign: 'center',
    marginBottom: 24,
    color: '#424242'
  },
  iconContainer: {
    width: 120,
    height: 120,
    marginBottom: 32,
    justifyContent: 'center',
    alignItems: 'center'
  },
  button: {
    backgroundColor: '#2196F3',
    paddingVertical: 12,
    paddingHorizontal: 32,
    borderRadius: 24
  },
  buttonText: {
    color: '#FFFFFF',
    fontSize: 16,
    fontWeight: 'bold'
  }
});

// App.tsx or app/_layout.tsx
import { InitializationErrorBoundary } from '@/core/shared/app/initialization/ErrorBoundary';
 
export default function App() {
  // Other initialization code...
  
  return (
    <InitializationProvider>
      <InitializationErrorBoundary>
        <QueryClientProvider client={queryClient}>
          <ThemeProvider>
            <NavigationContainer>
              <AppNavigator />
            </NavigationContainer>
          </ThemeProvider>
        </QueryClientProvider>
      </InitializationErrorBoundary>
    </InitializationProvider>
  );
}

// In InitializationProvider
useEffect(() => {
  const stageListener = ({ stage }: { stage: InitStage }) => {
    setState(prev => ({ ...prev, currentStage: stage }));
  };
  
  const errorListener = (error: Error) => {
    // Log detailed error information for debugging
    console.error(`Initialization error (${state.currentStage || 'unknown stage'}):`, error);
    
    // Categorize errors by stage for appropriate UI response
    const errorWithContext: InitError = {
      ...error,
      stage: state.currentStage,
      timestamp: new Date().toISOString()
    };
    
    setState(prev => ({ ...prev, error: errorWithContext }));
    
    // For non-critical errors in later stages, you might
    // want to show a toast or snackbar instead of a full error screen
    if (state.currentStage !== InitStage.PRE_UI) {
      showNonBlockingError(errorWithContext);
    }
  };
  
  // Rest of the effect code...
}, []);

// In your root component
import { initializer, InitStage, initEvents } from '@/core/shared/app/initialization';
import { SplashScreen } from '@/core/shared/splash-screen/SplashScreen';
 
export default function App() {
  useEffect(() => {
    async function initialize() {
      try {
        // Listen for timeout events to communicate to the user
        const timeoutListener = ({ task, stage }) => {
          // Update UI to show that something is taking longer than expected
          if (stage === InitStage.PRE_UI) {
            SplashScreen.setMessage('Taking longer than expected...');
          }
        };
        
        initEvents.on('task:timeout', timeoutListener);
        
        // Start initialization with progress updates
        await initializer.executeStage(InitStage.PRE_UI);
        SplashScreen.setProgress(0.4);
        
        // Continue with other stages...
        
        // Clean up
        initEvents.off('task:timeout', timeoutListener);
      } catch (error) {
        // Handle initialization failure
        if (error instanceof InitializationTimeoutError) {
          // Show specific timeout error UI
          setTimeoutError(error);
        } else {
          // Handle other errors
          setGeneralError(error);
        }
      }
    }
    
    initialize();
  }, []);
  
  // Render appropriate UI based on initialization state
}

// core/shared/app/initialization/performance.ts
import { InitStage } from './types';
 
/**
 * Interface for tracking detailed performance metrics
 */
export interface PerformanceMetrics {
  // Overall timing
  totalDuration: number;
  appStartTimestamp: number;
  
  // Stage timing
  stageDurations: Record<InitStage, number>;
  stageStartTimes: Record<InitStage, number>;
  stageEndTimes: Record<InitStage, number>;
  
  // Task timing
  taskDurations: Record<string, number>;
  longestTasks: Array<{name: string; duration: number}>;
}
 
/**
 * Service for tracking initialization performance
 */
export class PerformanceTracker {
  private appStartTime: number;
  private stageStartTimes: Partial<Record<InitStage, number>> = {};
  private stageEndTimes: Partial<Record<InitStage, number>> = {};
  private taskStartTimes: Map<string, number> = new Map();
  private taskDurations: Map<string, number> = new Map();
  
  constructor() {
    // Record app start time as soon as JavaScript bundle loads
    this.appStartTime = performance.now();
    
    // Listen for stage and task events to track timing
    initEvents.on('stage:started', this.handleStageStarted);
    initEvents.on('stage:complete', this.handleStageComplete);
    initEvents.on('task:started', this.handleTaskStarted);
    initEvents.on('task:completed', this.handleTaskCompleted);
  }
  
  private handleStageStarted = ({ stage }: { stage: InitStage }) => {
    this.stageStartTimes[stage] = performance.now();
  };
  
  private handleStageComplete = ({ stage }: { stage: InitStage }) => {
    this.stageEndTimes[stage] = performance.now();
  };
  
  private handleTaskStarted = ({ name }: { name: string }) => {
    this.taskStartTimes.set(name, performance.now());
  };
  
  private handleTaskCompleted = ({ name }: { name: string }) => {
    const startTime = this.taskStartTimes.get(name);
    if (startTime) {
      const duration = performance.now() - startTime;
      this.taskDurations.set(name, duration);
    }
  };
  
  /**
   * Get complete performance metrics
   */
  getMetrics(): PerformanceMetrics {
    const now = performance.now();
    const totalDuration = now - this.appStartTime;
    
    // Calculate stage durations
    const stageDurations: Partial<Record<InitStage, number>> = {};
    Object.values(InitStage).forEach(stage => {
      const start = this.stageStartTimes[stage] || 0;
      const end = this.stageEndTimes[stage] || now;
      stageDurations[stage] = end - start;
    });
    
    // Find longest tasks
    const taskEntries = Array.from(this.taskDurations.entries())
      .map(([name, duration]) => ({ name, duration }))
      .sort((a, b) => b.duration - a.duration)
      .slice(0, 5); // Top 5 longest tasks
    
    return {
      totalDuration,
      appStartTimestamp: this.appStartTime,
      stageDurations: stageDurations as Record<InitStage, number>,
      stageStartTimes: this.stageStartTimes as Record<InitStage, number>,
      stageEndTimes: this.stageEndTimes as Record<InitStage, number>,
      taskDurations: Object.fromEntries(this.taskDurations),
      longestTasks: taskEntries
    };
  }
  
  /**
   * Log performance metrics to console in a readable format
   */
  logMetricsToConsole() {
    const metrics = this.getMetrics();
    
    console.group('📊 App Initialization Performance Metrics');
    console.log(`Total Time: ${metrics.totalDuration.toFixed(2)}ms`);
    
    console.group('Stage Durations:');
    Object.entries(metrics.stageDurations).forEach(([stage, duration]) => {
      console.log(`- ${stage}: ${duration.toFixed(2)}ms`);
    });
    console.groupEnd();
    
    console.group('Longest Tasks:');
    metrics.longestTasks.forEach(task => {
      console.log(`- ${task.name}: ${task.duration.toFixed(2)}ms`);
    });
    console.groupEnd();
    
    console.groupEnd();
    
    // Additional analytics reporting if needed
    if (__DEV__) {
      // Only log details in development mode
      console.log('Full performance data:', metrics);
    } else {
      // In production, you might want to send this data to an analytics service
      analyticsService?.trackEvent('app_initialization_complete', {
        totalTime: Math.round(metrics.totalDuration),
        preUiTime: Math.round(metrics.stageDurations[InitStage.PRE_UI] || 0),
        uiRenderTime: Math.round(metrics.stageDurations[InitStage.INITIAL_UI] || 0),
        backgroundTime: Math.round(metrics.stageDurations[InitStage.BACKGROUND] || 0)
      });
    }
    
    return metrics;
  }
  
  /**
   * Reset the tracker for testing purposes
   */
  reset() {
    this.stageStartTimes = {};
    this.stageEndTimes = {};
    this.taskStartTimes.clear();
    this.taskDurations.clear();
  }
}
 
// Create singleton instance
export const performanceTracker = new PerformanceTracker();

// In your root component (App.tsx or _layout.tsx)
import { performanceTracker } from '@/core/shared/app/initialization/performance';
 
export default function App() {
  // Other initialization code...
  
  useEffect(() => {
    async function initialize() {
      try {
        await initializer.executeStage(InitStage.PRE_UI);
        setPreUIComplete(true);
        
        // Continue with other stages...
        await initializer.executeStage(InitStage.INITIAL_UI);
        await initializer.executeParallelStage(InitStage.BACKGROUND);
        await initializer.executeStage(InitStage.FINALIZATION);
        
        // Log performance metrics when initialization completes
        performanceTracker.logMetricsToConsole();
      } catch (error) {
        console.error('Initialization failed:', error);
      }
    }
    
    initialize();
  }, []);
  
  // Rest of component...
}