"""AI job matching / recommendations.

(DB → Platform → JobCatalogItem):
  Platform owns the marketplace job DB. It queries available roles, builds
  ``job_catalog``, and calls this service. We rank that catalog against the
  candidate profile (ResumeService). We do **not** read Platform DB or invent
  placeholder jobs when the catalog is empty (empty catalog is rejected at
  the schema layer).
"""

from __future__ import annotations

from app.schemas.common import JobStatus
from app.schemas.job_matching import (
    JobCatalogItem,
    JobMatchItem,
    JobMatchingRequest,
    JobMatchingResponse,
)
from app.services.screening.resume_input import ResumeInputProcessor
from app.services.screening.resume_service import ResumeService
from app.services.shared.ai_generate import generate_json


def _job_skills(job: JobCatalogItem) -> list[str]:
    seen: set[str] = set()
    out: list[str] = []
    for s in list(job.skills or []) + list(job.required_skills or []):
        t = str(s).strip()
        if t and t.lower() not in seen:
            seen.add(t.lower())
            out.append(t)
    return out


def _catalog_for_prompt(catalog: list[JobCatalogItem], *, limit: int) -> list[dict]:
    rows: list[dict] = []
    for job in catalog[:limit]:
        rows.append(
            {
                "job_id": job.job_id,
                "title": job.title,
                "description": job.description,
                "skills": _job_skills(job),
                "location": job.location,
                "seniority": job.seniority,
                "department": job.department,
            }
        )
    return rows


class JobMatchingService:
    def __init__(
        self,
        *,
        resumes: ResumeService | None = None,
        resume_input: ResumeInputProcessor | None = None,
    ) -> None:
        self._resume_input = resume_input or ResumeInputProcessor(resumes=resumes)

    async def recommend(self, payload: JobMatchingRequest) -> JobMatchingResponse:
        profile = await self._resume_input.process(
            candidate_id=payload.candidate_id,
            resume_text=payload.resume_text,
            resume_structured=payload.resume_structured,
            content_base64=payload.content_base64,
            source_url=payload.source_url,
            document_type=payload.document_type,
            filename=payload.filename,
            language=payload.language,
            persist=bool(payload.candidate_id),
            require_resume=False,
        )
        skills = list(payload.skills or [])
        if not skills:
            skills = [
                str(s)
                for s in (profile.structured.get("skills") or [])
                if str(s).strip()
            ]
        resume_blob = profile.raw_text or payload.resume_text or payload.resume_structured
        catalog = list(payload.job_catalog)
        catalog_slice = _catalog_for_prompt(catalog, limit=payload.limit)

        system = (
            "Rank ONLY the jobs in Catalog for this candidate. Do not invent job_ids "
            "or titles that are not in Catalog. Return JSON: {\"recommendations\":"
            "[{\"job_id\",\"title\",\"match_score\",\"reasons\":[],\"skill_overlap\":[],\"gaps\":[]}]}"
        )
        user = (
            f"Candidate: {payload.candidate_id}\nSkills: {skills}\n"
            f"Experience years: {payload.experience_years}\nInterests: {payload.interests}\n"
            f"Goals: {payload.career_goals}\nResume: {resume_blob}\n"
            f"Catalog (from Platform job DB): {catalog_slice}\nLimit: {payload.limit}"
        )

        allowed_ids = {j["job_id"] for j in catalog_slice}

        def local() -> dict:
            recs = []
            for job in catalog[: payload.limit]:
                job_skills = _job_skills(job)
                overlap = [s for s in skills if any(s.lower() == js.lower() for js in job_skills)]
                if not overlap and skills:
                    overlap = skills[:2]
                score = min(0.95, 0.55 + 0.08 * len(overlap)) if skills or job_skills else 0.5
                recs.append(
                    {
                        "job_id": job.job_id,
                        "title": job.title,
                        "match_score": round(score, 2),
                        "reasons": [
                            "Skill overlap with candidate profile",
                            "Aligned with stated interests/goals"
                            if payload.interests or payload.career_goals
                            else "Role title proximity",
                        ],
                        "skill_overlap": overlap,
                        "gaps": [s for s in job_skills if s not in skills][:5],
                    }
                )
            return {"recommendations": recs}

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        recommendations = [
            JobMatchItem(
                job_id=str(r.get("job_id", "")),
                title=r.get("title"),
                match_score=r.get("match_score"),
                reasons=list(r.get("reasons") or []),
                skill_overlap=list(r.get("skill_overlap") or []),
                gaps=list(r.get("gaps") or []),
            )
            for r in (data.get("recommendations") or [])
            if isinstance(r, dict)
            and r.get("job_id")
            and str(r.get("job_id")) in allowed_ids
        ]
        # Preserve catalog order if LLM dropped items; fill from local ranks
        if len(recommendations) < len(catalog_slice):
            have = {r.job_id for r in recommendations}
            local_recs = local()["recommendations"]
            for r in local_recs:
                if r["job_id"] not in have and r["job_id"] in allowed_ids:
                    recommendations.append(JobMatchItem(**r))
                    have.add(r["job_id"])

        msg = (
            f"Job matching via {provider} "
            f"(Platform catalog size={len(catalog)}, ranked={len(recommendations)})"
        )
        if profile.reused:
            msg += f" (resume profile v{profile.resume_version} reused)"
        return JobMatchingResponse(
            correlation_id=payload.correlation_id,
            candidate_id=payload.candidate_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=msg,
            recommendations=recommendations[: payload.limit],
            catalog_size=len(catalog),
        )
