"""Voice transcription — OpenAI gpt-4o-mini-transcribe by default."""

from __future__ import annotations

import base64

import httpx

from app.config import get_settings, get_transcription_model
from app.schemas.common import JobStatus
from app.schemas.transcription import (
    TranscriptionProvider,
    TranscriptionRequest,
    TranscriptionResponse,
    TranscriptSegment,
)
from app.services.voice import VoiceProviderError, get_stt_provider


def _response_provider(name: str, *, stub: bool) -> TranscriptionProvider:
    if stub or name == "stub":
        return TranscriptionProvider.STUB
    if name == "whisper":
        return TranscriptionProvider.WHISPER
    return TranscriptionProvider.OPENAI


def _resolve_provider_name(requested: TranscriptionProvider) -> str:
    """Honor the request provider; fall back to settings only if unspecified."""
    if requested == TranscriptionProvider.STUB:
        return "stub"
    if requested == TranscriptionProvider.WHISPER:
        return "whisper"  # legacy alias → same OpenAI client
    if requested == TranscriptionProvider.OPENAI:
        return "openai"
    settings = get_settings()
    return (settings.transcription_provider or "openai").lower()


class TranscriptionService:
    async def transcribe(self, payload: TranscriptionRequest) -> TranscriptionResponse:
        requested = payload.provider
        provider_name = _resolve_provider_name(requested)
        opts = dict(payload.options or {})
        # Prefer explicit per-request model (video intel may force whisper-1 for segments)
        model = str(
            opts.get("transcription_model")
            or opts.get("model")
            or get_transcription_model()
        ).strip()
        if bool(opts.get("require_segments")) and not model.lower().startswith("whisper"):
            model = str(opts.get("segment_model") or "whisper-1").strip()
        audio_bytes: bytes | None = None
        if payload.audio_base64:
            try:
                audio_bytes = base64.b64decode(payload.audio_base64)
            except Exception:
                audio_bytes = None

        if not audio_bytes and payload.source_url:
            try:
                async with httpx.AsyncClient(timeout=60.0, follow_redirects=True) as client:
                    dl = await client.get(payload.source_url)
                    dl.raise_for_status()
                    audio_bytes = dl.content
            except Exception as exc:  # noqa: BLE001
                return TranscriptionResponse(
                    correlation_id=payload.correlation_id,
                    interview_id=payload.interview_id,
                    provider=requested,
                    model=model,
                    status=JobStatus.FAILED,
                    stub=True,
                    message=f"Failed to fetch audio: {exc}",
                    text=None,
                    segments=[],
                    error_code="source_fetch_failed",
                )

        if not audio_bytes:
            return TranscriptionResponse(
                correlation_id=payload.correlation_id,
                interview_id=payload.interview_id,
                provider=requested,
                model=model,
                status=JobStatus.FAILED,
                stub=True,
                message="Empty or invalid audio",
                text=None,
                segments=[],
                error_code="invalid_audio",
            )

        # Ensure STT sees the resolved model / require_segments flags
        opts.setdefault("transcription_model", model)
        stt = get_stt_provider(provider_name)
        try:
            result = await stt.transcribe(
                audio_bytes=audio_bytes,
                language=payload.language,
                mime_type=str(opts.get("mime_type") or "audio/wav"),
                options=opts,
            )
        except VoiceProviderError as exc:
            return TranscriptionResponse(
                correlation_id=payload.correlation_id,
                interview_id=payload.interview_id,
                provider=_response_provider(provider_name, stub=True),
                model=model,
                status=JobStatus.FAILED,
                stub=True,
                message=str(exc),
                text=None,
                segments=[],
                error_code=exc.code or "stt_provider_failed",
            )

        return TranscriptionResponse(
            correlation_id=payload.correlation_id,
            interview_id=payload.interview_id,
            provider=_response_provider(result.provider, stub=result.stub),
            model=None if result.stub else model,
            status=JobStatus.SUCCEEDED,
            stub=result.stub,
            message=result.message,
            text=result.text,
            segments=[
                TranscriptSegment(
                    start_ms=int(s.get("start_ms", 0)),
                    end_ms=int(s.get("end_ms", 0)),
                    speaker=s.get("speaker"),
                    text=str(s.get("text", "")),
                    confidence=s.get("confidence"),
                )
                for s in result.segments
            ],
            error_code=None,
        )
