"""
matcher.py
----------
Scores a job posting against a parsed resume profile.
Returns a 0-100 score with detailed breakdown.
"""

import re
import math
import logging
from collections import Counter

logger = logging.getLogger(__name__)

from resume_parser import SKILL_TAXONOMY, TITLE_VARIANTS, CERT_PATTERNS


def _tokenize(text):
    return re.findall(r'[a-z0-9/\.\+\#]+', text.lower())


def _cosine_similarity(vec_a, vec_b):
    common = set(vec_a.keys()) & set(vec_b.keys())
    if not common:
        return 0.0
    dot = sum(vec_a[k] * vec_b[k] for k in common)
    mag_a = math.sqrt(sum(v ** 2 for v in vec_a.values()))
    mag_b = math.sqrt(sum(v ** 2 for v in vec_b.values()))
    if mag_a == 0 or mag_b == 0:
        return 0.0
    return dot / (mag_a * mag_b)


def score_skills(profile, job_text, aspirational_skills=None):
    job_lower = job_text.lower()
    aspirational_skills = [s.lower() for s in (aspirational_skills or [])]

    job_skills = {}
    for skill_name, patterns in SKILL_TAXONOMY.items():
        for pattern in patterns:
            if pattern.lower() in job_lower:
                count = job_lower.count(pattern.lower())
                job_skills[skill_name] = min(count, 5)
                break

    if not job_skills:
        return {"score": 50, "matched": [], "missing": [], "aspirational_hits": []}

    profile_skills = profile.get("skills", {})
    matched = []
    missing = []
    aspirational_hits = []

    for skill in job_skills:
        if skill in profile_skills:
            matched.append(skill)
        elif skill.lower() in aspirational_skills:
            aspirational_hits.append(skill)
            matched.append(skill)
        else:
            missing.append(skill)

    total = len(job_skills)
    effective_matches = len([s for s in matched if s not in aspirational_hits])
    effective_matches += len(aspirational_hits) * 0.5
    score = (effective_matches / total) * 100 if total > 0 else 50

    return {
        "score": min(round(score), 100),
        "matched": matched,
        "missing": missing,
        "aspirational_hits": aspirational_hits,
        "job_requires": list(job_skills.keys()),
    }


def score_title(profile, job_title):
    job_title_lower = job_title.lower().strip()
    profile_titles = [t.lower() for t in profile.get("titles", [])]

    for pt in profile_titles:
        if pt in job_title_lower or job_title_lower in pt:
            return {"score": 100, "reason": f"Direct match: {pt}"}

    job_normalized = set()
    for norm, variants in TITLE_VARIANTS.items():
        if any(v in job_title_lower for v in variants):
            job_normalized.add(norm)

    profile_normalized = set()
    for pt in profile_titles:
        for norm, variants in TITLE_VARIANTS.items():
            if any(v in pt for v in variants):
                profile_normalized.add(norm)

    if job_normalized & profile_normalized:
        return {"score": 95, "reason": f"Normalized match: {job_normalized & profile_normalized}"}

    related_groups = [
        {"network engineer", "network administrator", "infrastructure engineer", "system administrator"},
        {"cloud engineer", "devops engineer", "infrastructure engineer"},
        {"security engineer", "network engineer"},
    ]

    for group in related_groups:
        if (job_normalized & group) and (profile_normalized & group):
            return {"score": 70, "reason": "Related role family"}

    job_words = set(_tokenize(job_title_lower))
    profile_words = set()
    for pt in profile_titles:
        profile_words.update(_tokenize(pt))

    overlap = job_words & profile_words
    if overlap:
        ratio = len(overlap) / max(len(job_words), 1)
        return {"score": round(ratio * 60), "reason": f"Keyword overlap: {overlap}"}

    return {"score": 20, "reason": "No meaningful match"}


def score_experience(profile, job_text):
    profile_years = profile.get("years_experience", 0)
    patterns = [
        r'(\d+)\+?\s*years?\s*(?:of\s+)?(?:experience|exp)',
        r'(\d+)\+?\s*years?\s*(?:in|with|of)',
        r'minimum\s+(\d+)\s*years?',
        r'at\s+least\s+(\d+)\s*years?',
    ]

    required_years = []
    for pattern in patterns:
        matches = re.findall(pattern, job_text.lower())
        required_years.extend(int(m) for m in matches)

    if not required_years:
        return {"score": 70, "reason": "No experience requirement found", "required": None}

    max_required = max(required_years)

    if profile_years >= max_required:
        score = 100
        reason = f"Exceeds requirement ({profile_years} >= {max_required})"
    elif profile_years >= max_required - 1:
        score = 85
        reason = f"Close match ({profile_years} vs {max_required} required)"
    elif profile_years >= max_required * 0.7:
        score = 60
        reason = f"Slightly under ({profile_years} vs {max_required} required)"
    else:
        score = max(20, 100 - (max_required - profile_years) * 15)
        reason = f"Under-qualified ({profile_years} vs {max_required} required)"

    return {"score": round(score), "reason": reason, "required": max_required}


def score_keywords(profile, job_text):
    resume_text = profile.get("full_text", "")
    if not resume_text or not job_text:
        return {"score": 50, "similarity": 0}

    resume_tokens = _tokenize(resume_text)
    job_tokens = _tokenize(job_text)

    stopwords = {
        "the", "a", "an", "and", "or", "but", "in", "on", "at", "to",
        "for", "of", "with", "by", "is", "are", "was", "were", "be",
        "been", "being", "have", "has", "had", "do", "does", "did",
        "will", "would", "could", "should", "may", "might", "shall",
        "can", "this", "that", "these", "those", "it", "its", "we",
        "you", "they", "them", "their", "our", "your", "from", "as",
        "not", "all", "also", "more", "other", "such", "than", "into",
        "about", "over", "between", "through", "during", "before",
        "after", "above", "below", "up", "down", "out", "off", "then",
        "once", "here", "there", "when", "where", "why", "how", "any",
        "both", "each", "few", "most", "some", "no", "nor", "only",
        "own", "same", "so", "very", "just", "if", "while", "work",
        "working", "experience", "including", "ability", "strong",
        "knowledge", "skills", "required", "preferred", "minimum",
        "must", "etc", "ensure", "across", "using", "within",
    }

    resume_tf = Counter(t for t in resume_tokens if t not in stopwords and len(t) > 1)
    job_tf = Counter(t for t in job_tokens if t not in stopwords and len(t) > 1)
    similarity = _cosine_similarity(resume_tf, job_tf)
    score = min(round(similarity * 300), 100)
    return {"score": score, "similarity": round(similarity, 3)}


def score_certifications(profile, job_text):
    job_lower = job_text.lower()
    profile_certs = [c.lower() for c in profile.get("certifications", [])]

    if not profile_certs:
        return {"score": 50, "matched": [], "required": []}

    job_certs = []
    for pattern, cert_name in CERT_PATTERNS:
        if re.search(pattern, job_lower):
            job_certs.append(cert_name)

    if not job_certs:
        return {"score": 75, "matched": [], "required": []}

    matched = [c for c in job_certs if c.lower() in profile_certs]
    score = (len(matched) / len(job_certs)) * 100 if job_certs else 75

    return {"score": round(score), "matched": matched, "required": job_certs}


def score_job(profile, job_title, job_text, weights=None, aspirational_skills=None):
    if weights is None:
        weights = {
            "skills": 0.40,
            "title": 0.25,
            "experience": 0.15,
            "keywords": 0.15,
            "certifications": 0.05,
        }

    skill_result = score_skills(profile, job_text, aspirational_skills)
    title_result = score_title(profile, job_title)
    exp_result = score_experience(profile, job_text)
    kw_result = score_keywords(profile, job_text)
    cert_result = score_certifications(profile, job_text)

    final_score = (
        skill_result["score"] * weights["skills"]
        + title_result["score"] * weights["title"]
        + exp_result["score"] * weights["experience"]
        + kw_result["score"] * weights["keywords"]
        + cert_result["score"] * weights["certifications"]
    )
    final_score = round(final_score)

    if final_score >= 80:
        verdict = "Strong Match"
    elif final_score >= 70:
        verdict = "Good Match"
    elif final_score >= 55:
        verdict = "Weak Match"
    else:
        verdict = "Poor Match"

    return {
        "score": final_score,
        "verdict": verdict,
        "breakdown": {
            "skills": skill_result,
            "title": title_result,
            "experience": exp_result,
            "keywords": kw_result,
            "certifications": cert_result,
        },
        "matched_skills": skill_result.get("matched", []),
        "missing_skills": skill_result.get("missing", []),
    }