import {
  SKILL_LEVEL_VALUES,
  CategoryEvaluation,
  RadarChartData,
  SkillCategory,
  SkillImportance,
} from "./types";

export function calculateCategoryScore(
  categoryEvaluation: CategoryEvaluation
): number {
  if (categoryEvaluation.skills.length === 0) return 0;

  const evaluatedSkills = categoryEvaluation.skills.filter(
    (skill) => skill.level !== null
  );
  if (evaluatedSkills.length === 0) return 0;

  const totalScore = evaluatedSkills.reduce((sum, skill) => {
    return sum + SKILL_LEVEL_VALUES[skill.level!];
  }, 0);

  return totalScore / evaluatedSkills.length;
}

export function generateRadarData(
  evaluations: CategoryEvaluation[],
  categories: SkillCategory[]
): RadarChartData[] {
  const maxScore = 3; // Expert level

  return categories.map((category) => {
    const evaluation = evaluations.find(
      (e) => e.category === category.category
    );
    const score = evaluation ? calculateCategoryScore(evaluation) : 0;

    return {
      category: category.category,
      score: Math.round(score * 10) / 10, // Round to 1 decimal
      maxScore,
    };
  });
}

export function createEmptyEvaluation(
  categories: SkillCategory[]
): CategoryEvaluation[] {
  return categories.map((category) => ({
    category: category.category,
    skills: [],
    selectedSkillIds: [],
  }));
}

export const COVERAGE_OBJECTIVES: Record<SkillImportance, number> = {
  incontournable: 75,
  majeure: 60,
  standard: 0,
};

export function isCoverageBelowObjective(
  coverage: number,
  importance: SkillImportance
): boolean {
  const objective = COVERAGE_OBJECTIVES[importance];
  return objective > 0 && coverage < objective;
}

export function getCoverageObjective(importance: SkillImportance): number {
  return COVERAGE_OBJECTIVES[importance];
}

export function calculateSkillCoverage(
  levels: number[],
  totalMembers: number
): number {
  if (levels.length === 0 || totalMembers === 0) return 0;

  // Compter le nombre de membres autonomes ou experts (niveau >= 2)
  const expertCount = levels.filter((level) => level >= 2).length;

  // La couverture est le pourcentage de membres autonomes ou experts
  return (expertCount / totalMembers) * 100;
}

export function generateSkillCoverageSQL(levelField: string): string {
  return `
    COALESCE(
      (COUNT(*) FILTER (WHERE ${levelField} >= 2) * 100.0) / NULLIF(COUNT(*), 0),
      0
    )
  `;
}

export function isExpertLevel(level: number): boolean {
  return level >= 2;
}