"""Librosa audio analysis — service-level (HTTP /communication-analysis disabled)."""

from __future__ import annotations

import asyncio
import base64
import concurrent.futures
from pathlib import Path

import pytest
from fastapi.testclient import TestClient

from app.config import get_settings
from app.main import app
from app.schemas.audio_analysis import AudioAnalysisRequest
from app.schemas.common import JobStatus
from app.services.audio.analysis import AudioAnalysisService
from app.services.audio.preprocess import AudioPreprocessError, preprocess_audio_bytes
from tests.audio_fixtures import (
    clipped_wav,
    corrupt_bytes,
    noisy_wav,
    short_wav,
    silence_wav,
    tone_bursts_wav,
)

client = TestClient(app)
HEADERS = {"X-Internal-Token": get_settings().internal_api_token}
_svc = AudioAnalysisService()


def _b64(data: bytes) -> str:
    return base64.b64encode(data).decode("ascii")


def _analyze_svc(**kwargs):
    body = {
        "interview_id": kwargs.pop("interview_id", "audio-1"),
        "audio_base64": kwargs.pop("audio_base64", None),
        "run_transcription": False,
        **kwargs,
    }
    if body.get("audio_base64") is None and not body.get("source_url"):
        raise AssertionError("test helper needs audio")
    if body.get("source_url"):
        body.pop("audio_base64", None)
    return asyncio.run(_svc.analyze(AudioAnalysisRequest(**body)))


def test_valid_speech_like_recording() -> None:
    audio = tone_bursts_wav(duration_s=2.5)
    body = _analyze_svc(
        audio_base64=_b64(audio),
        transcript_text="I designed FastAPI services with Redis caching and PostgreSQL.",
    )
    assert body.status == JobStatus.SUCCEEDED
    assert body.audio_duration_seconds is not None
    assert body.audio_duration_seconds >= 2.0
    assert body.speech_duration_seconds is not None
    assert body.silence_duration_seconds is not None
    assert body.pause_count is not None
    assert body.pause_count >= 1
    assert body.words_per_minute is not None
    assert body.words_per_minute > 0
    assert body.transcript_used is True
    assert body.transcription_status == "succeeded"
    assert body.rms_energy_mean is not None
    assert body.audio_quality is not None
    assert any(
        "not emotion" in x.lower() or "suitability" in x.lower() for x in body.limitations
    )
    assert body.features


def test_silence_only() -> None:
    body = _analyze_svc(audio_base64=_b64(silence_wav(duration_s=1.2)))
    assert body.status == JobStatus.SUCCEEDED
    assert body.speech_duration_seconds is not None
    assert body.speech_duration_seconds < 0.4
    assert body.silence_percentage is not None
    assert body.silence_percentage > 50
    assert body.words_per_minute is None
    assert body.transcription_status == "skipped"


def test_clipped_audio_flags_quality() -> None:
    body = _analyze_svc(audio_base64=_b64(clipped_wav()))
    assert body.status == JobStatus.SUCCEEDED
    assert body.audio_quality.clipping_detected is True
    assert body.audio_quality.quality_warnings


def test_noisy_audio() -> None:
    body = _analyze_svc(audio_base64=_b64(noisy_wav(duration_s=1.2)))
    assert body.status == JobStatus.SUCCEEDED
    assert body.pitch_available in {True, False}
    if not body.pitch_available:
        assert body.pitch_median_hz is None


def test_very_short_recording_rejected() -> None:
    body = _analyze_svc(audio_base64=_b64(short_wav()))
    assert body.status == JobStatus.FAILED
    assert body.error_code == "audio_too_short"


def test_corrupted_audio_rejected() -> None:
    body = _analyze_svc(audio_base64=_b64(corrupt_bytes()))
    assert body.status == JobStatus.FAILED
    assert body.error_code in {
        "corrupt_or_unsupported",
        "invalid_audio",
        "audio_preprocess_error",
    }


def test_missing_transcription_wpm_null() -> None:
    body = _analyze_svc(
        audio_base64=_b64(tone_bursts_wav(duration_s=1.5)),
        run_transcription=False,
    )
    assert body.status == JobStatus.SUCCEEDED
    assert body.words_per_minute is None
    assert body.word_count is None
    assert any("transcript" in x.lower() for x in body.limitations)


def test_failed_transcription_does_not_block_metrics(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    async def boom(*_a, **_k):
        raise RuntimeError("STT down")

    monkeypatch.setattr(
        "app.services.audio.analysis.TranscriptionService.transcribe",
        boom,
    )
    body = _analyze_svc(
        audio_base64=_b64(tone_bursts_wav(duration_s=1.5)),
        run_transcription=True,
    )
    assert body.status == JobStatus.SUCCEEDED
    assert body.transcription_status == "failed"
    assert body.rms_energy_mean is not None
    assert body.words_per_minute is None


def test_empty_transcript_string_skips_wpm() -> None:
    body = _analyze_svc(
        audio_base64=_b64(tone_bursts_wav(duration_s=1.2)),
        transcript_text="   ",
    )
    assert body.words_per_minute is None


def test_require_exactly_one_source() -> None:
    with pytest.raises(Exception):
        AudioAnalysisRequest(interview_id="x")


def test_temp_file_cleanup() -> None:
    audio = tone_bursts_wav(duration_s=0.8)
    pre = preprocess_audio_bytes(audio, mime_type="audio/wav")
    work = pre.work_dir
    assert work.exists()
    assert pre.wav_path.exists()
    pre.cleanup()
    assert not work.exists()


def test_preprocess_corrupt_raises() -> None:
    with pytest.raises(AudioPreprocessError) as ei:
        preprocess_audio_bytes(corrupt_bytes())
    assert ei.value.code == "corrupt_or_unsupported"


def test_concurrent_analyze_and_cleanup() -> None:
    def once(i: int):
        body = _analyze_svc(
            interview_id=f"concurrent-{i}",
            audio_base64=_b64(tone_bursts_wav(duration_s=1.0)),
            transcript_text="hello world from concurrent test",
        )
        return body.status

    with concurrent.futures.ThreadPoolExecutor(max_workers=4) as pool:
        results = list(pool.map(once, range(6)))
    assert all(st == JobStatus.SUCCEEDED for st in results)

    tmp = Path("/tmp")
    leftovers = list(tmp.glob("tj_audio_*")) if tmp.exists() else []
    assert len(leftovers) < 20


def test_legacy_audio_route_removed() -> None:
    res = client.post(
        "/api/v1/audio-analysis/analyze",
        headers=HEADERS,
        json={"audio_base64": _b64(tone_bursts_wav(duration_s=1.0))},
    )
    assert res.status_code == 404


def test_transcription_endpoint_unchanged() -> None:
    from app.services.voice.wav_util import build_silent_wav

    res = client.post(
        "/api/v1/transcription",
        headers=HEADERS,
        json={
            "interview_id": "tr-1",
            "provider": "stub",
            "audio_base64": _b64(build_silent_wav()),
        },
    )
    assert res.status_code == 200
    assert "text" in res.json()
