"""Hiring-fit prediction service."""

from app.schemas.common import JobStatus
from app.schemas.hiring_fit import HiringFitRequest, HiringFitResponse
from app.schemas.resume_input import has_resume_signal
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 _label_and_pass(score: float) -> tuple[str, bool]:
    if score >= 0.85:
        return "strong_yes", True
    if score >= 0.70:
        return "yes", True
    if score >= 0.50:
        return "maybe", False
    return "no", False


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

    async def predict(self, payload: HiringFitRequest) -> HiringFitResponse:
        resume_text = payload.resume_text
        if has_resume_signal(
            candidate_id=payload.candidate_id,
            resume_text=resume_text,
            resume_structured=payload.resume_structured,
            content_base64=payload.content_base64,
            source_url=payload.source_url,
        ):
            profile = await self._resume_input.process(
                candidate_id=payload.candidate_id,
                resume_text=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,
            )
            resume_text = profile.raw_text or resume_text
            payload = payload.model_copy(
                update={
                    "resume_text": resume_text,
                    "resume_structured": profile.structured
                    or payload.resume_structured,
                }
            )
        system = (
            "Predict hiring fit. Return JSON: {\"hiring_fit_score\":0-1,"
            "\"hiring_fit_label\",\"reasons\":[],\"risks\":[],\"next_step\"}"
        )
        user = (
            f"Candidate: {payload.candidate_id}\nRole: {payload.role_title}\n"
            f"JD: {payload.job_description}\nSkills: {payload.required_skills}\n"
            f"Resume: {payload.resume_text}\nScorecard: {payload.scorecard}\n"
            f"Transcript turns: {len(payload.transcript)}"
        )

        def local() -> dict:
            base = 0.6
            if payload.scorecard:
                vals = [float(v) for v in payload.scorecard.values() if isinstance(v, (int, float))]
                if vals:
                    base = sum(vals) / len(vals)
            if payload.required_skills and payload.resume_text:
                hits = sum(1 for s in payload.required_skills if s.lower() in payload.resume_text.lower())
                base = min(0.95, base + 0.05 * hits)
            label, _ = _label_and_pass(base)
            missing = []
            if not payload.transcript:
                missing.append("No interview transcript provided")
            if not payload.job_description:
                missing.append("Job description missing")
            if payload.required_skills and not payload.resume_text and not payload.scorecard:
                missing.append("Limited skill evidence (no resume/scorecard)")
            return {
                "hiring_fit_score": round(base, 2),
                "hiring_fit_label": label,
                "reasons": ["Profile partially aligns with role requirements"],
                "risks": ["Validate depth with a focused technical follow-up"],
                "next_step": "advance" if base >= 0.70 else "hold_for_follow_up",
                "supporting_evidence": [
                    f"Scorecard/blend score: {round(base, 2)}",
                    f"Required skills considered: {len(payload.required_skills)}",
                ],
                "limitations": [
                    "Standalone prediction without full session aggregation",
                    "AI output is advisory only",
                ],
                "missing_information": missing
                or ["None critical — still requires human review"],
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        score = float(data.get("hiring_fit_score") or 0.5)
        label = data.get("hiring_fit_label") or _label_and_pass(score)[0]
        passed = score >= 0.70
        return HiringFitResponse(
            correlation_id=payload.correlation_id,
            candidate_id=payload.candidate_id,
            role_title=payload.role_title,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=(
                f"Hiring-fit prediction via {provider} — "
                "requires human review before any hiring decision"
            ),
            hiring_fit_score=score,
            hiring_fit_label=label,
            passed=passed,
            reasons=list(data.get("reasons") or []),
            risks=list(data.get("risks") or []),
            next_step=data.get("next_step"),
            supporting_evidence=list(data.get("supporting_evidence") or data.get("reasons") or []),
            limitations=list(
                data.get("limitations")
                or ["AI recommendation only — verify with human reviewers"]
            ),
            missing_information=list(data.get("missing_information") or []),
            requires_human_review=True,
        )
