Succession Planning — Integration

// In src/cores/hr/succession/utils/readinessScore.ts

import { supabase } from '@/integrations/supabase/client';

/**
 * Calculate skills score for readiness assessment.
 * Integrates with HR-13 Skills Matrix data.
 */
async function calculateSkillsScore(
  employeeId: string,
  positionId: string,
  organizationId: string
): Promise<number> {
  // Get position requirements from HR-13
  const { data: requirements } = await supabase
    .from('hr_position_skill_requirements')
    .select('skill_id, minimum_proficiency')
    .eq('position_id', positionId)
    .eq('organization_id', organizationId);

  // Get employee skills from HR-13
  const { data: skills } = await supabase
    .from('hr_employee_skills')
    .select('skill_id, proficiency_level, verification_status')
    .eq('employee_id', employeeId)
    .eq('organization_id', organizationId);

  // Calculate match score
  return calculateSkillMatchScore(requirements ?? [], skills ?? []);
}

// Proficiency level numeric mapping
const PROFICIENCY_SCORE_MAP: Record<string, number> = {
  'expert': 100,
  'advanced': 75,
  'intermediate': 50,
  'beginner': 25,
  'none': 0,
};

// Performance rating numeric mapping
const PERFORMANCE_SCORE_MAP: Record<string, number> = {
  'exceeds_expectations': 100,
  'meets_expectations': 75,
  'below_expectations': 25,
  'not_rated': 0,
};

/**
 * Calculate combined readiness score (0-100).
 *
 * @param performanceRating - Latest performance rating from HR-10
 * @param employeeSkills - Employee skill proficiency levels from HR-13
 * @param positionRequirements - Target position skill requirements from HR-13
 * @param performanceWeight - Weight for performance (from hr_module_settings)
 * @param skillsWeight - Weight for skills (from hr_module_settings)
 */
function calculateReadinessScore(
  performanceRating: string | null,
  employeeSkills: Array<{ skill_id: string; proficiency_level: string }>,
  positionRequirements: Array<{ skill_id: string; minimum_proficiency: string }>,
  performanceWeight: number = 50,
  skillsWeight: number = 50
): number {
  // Calculate performance score
  const performanceScore = PERFORMANCE_SCORE_MAP[performanceRating ?? 'not_rated'] ?? 0;
  
  // Calculate skills score (average of matched skill proficiencies)
  let skillsScore = 0;
  if (positionRequirements.length > 0 && employeeSkills.length > 0) {
    const skillMap = new Map(employeeSkills.map(s => [s.skill_id, s.proficiency_level]));
    let totalScore = 0;
    let matchedCount = 0;
    
    for (const req of positionRequirements) {
      const employeeProficiency = skillMap.get(req.skill_id);
      if (employeeProficiency) {
        totalScore += PROFICIENCY_SCORE_MAP[employeeProficiency] ?? 0;
        matchedCount++;
      }
    }
    
    skillsScore = matchedCount > 0 ? totalScore / matchedCount : 0;
  }
  
  // Weighted combination
  return (performanceScore * performanceWeight + skillsScore * skillsWeight) / 100;
}