/**
 * Interview Scoring Service
 * 
 * Rule-based smart scoring for interview performance.
 * Uses heuristics instead of heavy ML for fast execution.
 * 
 * Scores:
 * - Speech Clarity (filler words, pauses, speed)
 * - Confidence (answer length, hesitation)
 * - Eye Contact (simulated from webcam availability)
 * - Technical Depth (keyword density, structure)
 */

// ===========================================
// FILLER WORDS DATABASE
// ===========================================

const FILLER_WORDS = [
    'um', 'uh', 'er', 'ah', 'like', 'you know', 'basically',
    'actually', 'literally', 'honestly', 'right', 'so yeah',
    'kind of', 'sort of', 'i mean', 'well', 'okay so',
];

const HEDGING_WORDS = [
    'maybe', 'perhaps', 'probably', 'might', 'could be',
    'i think', 'i guess', 'i believe', 'i suppose',
    'not sure', 'possibly', 'somewhat',
];

const TECHNICAL_KEYWORDS = [
    // Programming
    'algorithm', 'data structure', 'complexity', 'optimization',
    'scalability', 'performance', 'architecture', 'design pattern',
    'microservices', 'api', 'database', 'cache', 'queue',
    // Concepts
    'trade-off', 'approach', 'solution', 'implementation',
    'refactor', 'debug', 'testing', 'deployment', 'monitoring',
    // Methods
    'agile', 'scrum', 'sprint', 'iteration', 'review',
];

const STAR_METHOD_INDICATORS = [
    'situation', 'task', 'action', 'result',
    'challenge', 'approach', 'outcome', 'learned',
    'responsibility', 'achieved', 'improved', 'delivered',
];

// ===========================================
// SCORING FUNCTIONS
// ===========================================

/**
 * Calculate speech clarity score (0-100)
 * Based on filler words, sentence structure, and word count
 */
export function calculateClarityScore(answer) {
    if (!answer || answer.trim().length === 0) return 0;

    const text = answer.toLowerCase();
    const words = text.split(/\s+/).filter(w => w.length > 0);
    const wordCount = words.length;

    if (wordCount < 5) return 20; // Too short

    // Count filler words
    let fillerCount = 0;
    FILLER_WORDS.forEach(filler => {
        const regex = new RegExp(`\\b${filler}\\b`, 'gi');
        const matches = text.match(regex);
        if (matches) fillerCount += matches.length;
    });

    // Filler ratio (lower is better)
    const fillerRatio = fillerCount / wordCount;
    const fillerPenalty = Math.min(40, fillerRatio * 200);

    // Sentence count and average length
    const sentences = answer.split(/[.!?]+/).filter(s => s.trim().length > 0);
    const avgSentenceLength = wordCount / Math.max(1, sentences.length);

    // Ideal sentence length is 15-25 words
    let structurePenalty = 0;
    if (avgSentenceLength < 8) structurePenalty = 15;
    else if (avgSentenceLength > 35) structurePenalty = 20;

    // Word length variety (indicates vocabulary)
    const avgWordLength = words.reduce((sum, w) => sum + w.length, 0) / wordCount;
    const vocabularyBonus = avgWordLength > 5 ? 10 : 0;

    // Calculate final score
    let score = 100 - fillerPenalty - structurePenalty + vocabularyBonus;

    // Clamp to 0-100
    return Math.max(0, Math.min(100, Math.round(score)));
}

/**
 * Calculate confidence score (0-100)
 * Based on hedging words, answer length, and assertive language
 */
export function calculateConfidenceScore(answer) {
    if (!answer || answer.trim().length === 0) return 0;

    const text = answer.toLowerCase();
    const words = text.split(/\s+/).filter(w => w.length > 0);
    const wordCount = words.length;

    if (wordCount < 5) return 15; // Very short = low confidence

    // Count hedging words
    let hedgingCount = 0;
    HEDGING_WORDS.forEach(hedge => {
        const regex = new RegExp(`\\b${hedge}\\b`, 'gi');
        const matches = text.match(regex);
        if (matches) hedgingCount += matches.length;
    });

    // Hedging ratio (lower is better)
    const hedgingRatio = hedgingCount / wordCount;
    const hedgingPenalty = Math.min(35, hedgingRatio * 250);

    // Answer length bonus (longer = more confident, up to a point)
    let lengthBonus = 0;
    if (wordCount >= 30) lengthBonus = 10;
    if (wordCount >= 60) lengthBonus = 15;
    if (wordCount >= 100) lengthBonus = 20;

    // Assertive language detection
    const assertivePatterns = [
        /\bi (did|led|managed|created|built|designed|implemented)\b/gi,
        /\bmy (approach|solution|responsibility)\b/gi,
        /\bsuccessfully\b/gi,
        /\bachieved\b/gi,
        /\bdelivered\b/gi,
    ];

    let assertiveBonus = 0;
    assertivePatterns.forEach(pattern => {
        if (pattern.test(text)) assertiveBonus += 5;
    });
    assertiveBonus = Math.min(20, assertiveBonus);

    // Calculate final score
    let score = 70 - hedgingPenalty + lengthBonus + assertiveBonus;

    // Clamp to 0-100
    return Math.max(0, Math.min(100, Math.round(score)));
}

/**
 * Calculate technical depth score (0-100)
 * Based on technical keywords and structured responses
 */
export function calculateTechnicalScore(answer) {
    if (!answer || answer.trim().length === 0) return 0;

    const text = answer.toLowerCase();
    const words = text.split(/\s+/).filter(w => w.length > 0);
    const wordCount = words.length;

    if (wordCount < 10) return 10;

    // Count technical keywords
    let technicalCount = 0;
    TECHNICAL_KEYWORDS.forEach(keyword => {
        const regex = new RegExp(`\\b${keyword}\\b`, 'gi');
        const matches = text.match(regex);
        if (matches) technicalCount += matches.length;
    });

    // Technical density bonus
    const technicalRatio = technicalCount / wordCount;
    const technicalBonus = Math.min(30, technicalRatio * 500);

    // STAR method indicators
    let starCount = 0;
    STAR_METHOD_INDICATORS.forEach(indicator => {
        if (text.includes(indicator)) starCount++;
    });
    const starBonus = Math.min(20, starCount * 5);

    // Specific example detection
    const hasExample = /for example|such as|instance|specifically|when i/gi.test(text);
    const exampleBonus = hasExample ? 15 : 0;

    // Numbers and metrics (shows quantifiable experience)
    const hasNumbers = /\d+/.test(answer);
    const metricsBonus = hasNumbers ? 10 : 0;

    // Base score from length
    let baseScore = 40;
    if (wordCount >= 50) baseScore = 50;
    if (wordCount >= 80) baseScore = 55;

    // Calculate final score
    let score = baseScore + technicalBonus + starBonus + exampleBonus + metricsBonus;

    // Clamp to 0-100
    return Math.max(0, Math.min(100, Math.round(score)));
}

/**
 * Calculate eye contact score (0-100)
 * Simulated based on webcam availability and face detection
 */
export function calculateEyeContactScore(stats) {
    const {
        totalDuration = 0,      // Total interview duration in seconds
        cameraActiveTime = 0,   // Time camera was on
        faceDetectedTime = 0,   // Time face was detected
        lookAwayCount = 0,      // Times user looked away
    } = stats;

    if (totalDuration === 0) return 50; // Default if no data

    // Camera usage ratio
    const cameraRatio = cameraActiveTime / totalDuration;
    const cameraScore = cameraRatio * 40; // Max 40 points

    // Face detection ratio
    const faceRatio = cameraActiveTime > 0
        ? faceDetectedTime / cameraActiveTime
        : 0;
    const faceScore = faceRatio * 40; // Max 40 points

    // Look away penalty (normalized per minute)
    const durationMinutes = totalDuration / 60;
    const lookAwayPerMinute = lookAwayCount / Math.max(1, durationMinutes);
    const lookAwayPenalty = Math.min(20, lookAwayPerMinute * 4);

    // Calculate final score
    let score = cameraScore + faceScore + 20 - lookAwayPenalty;

    // Clamp to 0-100
    return Math.max(0, Math.min(100, Math.round(score)));
}

/**
 * Calculate overall interview score from components
 */
export function calculateOverallScore(scores) {
    const {
        clarity = 50,
        confidence = 50,
        technical = 50,
        eyeContact = 50,
    } = scores;

    // Weighted average
    const overall = (
        clarity * 0.25 +
        confidence * 0.30 +
        technical * 0.30 +
        eyeContact * 0.15
    );

    return Math.round(overall);
}

/**
 * Get score grade and label
 */
export function getScoreGrade(score) {
    if (score >= 90) return { grade: 'A+', label: 'Exceptional', color: '#10b981' };
    if (score >= 85) return { grade: 'A', label: 'Excellent', color: '#10b981' };
    if (score >= 80) return { grade: 'B+', label: 'Very Good', color: '#22c55e' };
    if (score >= 75) return { grade: 'B', label: 'Good', color: '#84cc16' };
    if (score >= 70) return { grade: 'C+', label: 'Above Average', color: '#eab308' };
    if (score >= 65) return { grade: 'C', label: 'Average', color: '#f59e0b' };
    if (score >= 60) return { grade: 'D', label: 'Below Average', color: '#f97316' };
    return { grade: 'F', label: 'Needs Improvement', color: '#ef4444' };
}

/**
 * Generate score breakdown for analytics
 */
export function generateScoreBreakdown(answers = []) {
    if (answers.length === 0) {
        return {
            clarity: 50,
            confidence: 50,
            technical: 50,
            eyeContact: 50,
            overall: 50,
            details: [],
        };
    }

    // Calculate scores for each answer
    const details = answers.map((answer, index) => ({
        questionIndex: index + 1,
        clarity: calculateClarityScore(answer.text),
        confidence: calculateConfidenceScore(answer.text),
        technical: calculateTechnicalScore(answer.text),
        wordCount: (answer.text || '').split(/\s+/).filter(w => w).length,
        responseTime: answer.responseTime || 0,
    }));

    // Calculate averages
    const avgClarity = details.reduce((sum, d) => sum + d.clarity, 0) / details.length;
    const avgConfidence = details.reduce((sum, d) => sum + d.confidence, 0) / details.length;
    const avgTechnical = details.reduce((sum, d) => sum + d.technical, 0) / details.length;

    return {
        clarity: Math.round(avgClarity),
        confidence: Math.round(avgConfidence),
        technical: Math.round(avgTechnical),
        eyeContact: 50, // Default, updated by eye tracking
        overall: calculateOverallScore({
            clarity: avgClarity,
            confidence: avgConfidence,
            technical: avgTechnical,
            eyeContact: 50,
        }),
        details,
    };
}

// ===========================================
// INTERVIEW MODE SYSTEM - 4 MODES ONLY
// ===========================================

/**
 * The ONLY 4 interview modes available.
 * This is the single source of truth for modes.
 */
export const INTERVIEW_MODES = {
    friendly: {
        id: 'friendly',
        name: 'Friendly Practice',
        icon: '😊',
        description: 'Relaxed practice with helpful feedback - perfect for beginners',
        tier: 'free',
        color: '#10b981', // Green
        config: {
            strictness: 0.3,
            technicalWeight: 0.30,
            behavioralWeight: 0.40,
            communicationWeight: 0.30,
            followUpDepth: 'light',
            scoringThreshold: 50,
            hasVideo: false,
            hasVerdict: false,
            hasRag: false,
            usesLLM: false,
        },
    },
    balanced: {
        id: 'balanced',
        name: 'Balanced Interview',
        icon: '⚖️',
        description: 'Standard interview experience with video recording',
        tier: 'paid_entry',
        color: '#3b82f6', // Blue
        config: {
            strictness: 0.6,
            technicalWeight: 0.35,
            behavioralWeight: 0.35,
            communicationWeight: 0.30,
            followUpDepth: 'moderate',
            scoringThreshold: 65,
            hasVideo: true,
            hasVerdict: false,
            hasRag: false,
            usesLLM: true,
        },
    },
    strict: {
        id: 'strict',
        name: 'Strict Interview',
        icon: '🎯',
        description: 'Rigorous evaluation with behavior analysis and verdicts',
        tier: 'paid_advanced',
        color: '#f59e0b', // Orange
        config: {
            strictness: 0.8,
            technicalWeight: 0.40,
            behavioralWeight: 0.30,
            communicationWeight: 0.30,
            followUpDepth: 'deep',
            scoringThreshold: 75,
            hasVideo: true,
            hasVerdict: true,
            hasRag: true,
            usesLLM: true,
        },
    },
    final_boss: {
        id: 'final_boss',
        name: 'Final Boss Challenge',
        icon: '👹',
        description: 'Maximum difficulty with industry persona - no mercy',
        tier: 'premium',
        color: '#ef4444', // Red
        config: {
            strictness: 1.0,
            technicalWeight: 0.45,
            behavioralWeight: 0.25,
            communicationWeight: 0.30,
            followUpDepth: 'deep',
            scoringThreshold: 85,
            hasVideo: true,
            hasVerdict: true,
            hasRag: true,
            usesLLM: true,
            hasPersonalitySelection: true, // ONLY this mode has personality sub-selection
            hasRoadmap: true, // Career roadmap generation after interview
        },
    },
};

/**
 * Final Boss mode personality options.
 * These are ONLY available when mode = 'final_boss'.
 */
export const FINAL_BOSS_PERSONALITIES = {
    faang_engineer: {
        id: 'faang_engineer',
        name: 'FAANG Engineer',
        icon: '🏢',
        description: 'Google/Meta-level senior engineer with deep technical focus',
    },
    startup_founder: {
        id: 'startup_founder',
        name: 'Startup Founder',
        icon: '🚀',
        description: 'YC-backed founder who values speed and ownership',
    },
    senior_staff: {
        id: 'senior_staff',
        name: 'Senior Staff Engineer',
        icon: '⚙️',
        description: 'Principal-level architect with 15+ years experience',
    },
    hr_director: {
        id: 'hr_director',
        name: 'HR Director',
        icon: '👔',
        description: 'Fortune 500 HR leader focused on culture and leadership',
    },
    hiring_manager: {
        id: 'hiring_manager',
        name: 'Hiring Manager',
        icon: '📋',
        description: 'Experienced team lead making final hiring decisions',
    },
};

export function getInterviewMode(modeId) {
    return INTERVIEW_MODES[modeId] || INTERVIEW_MODES.friendly;
}

export function getInterviewModeList() {
    return Object.values(INTERVIEW_MODES);
}

export function getFinalBossPersonality(personalityId) {
    return FINAL_BOSS_PERSONALITIES[personalityId] || FINAL_BOSS_PERSONALITIES.faang_engineer;
}

export function getFinalBossPersonalityList() {
    return Object.values(FINAL_BOSS_PERSONALITIES);
}

/**
 * Check if personality selection is allowed for a mode.
 * ONLY final_boss mode allows personality selection.
 */
export function modeAllowsPersonality(modeId) {
    return modeId === 'final_boss';
}

// ===========================================
// LEGACY COMPATIBILITY - DEPRECATE SOON
// ===========================================

/** @deprecated Use INTERVIEW_MODES instead */
export const COMPANY_MODES = INTERVIEW_MODES;

/** @deprecated Use getInterviewMode instead */
export function getCompanyMode(modeId) {
    return getInterviewMode(modeId);
}

/** @deprecated Use getInterviewModeList instead */
export function getCompanyModeList() {
    return getInterviewModeList();
}