"""Dedicated confidence scoring — linguistic + optional acoustic indicators."""

from __future__ import annotations

from app.schemas.common import JobStatus
from app.schemas.confidence_scoring import (
    ConfidenceScoringRequest,
    ConfidenceScoringResponse,
)
from app.services.shared.ai_generate import generate_json
from app.services.audio.voice_scoring import score_voice_analysis


class ConfidenceScoringService:
    async def evaluate(
        self, payload: ConfidenceScoringRequest
    ) -> ConfidenceScoringResponse:
        # Prefer deterministic voice-analysis indicators when features/transcript exist
        turns = list(payload.transcript or [])
        features = dict(payload.audio_features or {})
        has_signal = bool(turns) or bool(features)

        if has_signal:
            scored = score_voice_analysis(
                features=features,
                transcript_turns=turns,
            )
            ci = scored["confidence_indicators"]
            cues = list(ci.get("linguistic_cues") or []) + list(
                ci.get("acoustic_cues") or []
            )
            return ConfidenceScoringResponse(
                correlation_id=payload.correlation_id,
                interview_id=payload.interview_id,
                status=JobStatus.SUCCEEDED,
                stub=False,
                message="Confidence indicators from speech/transcript cues",
                confidence_score=ci.get("score"),
                certainty_band=ci.get("band"),
                cues=cues[:8],
                summary=(
                    f"{scored.get('summary')} "
                    f"Note: {ci.get('note')}"
                ),
            )

        system = (
            "Score interview confidence indicators from transcript only. "
            "Return JSON: "
            '{"confidence_score":0-1,"certainty_band","cues":[],"summary"}. '
            "Do not claim personality or hiring suitability."
        )
        user = (
            f"Interview: {payload.interview_id}\nMode: {payload.mode.value}\n"
            f"Transcript: {payload.transcript}\nAudio: {payload.audio_features}"
        )

        def local() -> dict:
            n = len(payload.transcript)
            score = 0.45 if n < 1 else 0.55 if n < 2 else 0.68 if n < 6 else 0.78
            band = "low" if score < 0.6 else "medium" if score < 0.8 else "high"
            return {
                "confidence_score": score,
                "certainty_band": band,
                "cues": ["limited transcript context"],
                "summary": (
                    f"Estimated certainty band `{band}` from turn count only "
                    f"for interview {payload.interview_id}."
                ),
            }

        data, stub, provider = await generate_json(
            system=system, user=user, local_factory=local
        )
        return ConfidenceScoringResponse(
            correlation_id=payload.correlation_id,
            interview_id=payload.interview_id,
            status=JobStatus.SUCCEEDED,
            stub=stub,
            message=f"Confidence scoring via {provider}",
            confidence_score=data.get("confidence_score"),
            certainty_band=data.get("certainty_band"),
            cues=list(data.get("cues") or []),
            summary=data.get("summary"),
        )
