"""Custom persona, scorecards, interview summarize, DEI analytics."""

from uuid import uuid4

from app.schemas.common import JobStatus
from app.schemas.extra import (
    CustomPersonaRequest,
    CustomPersonaResponse,
    DeiAnalyticsRequest,
    DeiAnalyticsResponse,
    InterviewSummarizeRequest,
    InterviewSummarizeResponse,
    ScorecardCriterion,
    ScorecardGenerateRequest,
    ScorecardGenerateResponse,
)
from app.services.ai_generate import generate_json


class CustomPersonaService:
    async def create(self, payload: CustomPersonaRequest) -> CustomPersonaResponse:
        system = (
            "Build a custom interviewer persona. Return JSON: "
            "{\"system_prompt\",\"style_summary\"}"
        )
        user = (
            f"Company: {payload.company_id}\nName: {payload.name}\n"
            f"Style: {payload.interview_style}\nValues: {payload.company_values}\n"
            f"Samples: {payload.sample_questions}\nCriteria: {payload.evaluation_criteria}\n"
            f"Tone: {payload.tone_notes}"
        )

        def local() -> dict:
            values = ", ".join(payload.company_values) or "company standards"
            return {
                "system_prompt": (
                    f"You are `{payload.name}`, a custom interviewer for company "
                    f"{payload.company_id}. Emphasize {values}. "
                    f"Style: {payload.interview_style or 'structured and fair'}."
                ),
                "style_summary": (
                    f"Custom persona `{payload.name}` aligned to company values and "
                    "role-specific evaluation criteria."
                ),
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return CustomPersonaResponse(
            correlation_id=payload.correlation_id,
            company_id=payload.company_id,
            persona_id=str(uuid4()),
            name=payload.name,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Custom persona via {provider}",
            system_prompt=data.get("system_prompt"),
            style_summary=data.get("style_summary"),
        )


class ScorecardsService:
    async def generate(
        self, payload: ScorecardGenerateRequest
    ) -> ScorecardGenerateResponse:
        system = (
            "Create an interview scorecard. Return JSON: "
            "{\"criteria\":[{\"id\",\"name\",\"weight\",\"description\"}]}"
        )
        user = (
            f"Role: {payload.role_title}\nJD: {payload.job_description}\n"
            f"Persona: {payload.persona}\nHints: {payload.criteria_hints}"
        )

        def local() -> dict:
            base = payload.criteria_hints or [
                "technical_depth",
                "problem_solving",
                "communication",
                "role_fit",
            ]
            weight = round(1.0 / len(base), 2)
            return {
                "criteria": [
                    {
                        "id": f"c-{i + 1}",
                        "name": name.replace("_", " ").title(),
                        "weight": weight,
                        "description": f"Evaluate {name.replace('_', ' ')} for {payload.role_title}",
                    }
                    for i, name in enumerate(base)
                ]
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        criteria = [
            ScorecardCriterion(
                id=str(c.get("id", f"c-{i}")),
                name=str(c.get("name", "Criterion")),
                weight=float(c.get("weight") or 1.0),
                description=c.get("description"),
            )
            for i, c in enumerate(data.get("criteria") or [])
            if isinstance(c, dict)
        ]
        return ScorecardGenerateResponse(
            correlation_id=payload.correlation_id,
            role_title=payload.role_title,
            scorecard_id=str(uuid4()),
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Scorecard generated via {provider}",
            criteria=criteria,
        )


class InterviewSummarizeService:
    async def summarize(
        self, payload: InterviewSummarizeRequest
    ) -> InterviewSummarizeResponse:
        system = (
            "Summarize a completed interview. Return JSON: "
            "{\"summary_markdown\",\"key_takeaways\":[],\"recommendation\"}"
        )
        user = (
            f"Interview: {payload.interview_id}\nRole: {payload.role_title}\n"
            f"Scorecard: {payload.scorecard}\nTranscript: {payload.transcript}"
        )

        def local() -> dict:
            return {
                "summary_markdown": (
                    f"## Interview summary — {payload.role_title}\n\n"
                    f"Session `{payload.interview_id}` completed. "
                    "Candidate showed relevant experience with room for deeper evidence."
                ),
                "key_takeaways": [
                    "Relevant domain experience",
                    "Needs stronger quantified outcomes",
                ],
                "recommendation": "advance_or_hold",
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return InterviewSummarizeResponse(
            correlation_id=payload.correlation_id,
            interview_id=payload.interview_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Interview summary via {provider}",
            summary_markdown=data.get("summary_markdown"),
            key_takeaways=list(data.get("key_takeaways") or []),
            recommendation=data.get("recommendation"),
        )


class DeiAnalyticsService:
    async def analyze(self, payload: DeiAnalyticsRequest) -> DeiAnalyticsResponse:
        system = (
            "Produce DEI / fairness insights from anonymized eval data. Return JSON: "
            "{\"fairness_score\":0-1,\"insights\":[],\"risks\":[],\"recommendations\":[]}"
        )
        user = f"Role: {payload.role_title}\nDataset size: {len(payload.dataset)}\nSample: {payload.dataset[:20]}"

        def local() -> dict:
            n = len(payload.dataset)
            return {
                "fairness_score": 0.78 if n else 0.5,
                "insights": [
                    "Score distribution appears broadly consistent across provided rows",
                    f"Analyzed {n} anonymized evaluation records",
                ],
                "risks": [
                    "Small sample may hide subgroup gaps" if n < 30 else "Monitor score variance by source"
                ],
                "recommendations": [
                    "Keep questions skill-based",
                    "Run bias-detection on new templates before publish",
                ],
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return DeiAnalyticsResponse(
            correlation_id=payload.correlation_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"DEI analytics via {provider}",
            fairness_score=data.get("fairness_score"),
            insights=list(data.get("insights") or []),
            risks=list(data.get("risks") or []),
            recommendations=list(data.get("recommendations") or []),
        )