"""
HireSense AI — Learning Ability Predictor
Estimates how quickly a candidate can learn missing skills.
"""

from backend.services.skill_dictionary import get_skill_category, SKILL_CATEGORIES


class LearningPredictor:
    """Predicts learning ability based on skill graph and activity patterns."""

    def predict(
        self,
        candidate_skills: list[str],
        missing_skills: list[str],
        github_data: dict = None,
        leetcode_data: dict = None,
    ) -> dict:
        """
        Predict learning ability and time-to-learn for missing skills.
        """
        if not missing_skills:
            return {
                "learning_score": 95.0,
                "predictions": [],
                "factors": {
                    "base_score": 50,
                    "skill_breadth_bonus": 20,
                    "consistency_bonus": 15,
                    "problem_solving_bonus": 10,
                },
                "explanation": "Candidate already has all required skills. Excellent readiness.",
            }

        # Per-skill predictions
        predictions = []
        for skill in missing_skills:
            pred = self._estimate_learning_time(skill, candidate_skills)
            predictions.append(pred)

        # Calculate factor bonuses
        factors = self._calculate_factors(candidate_skills, github_data, leetcode_data)

        # Overall learning score
        learning_score = self._calculate_learning_score(predictions, factors)

        explanation = self._generate_explanation(learning_score, predictions, factors)

        return {
            "learning_score": round(learning_score, 1),
            "predictions": predictions,
            "factors": factors,
            "explanation": explanation,
        }

    def _estimate_learning_time(self, skill: str, existing_skills: list[str]) -> dict:
        """Estimate learning time for a specific skill."""
        target_category = get_skill_category(skill)

        # Count existing skills in the same category
        related = [s for s in existing_skills if get_skill_category(s) == target_category]

        if len(related) >= 3:
            months = 1.5
            confidence = "high"
            reason = (
                f"Already proficient in {len(related)} skills in '{target_category}' "
                f"({', '.join(related[:3])}). Transfer learning will be fast."
            )
        elif len(related) >= 1:
            months = 3.0
            confidence = "medium"
            reason = (
                f"Has {len(related)} related skill(s) in '{target_category}' "
                f"({', '.join(related)}). Foundation exists to build upon."
            )
        else:
            # Check cross-category transfers
            unique_categories = set(get_skill_category(s) for s in existing_skills)
            if len(unique_categories) >= 4:
                months = 4.0
                confidence = "medium"
                reason = (
                    f"No direct '{target_category}' experience, but has skills across "
                    f"{len(unique_categories)} categories — demonstrated versatility suggests adaptability."
                )
            else:
                months = 6.0
                confidence = "low"
                reason = (
                    f"No experience in '{target_category}' and limited breadth. "
                    f"Will require structured learning and mentorship."
                )

        return {
            "skill": skill,
            "estimated_months": months,
            "confidence": confidence,
            "reason": reason,
            "related_existing": related[:5],
        }

    def _calculate_factors(
        self,
        candidate_skills: list[str],
        github_data: dict = None,
        leetcode_data: dict = None,
    ) -> dict:
        """Calculate bonus factors for learning score."""
        # Skill breadth bonus
        unique_categories = set(get_skill_category(s) for s in candidate_skills)
        skill_breadth_bonus = min(20, len(unique_categories) * 4)

        # GitHub consistency bonus
        consistency_bonus = 0
        if github_data:
            gh_scores = github_data.get("scores", {})
            consistency = gh_scores.get("consistency", 0)
            if consistency >= 70:
                consistency_bonus = 15
            elif consistency >= 40:
                consistency_bonus = 8

        # LeetCode problem-solving bonus
        problem_solving_bonus = 0
        if leetcode_data:
            lc_scores = leetcode_data.get("scores", {})
            lc_overall = lc_scores.get("overall", 0)
            if lc_overall >= 70:
                problem_solving_bonus = 15
            elif lc_overall >= 40:
                problem_solving_bonus = 8

        return {
            "base_score": 50,
            "skill_breadth_bonus": skill_breadth_bonus,
            "consistency_bonus": consistency_bonus,
            "problem_solving_bonus": problem_solving_bonus,
        }

    def _calculate_learning_score(self, predictions: list, factors: dict) -> float:
        """Calculate the overall learning ability score."""
        score = factors["base_score"]
        score += factors["skill_breadth_bonus"]
        score += factors["consistency_bonus"]
        score += factors["problem_solving_bonus"]

        # Penalty for hard-to-learn skills
        for pred in predictions:
            if pred["estimated_months"] > 4:
                score -= 5
            elif pred["estimated_months"] > 2:
                score -= 2

        return max(0, min(100, score))

    def _generate_explanation(
        self, score: float, predictions: list, factors: dict
    ) -> str:
        """Generate human-readable learning ability explanation."""
        if score >= 80:
            verdict = "High learning potential"
        elif score >= 60:
            verdict = "Good learning potential"
        elif score >= 40:
            verdict = "Moderate learning potential"
        else:
            verdict = "Learning may be challenging"

        fast = [p for p in predictions if p["estimated_months"] <= 2]
        slow = [p for p in predictions if p["estimated_months"] > 4]

        parts = [f"{verdict} ({score:.0f}/100)."]

        if fast:
            parts.append(
                f"Can quickly pick up: {', '.join(p['skill'] for p in fast)}."
            )
        if slow:
            parts.append(
                f"Will need more time for: {', '.join(p['skill'] for p in slow)}."
            )

        bonuses = []
        if factors["consistency_bonus"] > 0:
            bonuses.append("consistent GitHub activity")
        if factors["problem_solving_bonus"] > 0:
            bonuses.append("strong problem-solving skills")
        if factors["skill_breadth_bonus"] >= 16:
            bonuses.append("diverse skill set")

        if bonuses:
            parts.append(f"Positive signals: {', '.join(bonuses)}.")

        return " ".join(parts)