"""Candidate interview scoring."""

from app.schemas.candidate_scoring import (BiasFlag,CandidateScoringRequest,CandidateScoringResponse,SkillGapItem,)
from app.schemas.common import JobStatus
from app.services.ai_generate import generate_json


class CandidateScoringService:
    async def evaluate(self, payload: CandidateScoringRequest) -> CandidateScoringResponse:
        system = (
            "Score an interview. Return JSON: {\"confidence_score\":0-1,\"hiring_fit_score\":0-1,"
            "\"hiring_fit_label\",\"behavioral_summary\",\"skill_gaps\":[{\"skill\",\"gap\",\"evidence\"}],"
            "\"bias_flags\":[{\"category\",\"severity\",\"description\",\"recommendation\"}],"
            "\"scorecard\":{}}"
        )
        user = (
            f"Role: {payload.role_title}\nJD: {payload.job_description}\n"
            f"Skills: {payload.required_skills}\nMode: {payload.mode.value}\n"
            f"Transcript turns: {len(payload.transcript)}\nAnswers: {payload.answers}"
        )

        def local() -> dict:
            skills = payload.required_skills or ["communication", "role expertise"]
            return {
                "confidence_score": 0.72,
                "hiring_fit_score": 0.68,
                "hiring_fit_label": "maybe",
                "behavioral_summary": (
                    f"Candidate showed reasonable depth for {payload.role_title}; "
                    "probe consistency on impact metrics."
                ),
                "skill_gaps": [
                    {
                        "skill": s,
                        "required_level": 0.8,
                        "demonstrated_level": 0.55,
                        "gap": 0.25,
                        "evidence": "Limited concrete examples in transcript/answers.",
                    }
                    for s in skills[:5]
                ],
                "bias_flags": [],
                "scorecard": {
                    "technical": 0.7,
                    "communication": 0.75,
                    "problem_solving": 0.65,
                },
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        skill_gaps = [
            SkillGapItem(
                skill=str(g.get("skill", "")),
                required_level=g.get("required_level"),
                demonstrated_level=g.get("demonstrated_level"),
                gap=g.get("gap"),
                evidence=g.get("evidence"),
            )
            for g in (data.get("skill_gaps") or [])
            if isinstance(g, dict)
        ]
        bias_flags = [
            BiasFlag(
                category=str(b.get("category", "general")),
                severity=str(b.get("severity", "low")),
                description=str(b.get("description", "")),
                recommendation=b.get("recommendation"),
            )
            for b in (data.get("bias_flags") or [])
            if isinstance(b, dict)
        ]
        return CandidateScoringResponse(
            correlation_id=payload.correlation_id,
            interview_id=payload.interview_id,
            candidate_id=payload.candidate_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Scored interview via {provider}",
            confidence_score=data.get("confidence_score"),
            hiring_fit_score=data.get("hiring_fit_score"),
            hiring_fit_label=data.get("hiring_fit_label"),
            skill_gaps=skill_gaps,
            bias_flags=bias_flags,
            behavioral_summary=data.get("behavioral_summary"),
            scorecard=data.get("scorecard") or {},
        )