// Emotion types enum

export const Emotions = {

  JOY: 'joy',

  TRUST: 'trust',

  FEAR: 'fear',

  SURPRISE: 'surprise',

  SAD: 'sad',

  DISGUST: 'disgust',

  ANGRY: 'angry',

  ANXIETY: 'anxiety'

};

// Valid emotion values for validation

export const VALID_EMOTIONS = Object.values(Emotions);

// Validate emotion type

export function isValidEmotion(emotion) {

  return VALID_EMOTIONS.includes(emotion?.toLowerCase());

}

// Validate intensity value

export function isValidIntensity(intensity) {

  const num = Number(intensity);

  return !isNaN(num) && num >= 1 && num <= 10;

}

// Validate rating value

export function isValidRating(rating) {

  const num = Number(rating);

  return !isNaN(num) && num >= 1 && num <= 10;

}

// Validate level values (stress, anxiety, energy)

export function isValidLevel(level) {

  const num = Number(level);

  return !isNaN(num) && num >= 1 && num <= 10;

}

// Validate mood components array

export function validateMoodComponents(components) {

  if (!Array.isArray(components)) {

    return { valid: false, error: 'Components must be an array' };

  }

  const emotions = new Set();

  for (const component of components) {

    if (!Object.hasOwn(component, 'emotion') || !Object.hasOwn(component, 'intensity')) {

      return { valid: false, error: 'Each component must have emotion and intensity' };

    }

    const emotionLower = component.emotion.toLowerCase();

    if (!isValidEmotion(emotionLower)) {

      return { valid: false, error: `Invalid emotion: ${component.emotion}` };

    }

    if (!isValidIntensity(component.intensity)) {

      return { valid: false, error: `Invalid intensity for ${component.emotion}: must be 1-10` };

    }

    if (emotions.has(emotionLower)) {

      return { valid: false, error: `Duplicate emotion: ${component.emotion}` };

    }

    emotions.add(emotionLower);

  }

  return { valid: true };

}

// Get emotion statistics

export function calculateEmotionStats(moodComponents) {

  const stats = {

    dominant: null,

    average: 0,

    breakdown: {}

  };

  if (!moodComponents || moodComponents.length === 0) {

    return stats;

  }

  let maxIntensity = 0;

  let totalIntensity = 0;

  moodComponents.forEach(component => {

    const intensity = Number(component.intensity);

    totalIntensity += intensity;

    stats.breakdown[component.emotion] = intensity;

    if (intensity > maxIntensity) {

      maxIntensity = intensity;

      stats.dominant = component.emotion;

    }

  });

  stats.average = totalIntensity / moodComponents.length;

  return stats;

}

import { parseISO, isValid, isFuture, isAfter } from 'date-fns';

// Email validation

const isValidEmail = (email: string) => {

  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  return emailRegex.test(email);

}

// Password validation (minimum 6 characters)

const isValidPassword = (password: string) => {

  return password && password.length >= 6;

}

// Date validation

const isValidDate = (dateString: string) => {

  if (!dateString) return false;

  try {

    const date = parseISO(dateString);

    return isValid(date);

  } catch {

    return false;

  }

}

// Check if date is not in the future

const isNotFutureDate = (dateString: string) => {

  if (!dateString) return false;

  try {

    const date = parseISO(dateString);

    return isValid(date) && !isFuture(date);

  } catch {

    return false;

  }

}

// Validate date range

const isValidDateRange = (startDate: string, endDate: string) => {

  if (!startDate || !endDate) return false;

  try {

    const start = parseISO(startDate);

    const end = parseISO(endDate);

    if (!isValid(start) || !isValid(end)) {

      return false;

    }

    return !isAfter(start, end);

  } catch {

    return false;

  }

}

// Sanitize string input

const sanitizeString = (str: string) => {

  if (typeof str !== 'string') return '';

  return str.trim().slice(0, 500); // Limit to 500 chars

}

// Validate required fields

const validateRequiredFields = (data: Record<string, unknown>, fields: string[]) => {

  const missing: string[] = [];

  for (const field of fields) {

    if (data[field] === undefined || data[field] === null || data[field] === '') {

      missing.push(field);

    }

  }

  return {

    valid: missing.length === 0,

    missing

  };

}

// Validate number in range

const isInRange = (value: number, min: number, max: number) => {

  const num = Number(value);

  return !isNaN(num) && num >= min && num <= max;

}

export {

  validateRequiredFields,

  sanitizeString,

  isInRange,

  isValidEmail,

  isValidPassword,

  isValidDateRange,

  isNotFutureDate,

  isValidDate,

};

    expect(log!.regimen.name).toBe('Sertralina')

    expect(log!.regimen.dosage).toBe('50mg')