utils.js

// Utility functions for the exam application

/**
 * Shuffle array elements using Fisher-Yates algorithm
 * @param {Array} array - Array to shuffle
 * @returns {Array} - Shuffled array
 */
export function shuffleArray(array) {
  const shuffled = [...array];
  for (let i = shuffled.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
  }
  return shuffled;
}

/**
 * Calculate exam score
 * @param {Array} userAnswers - Array of user's selected answers
 * @param {Array} questions - Array of questions with correct answers
 * @returns {Object} - Score object with correct, total, percentage, and details
 */
export function calculateScore(userAnswers, questions) {
  let correct = 0;
  const details = [];
  
  questions.forEach((question, index) => {
    const userAnswer = userAnswers[index];
    const isCorrect = userAnswer === question.correct;
    
    if (isCorrect) {
      correct++;
    }
    
    details.push({
      questionId: question.id,
      userAnswer: userAnswer,
      correctAnswer: question.correct,
      isCorrect: isCorrect,
      explanation: question.explanation
    });
  });
  
  const total = questions.length;
  const percentage = Math.round((correct / total) * 100);
  
  return {
    correct,
    total,
    percentage,
    details
  };
}

/**
 * Format time duration in seconds to readable format
 * @param {number} seconds - Duration in seconds
 * @returns {string} - Formatted time string
 */
export function formatTime(seconds) {
  const hours = Math.floor(seconds / 3600);
  const minutes = Math.floor((seconds % 3600) / 60);
  const secs = seconds % 60;
  
  if (hours > 0) {
    return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
  }
  return `${minutes}:${secs.toString().padStart(2, '0')}`;
}

/**
 * Start countdown timer
 * @param {number} seconds - Total seconds for timer
 * @param {Function} callback - Callback function called every second
 * @returns {Object} - Timer object with stop method
 */
export function startTimer(seconds, callback) {
  let remaining = seconds;
  let intervalId = null;
  
  const update = () => {
    if (remaining <= 0) {
      clearInterval(intervalId);
      callback(0);
      return;
    }
    
    callback(remaining);
    remaining--;
  };
  
  // Call immediately
  update();
  
  // Then start interval
  intervalId = setInterval(update, 1000);
  
  return {
    stop: () => clearInterval(intervalId)
  };
}

/**
 * Create progress percentage
 * @param {number} current - Current progress
 * @param {number} total - Total items
 * @returns {number} - Percentage (0-100)
 */
export function getProgressPercentage(current, total) {
  return Math.round((current / total) * 100);
}

/**
 * Generate random exam session ID
 * @returns {string} - Unique session ID
 */
export function generateSessionId() {
  return 'CEH-' + Date.now() + '-' + Math.random().toString(36).substr(2, 9).toUpperCase();
}

/**
 * Save exam results to localStorage
 * @param {Object} results - Exam results object
 */
export function saveResults(results) {
  try {
    localStorage.setItem('ceh-exam-results', JSON.stringify(results));
  } catch (error) {
    console.error('Failed to save results to localStorage:', error);
  }
}

/**
 * Load exam results from localStorage
 * @returns {Object|null} - Saved results or null
 */
export function loadResults() {
  try {
    const saved = localStorage.getItem('ceh-exam-results');
    return saved ? JSON.parse(saved) : null;
  } catch (error) {
    console.error('Failed to load results from localStorage:', error);
    return null;
  }
}

/**
 * Clear saved results from localStorage
 */
export function clearResults() {
  try {
    localStorage.removeItem('ceh-exam-results');
  } catch (error) {
    console.error('Failed to clear results from localStorage:', error);
  }
}

/**
 * Validate exam configuration
 * @param {Object} config - Exam configuration
 * @returns {Object} - Validation result
 */
export function validateConfig(config) {
  const errors = [];
  
  if (!config || typeof config !== 'object') {
    errors.push('Configuration must be an object');
    return { isValid: false, errors };
  }
  
  if (!config.questions || !Array.isArray(config.questions) || config.questions.length === 0) {
    errors.push('Questions array is required and must not be empty');
  }
  
  if (config.timeLimit && (typeof config.timeLimit !== 'number' || config.timeLimit <= 0)) {
    errors.push('Time limit must be a positive number');
  }
  
  if (config.passingScore && (typeof config.passingScore !== 'number' || config.passingScore < 0 || config.passingScore > 100)) {
    errors.push('Passing score must be a number between 0 and 100');
  }
  
  return {
    isValid: errors.length === 0,
    errors
  };
}

/**
 * Debounce function to limit the rate of function calls
 * @param {Function} func - Function to debounce
 * @param {number} wait - Wait time in milliseconds
 * @returns {Function} - Debounced function
 */
export function debounce(func, wait) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

/**
 * Get grade based on percentage
 * @param {number} percentage - Score percentage
 * @returns {string} - Grade letter
 */
export function getGrade(percentage) {
  if (percentage >= 90) return 'A+';
  if (percentage >= 85) return 'A';
  if (percentage >= 80) return 'A-';
  if (percentage >= 75) return 'B+';
  if (percentage >= 70) return 'B';
  if (percentage >= 65) return 'B-';
  if (percentage >= 60) return 'C+';
  if (percentage >= 55) return 'C';
  if (percentage >= 50) return 'C-';
  if (percentage >= 45) return 'D+';
  if (percentage >= 40) return 'D';
  return 'F';
}

/**
 * Get grade description
 * @param {string} grade - Grade letter
 * @returns {string} - Grade description
 */
export function getGradeDescription(grade) {
  const descriptions = {
    'A+': 'Excellent - Outstanding performance',
    'A': 'Excellent - Very good performance',
    'A-': 'Excellent - Good performance',
    'B+': 'Good - Above average performance',
    'B': 'Good - Average performance',
    'B-': 'Good - Below average performance',
    'C+': 'Fair - Above passing performance',
    'C': 'Fair - Average passing performance',
    'C-': 'Fair - Below average passing performance',
    'D+': 'Poor - Just above failing',
    'D': 'Poor - Failing performance',
    'F': 'Fail - Below passing standards'
  };
  
  return descriptions[grade] || 'Unknown grade';
}