"""Shared helpers: inclusive JD rewrite + next-question selection.

Interview preview / lock / merge-custom / follow-up-logic helpers were removed
with ephemeral ``/interview-preview/*`` — use ``/interview-workflows`` instead.
Role scenarios live in ``app.services.assessments.scenarios``.
"""

from app.schemas.common import JobStatus
from app.schemas.helpers import (
    JdInclusivityRewriteRequest,
    JdInclusivityRewriteResponse,
    NextQuestionRequest,
    NextQuestionResponse,
)
from app.services.shared.ai_generate import generate_json


class JdInclusivityService:
    async def rewrite(
        self, payload: JdInclusivityRewriteRequest
    ) -> JdInclusivityRewriteResponse:
        system = (
            "Rewrite JD to be inclusive and bias-free. Return JSON: "
            "{\"rewritten_markdown\",\"removed_bias_phrases\":[],\"notes\":[]}"
        )
        user = f"Title: {payload.role_title}\nJD:\n{payload.job_description}"

        def local() -> dict:
            risky = ["young blood", "native speaker", "guys", "rockstar ninja"]
            found = [p for p in risky if p in payload.job_description.lower()]
            text = payload.job_description
            for p in found:
                text = text.replace(p, "skilled professional")
                text = text.replace(p.title(), "Skilled professional")
            return {
                "rewritten_markdown": text,
                "removed_bias_phrases": found,
                "notes": ["Prefer skill/outcome language over demographic proxies"],
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return JdInclusivityRewriteResponse(
            correlation_id=payload.correlation_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Inclusivity rewrite via {provider}",
            original=payload.job_description,
            rewritten_markdown=data.get("rewritten_markdown"),
            removed_bias_phrases=list(data.get("removed_bias_phrases") or []),
            notes=list(data.get("notes") or []),
        )


class NextQuestionService:
    async def choose(self, payload: NextQuestionRequest) -> NextQuestionResponse:
        system = (
            "Pick the best next interview question. Return JSON: "
            "{\"question_id\",\"question_text\",\"rationale\",\"done\":bool}"
        )
        user = (
            f"Role: {payload.role_title}\nJD: {payload.job_description}\n"
            f"Planned: {payload.planned_questions}\nAsked: {payload.asked_question_ids}\n"
            f"Last score: {payload.last_score}\nTranscript: {payload.transcript[-5:]}"
        )

        def local() -> dict:
            remaining = [
                q
                for i, q in enumerate(payload.planned_questions)
                if f"q-{i + 1}" not in payload.asked_question_ids
                and q not in payload.asked_question_ids
            ]
            if not remaining and not payload.planned_questions:
                return {
                    "question_id": "nq-1",
                    "question_text": (
                        f"What recent impact did you deliver as a {payload.role_title}?"
                    ),
                    "rationale": "No planned list — generate adaptive probe",
                    "done": False,
                }
            if not remaining:
                return {
                    "question_id": None,
                    "question_text": None,
                    "rationale": "All planned questions asked",
                    "done": True,
                }
            idx = 0
            if (
                payload.last_score is not None
                and payload.last_score < 0.6
                and len(remaining) > 1
            ):
                idx = 0
            qtext = remaining[idx]
            qid = f"q-{payload.planned_questions.index(qtext) + 1}"
            return {
                "question_id": qid,
                "question_text": qtext,
                "rationale": "Next unanswered planned question",
                "done": False,
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return NextQuestionResponse(
            correlation_id=payload.correlation_id,
            interview_id=payload.interview_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Next question via {provider}",
            question_id=data.get("question_id"),
            question_text=data.get("question_text"),
            rationale=data.get("rationale"),
            done=bool(data.get("done")),
        )
