"""Interview preview & regenerate question."""

from uuid import uuid4

from app.schemas.common import JobStatus
from app.schemas.interview_preview import (
    InterviewPreviewRequest,
    InterviewPreviewResponse,
    RegenerateQuestionRequest,
    RegenerateQuestionResponse,
)
from app.schemas.questions import GeneratedQuestion, QuestionType
from app.services.ai_generate import generate_json
from app.services.questions import _local_questions, _parse_questions


class InterviewPreviewService:
    async def generate(self, payload: InterviewPreviewRequest) -> InterviewPreviewResponse:
        system = (
            "Build a full interview preview pack. Return JSON: "
            "{\"questions\":[...],\"follow_up_logic\":[{\"question_id\",\"if\",\"then\"}]}"
        )
        user = (
            f"Role: {payload.role_title}\nJD:\n{payload.job_description}\n"
            f"Persona: {payload.persona.value}\nCount: {payload.count}\n"
            f"Types: {[t.value for t in payload.question_types]}\n"
            f"Mandatory: {payload.mandatory_topics}\nCustom: {payload.custom_questions}"
        )
        primary = payload.question_types[0] if payload.question_types else QuestionType.SHORT_ANSWER

        def local() -> dict:
            qs = _local_questions(
                count=payload.count,
                qtype=primary,
                difficulty=payload.difficulty,
                topic=payload.role_title,
            )
            for i, custom in enumerate(payload.custom_questions):
                qs.append(
                    {
                        "id": f"custom-{i + 1}",
                        "question_type": "short_answer",
                        "difficulty": payload.difficulty.value,
                        "stem": custom,
                        "options": [],
                        "answer": None,
                        "explanation": "Custom company question",
                        "metadata": {"mandatory": True},
                    }
                )
            logic = [
                {
                    "question_id": qs[0]["id"],
                    "if": "answer_shallow",
                    "then": "ask_follow_up_for_evidence",
                }
            ] if qs else []
            return {"questions": qs, "follow_up_logic": logic}

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        questions = _parse_questions(
            data.get("questions", []), primary, payload.difficulty
        )
        return InterviewPreviewResponse(
            correlation_id=payload.correlation_id,
            preview_id=str(uuid4()),
            role_title=payload.role_title,
            persona=payload.persona,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Interview preview via {provider}",
            questions=questions,
            follow_up_logic=list(data.get("follow_up_logic") or []),
            locked=False,
        )

    async def regenerate_question(
        self, payload: RegenerateQuestionRequest
    ) -> RegenerateQuestionResponse:
        system = (
            "Regenerate one interview question. Return JSON: {\"question\":{...}}"
        )
        user = (
            f"Role: {payload.role_title}\nJD:\n{payload.job_description}\n"
            f"Persona: {payload.persona.value}\nPrevious: {payload.previous_stem}\n"
            f"Type: {payload.question_type.value}\nInstructions: {payload.instructions}"
        )

        def local() -> dict:
            items = _local_questions(
                count=1,
                qtype=payload.question_type,
                difficulty=payload.difficulty,
                topic=payload.role_title,
            )
            if payload.question_id:
                items[0]["id"] = payload.question_id
            return {"question": items[0]}

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        raw = data.get("question") or {}
        parsed = _parse_questions([raw], payload.question_type, payload.difficulty)
        question = parsed[0] if parsed else None
        return RegenerateQuestionResponse(
            correlation_id=payload.correlation_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Question regenerated via {provider}",
            question=question,
        )