"""OpenAI audio transcription STT — default model: gpt-4o-mini-transcribe."""

from __future__ import annotations

from typing import Any

import httpx

from app.config import get_transcription_model, get_settings
from app.services.voice.base import STTProvider, STTResult, VoiceProviderError
from app.services.voice.wav_util import is_plausible_audio


def _response_format_for_model(model: str) -> str:
    """gpt-4o-* / *-transcribe use json; classic whisper-1 supports verbose_json."""
    m = (model or "").lower()
    if m.startswith("whisper"):
        return "verbose_json"
    if m.startswith("gpt-4o") or "transcribe" in m:
        return "json"
    return "json"


def _model_supports_segments(model: str) -> bool:
    return (model or "").lower().startswith("whisper")


def _parse_segments(body: dict[str, Any]) -> list[dict[str, Any]]:
    """Extract timed segments from verbose_json (segments or words)."""
    segments: list[dict[str, Any]] = []
    for seg in (body.get("segments") or [])[:200]:
        if not isinstance(seg, dict):
            continue
        text = str(seg.get("text", "")).strip()
        if not text:
            continue
        segments.append(
            {
                "start_ms": int(float(seg.get("start", 0)) * 1000),
                "end_ms": int(float(seg.get("end", 0)) * 1000),
                "text": text,
                "confidence": seg.get("avg_logprob"),
                "speaker": None,
            }
        )
    if segments:
        return segments

    # Coalesce word-level timestamps into short phrase segments
    words = body.get("words") or []
    if not isinstance(words, list) or not words:
        return []
    bucket: list[dict[str, Any]] = []
    bucket_start: float | None = None
    bucket_end: float = 0.0
    out: list[dict[str, Any]] = []

    def flush() -> None:
        nonlocal bucket, bucket_start, bucket_end
        if not bucket or bucket_start is None:
            return
        text = " ".join(str(w.get("word", "")).strip() for w in bucket).strip()
        if text:
            out.append(
                {
                    "start_ms": int(bucket_start * 1000),
                    "end_ms": int(bucket_end * 1000),
                    "text": text,
                    "confidence": None,
                    "speaker": None,
                }
            )
        bucket = []
        bucket_start = None

    for w in words[:2000]:
        if not isinstance(w, dict):
            continue
        try:
            start = float(w.get("start", 0))
            end = float(w.get("end", start))
        except (TypeError, ValueError):
            continue
        if bucket_start is None:
            bucket_start = start
        bucket.append(w)
        bucket_end = end
        # ~2s or punctuation-ish break
        if end - bucket_start >= 2.0 or len(bucket) >= 12:
            flush()
    flush()
    return out[:200]


class OpenAISTTProvider(STTProvider):
    """OpenAI /v1/audio/transcriptions (gpt-4o-mini-transcribe by default)."""

    name = "openai"

    async def transcribe(
        self,
        *,
        audio_bytes: bytes,
        language: str = "en",
        mime_type: str = "audio/wav",
        options: dict[str, Any] | None = None,
    ) -> STTResult:
        if not is_plausible_audio(audio_bytes):
            raise VoiceProviderError(
                "Empty or invalid audio for STT",
                code="invalid_audio",
            )

        settings = get_settings()
        api_key = (settings.openai_api_key or "").strip()
        if not api_key:
            raise VoiceProviderError(
                "OPENAI_API_KEY not configured for transcription STT",
                code="stt_not_configured",
            )

        opts = options or {}
        # Allow per-request override (video intel uses whisper-1 for timed segments)
        model = str(
            opts.get("transcription_model")
            or opts.get("model")
            or get_transcription_model()
        ).strip()
        require_segments = bool(opts.get("require_segments"))
        if require_segments and not _model_supports_segments(model):
            model = str(opts.get("segment_model") or "whisper-1").strip()

        filename = "audio.webm" if "webm" in (mime_type or "") else "audio.wav"
        content_type = mime_type or "audio/wav"
        response_format = _response_format_for_model(model)

        # httpx AsyncClient: put ALL multipart fields in `files` (bytes, not BytesIO).
        # Mixing `files=` + list-form `data=` triggers:
        # "Attempted to send an sync request with an AsyncClient instance."
        multipart: list[tuple[str, Any]] = [
            ("file", (filename, audio_bytes, content_type)),
            ("model", (None, model)),
            ("response_format", (None, response_format)),
        ]
        if language:
            multipart.append(("language", (None, language)))
        if response_format == "verbose_json":
            multipart.append(("timestamp_granularities[]", (None, "segment")))

        try:
            async with httpx.AsyncClient(timeout=120.0) as client:
                res = await client.post(
                    "https://api.openai.com/v1/audio/transcriptions",
                    headers={"Authorization": f"Bearer {api_key}"},
                    files=multipart,
                )
                if res.status_code >= 400:
                    raise VoiceProviderError(
                        f"Transcription HTTP {res.status_code}: {res.text[:300]}",
                        code="stt_provider_failed",
                    )
                if response_format == "text":
                    body: dict[str, Any] = {"text": (res.text or "").strip()}
                else:
                    body = res.json()
        except VoiceProviderError:
            raise
        except Exception as exc:  # noqa: BLE001
            raise VoiceProviderError(
                f"Transcription STT failed: {exc}",
                code="stt_provider_failed",
            ) from exc

        text = (body.get("text") or "").strip()
        if not text:
            raise VoiceProviderError(
                f"{model} returned empty transcript",
                code="empty_transcript",
            )

        segments = _parse_segments(body)
        return STTResult(
            text=text,
            provider=self.name,
            stub=False,
            language=language,
            segments=segments,
            message=f"Transcribed via OpenAI {model}",
        )


# Backward-compatible alias
WhisperSTTProvider = OpenAISTTProvider


class StubSTTProvider(STTProvider):
    """Deterministic local STT for tests / offline mode."""

    name = "stub"

    def __init__(self, fixed_text: str = "[stub transcript]") -> None:
        self.fixed_text = fixed_text

    async def transcribe(
        self,
        *,
        audio_bytes: bytes,
        language: str = "en",
        mime_type: str = "audio/wav",
        options: dict[str, Any] | None = None,
    ) -> STTResult:
        if not audio_bytes:
            raise VoiceProviderError(
                "Empty or invalid audio for STT",
                code="invalid_audio",
            )
        override = (options or {}).get("stub_transcript")
        text = str(override).strip() if override else self.fixed_text
        raw_segments = (options or {}).get("stub_segments")
        segments: list[dict[str, Any]] = []
        if isinstance(raw_segments, list):
            segments = [s for s in raw_segments if isinstance(s, dict)]
        elif text:
            # Default single segment so alignment tests can run offline
            segments = [
                {
                    "start_ms": 0,
                    "end_ms": 2000,
                    "text": text,
                    "confidence": None,
                    "speaker": None,
                }
            ]
        return STTResult(
            text=text,
            provider=self.name,
            stub=True,
            language=language,
            message="Local STT stub",
            segments=segments,
        )
