"""Librosa acoustics + speech patterns / delivery / confidence indicators."""

from __future__ import annotations

import asyncio
import base64
import logging

import httpx

from app.config import get_settings
from app.schemas.audio_analysis import (
    AudioAnalysisRequest,
    AudioAnalysisResponse,
    AudioQualityInfo,
    ConfidenceIndicators,
    DeliveryScore,
    PauseStats,
    SpeechPatterns,
)
from app.schemas.common import JobStatus
from app.schemas.transcription import TranscriptionProvider, TranscriptionRequest
from app.services.audio.features import extract_audio_features
from app.services.audio.preprocess import AudioPreprocessError, preprocess_audio_bytes
from app.services.voice.transcription import TranscriptionService
from app.services.audio.voice_scoring import score_voice_analysis

logger = logging.getLogger(__name__)


def _feature_map_for_scoring(features, *, clipping: bool) -> dict:
    d = features.to_features_dict()
    d.update(
        {
            "audio_duration_seconds": features.audio_duration_seconds,
            "speech_duration_seconds": features.speech_duration_seconds,
            "silence_percentage": features.silence_percentage,
            "pause_count": features.pause_count,
            "long_pause_count": features.long_pause_count,
            "words_per_minute": features.words_per_minute,
            "word_count": features.word_count,
            "pitch_median_hz": features.pitch_median_hz,
            "pitch_range_hz": features.pitch_range_hz,
            "pitch_std_hz": features.pitch_std_hz,
            "pitch_available": features.pitch_available,
            "rms_energy_mean": features.rms_energy_mean,
            "rms_energy_std": features.rms_energy_std,
            "clipping_detected": clipping,
        }
    )
    return d


class AudioAnalysisService:
    def __init__(self) -> None:
        self._transcription = TranscriptionService()

    async def analyze(self, payload: AudioAnalysisRequest) -> AudioAnalysisResponse:
        settings = get_settings()
        audio_bytes, fetch_err = await self._load_bytes(payload)
        if fetch_err or not audio_bytes:
            return AudioAnalysisResponse(
                correlation_id=payload.correlation_id,
                interview_id=payload.interview_id,
                status=JobStatus.FAILED,
                stub=False,
                message=fetch_err or "Empty or invalid audio",
                error_code="invalid_audio",
                limitations=["Audio could not be loaded for analysis"],
                transcription_status="not_requested",
            )

        transcript = (payload.transcript_text or "").strip() or None
        transcription_status = "skipped"
        if transcript is not None:
            transcription_status = "succeeded"
        elif payload.run_transcription:
            transcript, transcription_status = await self._maybe_transcribe(
                payload, audio_bytes
            )

        preprocessed = None
        try:
            preprocessed = await asyncio.to_thread(
                preprocess_audio_bytes,
                audio_bytes,
                mime_type=payload.audio_mime_type,
            )
        except AudioPreprocessError as exc:
            logger.info(
                "Audio preprocess failed interview_id=%s code=%s",
                payload.interview_id,
                exc.code,
            )
            return AudioAnalysisResponse(
                correlation_id=payload.correlation_id,
                interview_id=payload.interview_id,
                status=JobStatus.FAILED,
                stub=False,
                message=str(exc),
                error_code=exc.code,
                limitations=[str(exc)],
                transcript_used=transcript is not None,
                transcription_status=transcription_status,
            )

        preprocess_warnings = list(preprocessed.warnings)
        try:
            features = await asyncio.to_thread(
                extract_audio_features,
                preprocessed.wav_path,
                sample_rate=preprocessed.sample_rate,
                transcript_text=transcript,
            )
        except Exception as exc:  # noqa: BLE001
            logger.exception("Librosa feature extraction failed")
            return AudioAnalysisResponse(
                correlation_id=payload.correlation_id,
                interview_id=payload.interview_id,
                status=JobStatus.FAILED,
                stub=False,
                message=f"Feature extraction failed: {type(exc).__name__}",
                error_code="feature_extraction_failed",
                limitations=["Acoustic feature extraction raised an unexpected error"],
                transcript_used=transcript is not None,
                transcription_status=transcription_status,
            )
        finally:
            preprocessed.cleanup()

        feat_map = _feature_map_for_scoring(
            features, clipping=features.clipping_detected
        )
        scored = score_voice_analysis(
            features=feat_map,
            transcript_text=transcript,
        )

        limitations = list(features.limitations) + list(scored.get("limitations") or [])
        # de-dupe limitations preserving order
        seen: set[str] = set()
        uniq_lim: list[str] = []
        for item in limitations:
            if item not in seen:
                seen.add(item)
                uniq_lim.append(item)

        quality_warnings = list(features.quality_warnings) + preprocess_warnings
        compact = features.to_features_dict()
        compact["overall_delivery_score"] = scored.get("overall_score")
        compact["confidence_band"] = (scored.get("confidence_indicators") or {}).get(
            "band"
        )

        return AudioAnalysisResponse(
            correlation_id=payload.correlation_id,
            interview_id=payload.interview_id,
            status=JobStatus.SUCCEEDED,
            stub=False,
            message=(
                "Audio analysis completed (Librosa acoustics + speech patterns, "
                "delivery, confidence indicators)"
            ),
            audio_duration_seconds=features.audio_duration_seconds,
            sample_rate=features.sample_rate,
            speech_duration_seconds=features.speech_duration_seconds,
            silence_duration_seconds=features.silence_duration_seconds,
            silence_percentage=features.silence_percentage,
            pause_count=features.pause_count,
            pause_stats=PauseStats(
                pause_count=features.pause_count,
                long_pause_count=features.long_pause_count,
                pause_durations_seconds=features.pause_durations_seconds,
                long_pause_threshold_ms=float(settings.audio_long_pause_ms),
            ),
            words_per_minute=features.words_per_minute,
            word_count=features.word_count,
            pitch_median_hz=features.pitch_median_hz,
            pitch_range_hz=features.pitch_range_hz,
            pitch_std_hz=features.pitch_std_hz,
            pitch_available=features.pitch_available,
            zero_crossing_rate_mean=features.zero_crossing_rate_mean,
            spectral_centroid_mean_hz=features.spectral_centroid_mean_hz,
            rms_energy_mean=features.rms_energy_mean,
            rms_energy_std=features.rms_energy_std,
            audio_quality=AudioQualityInfo(
                clipping_detected=features.clipping_detected,
                clipping_ratio=features.clipping_ratio,
                snr_estimate_db=features.snr_estimate_db,
                quality_warnings=quality_warnings,
            ),
            overall_delivery_score=scored.get("overall_score"),
            speech_patterns=SpeechPatterns(**scored["speech_patterns"]),
            delivery=DeliveryScore(**scored["delivery"]),
            confidence_indicators=ConfidenceIndicators(
                **scored["confidence_indicators"]
            ),
            strengths=list(scored.get("strengths") or []),
            improvement_areas=list(scored.get("improvement_areas") or []),
            summary=scored.get("summary"),
            transcript_used=transcript is not None,
            transcription_status=transcription_status,
            features=compact,
            limitations=uniq_lim,
        )

    async def _load_bytes(
        self, payload: AudioAnalysisRequest
    ) -> tuple[bytes | None, str | None]:
        if payload.audio_base64:
            try:
                return base64.b64decode(payload.audio_base64), None
            except Exception:  # noqa: BLE001
                return None, "Invalid audio_base64 encoding"

        if payload.source_url:
            try:
                async with httpx.AsyncClient(
                    timeout=60.0, follow_redirects=True
                ) as client:
                    res = await client.get(payload.source_url)
                    res.raise_for_status()
                    return res.content, None
            except Exception as exc:  # noqa: BLE001
                return None, f"Failed to fetch audio: {exc}"

        return None, "No audio source provided"

    async def _maybe_transcribe(
        self, payload: AudioAnalysisRequest, audio_bytes: bytes
    ) -> tuple[str | None, str]:
        try:
            b64 = base64.b64encode(audio_bytes).decode("ascii")
            tr = await self._transcription.transcribe(
                TranscriptionRequest(
                    interview_id=payload.interview_id,
                    provider=TranscriptionProvider.OPENAI,
                    audio_base64=b64,
                    language=payload.language,
                    options={"mime_type": payload.audio_mime_type},
                )
            )
            if tr.status == JobStatus.SUCCEEDED and (tr.text or "").strip():
                return tr.text.strip(), "succeeded"
            logger.info(
                "Optional transcription failed or empty interview_id=%s",
                payload.interview_id,
            )
            return None, "failed"
        except Exception:  # noqa: BLE001
            logger.info(
                "Optional transcription raised interview_id=%s",
                payload.interview_id,
                exc_info=True,
            )
            return None, "failed"
