skillMapping.ts

import { TeamMember } from '../types';

export interface SkillDistribution {
  skill: string;
  count: number;
  members: string[];
}

export interface RoleAssignment {
  role: string;
  member: TeamMember;
  confidence: number;
}

const roleKeywords: Record<string, string[]> = {
  'Frontend': ['frontend', 'react', 'vue', 'angular', 'html', 'css', 'ui', 'ux', 'design'],
  'Backend': ['backend', 'node', 'python', 'java', 'api', 'server', 'database', 'sql'],
  'AI/ML': ['ai', 'ml', 'machine learning', 'data science', 'tensorflow', 'pytorch'],
  'DevOps': ['devops', 'docker', 'kubernetes', 'ci/cd', 'aws', 'cloud', 'deployment'],
  'Mobile': ['mobile', 'ios', 'android', 'react native', 'flutter', 'swift', 'kotlin'],
  'Design': ['design', 'figma', 'sketch', 'ui/ux', 'graphic', 'adobe'],
  'Documentation': ['documentation', 'writing', 'technical writer', 'docs']
};

export const analyzeSkills = (members: TeamMember[]): SkillDistribution[] => {
  const skillMap = new Map<string, { count: number; members: string[] }>();

  members.forEach(member => {
    member.skillset.forEach(skill => {
      const normalized = skill.toLowerCase().trim();
      if (!skillMap.has(normalized)) {
        skillMap.set(normalized, { count: 0, members: [] });
      }
      const data = skillMap.get(normalized)!;
      data.count++;
      data.members.push(member.name);
    });
  });

  return Array.from(skillMap.entries())
    .map(([skill, data]) => ({
      skill,
      count: data.count,
      members: data.members
    }))
    .sort((a, b) => b.count - a.count);
};

export const suggestRoles = (members: TeamMember[]): RoleAssignment[] => {
  const assignments: RoleAssignment[] = [];
  const assignedMembers = new Set<string>();

  const roles = Object.keys(roleKeywords);

  roles.forEach(role => {
    let bestMatch: { member: TeamMember; score: number } | null = null;

    members.forEach(member => {
      if (assignedMembers.has(member.id)) return;

      const keywords = roleKeywords[role];
      let score = 0;

      member.skillset.forEach(skill => {
        const normalized = skill.toLowerCase();
        keywords.forEach(keyword => {
          if (normalized.includes(keyword)) {
            score += 1;
          }
        });
      });

      if (score > 0 && (!bestMatch || score > bestMatch.score)) {
        bestMatch = { member, score };
      }
    });

    if (bestMatch) {
      assignedMembers.add(bestMatch.member.id);
      assignments.push({
        role,
        member: bestMatch.member,
        confidence: Math.min(bestMatch.score * 20, 95)
      });
    }
  });

  members.forEach(member => {
    if (!assignedMembers.has(member.id)) {
      assignments.push({
        role: 'General Development',
        member,
        confidence: 60
      });
    }
  });

  return assignments;
};

export const getSkillCategories = (skills: SkillDistribution[]): Record<string, number> => {
  const categories: Record<string, number> = {
    'Frontend': 0,
    'Backend': 0,
    'AI/ML': 0,
    'Design': 0,
    'Other': 0
  };

  skills.forEach(({ skill, count }) => {
    const normalized = skill.toLowerCase();
    let categorized = false;

    if (roleKeywords['Frontend'].some(kw => normalized.includes(kw))) {
      categories['Frontend'] += count;
      categorized = true;
    }
    if (roleKeywords['Backend'].some(kw => normalized.includes(kw))) {
      categories['Backend'] += count;
      categorized = true;
    }
    if (roleKeywords['AI/ML'].some(kw => normalized.includes(kw))) {
      categories['AI/ML'] += count;
      categorized = true;
    }
    if (roleKeywords['Design'].some(kw => normalized.includes(kw))) {
      categories['Design'] += count;
      categorized = true;
    }
    if (!categorized) {
      categories['Other'] += count;
    }
  });

  return categories;
};