"""
Lab audio fixtures — the classifier must agree with what each one claims to be.

These guard the *fixtures*, not the classifier. `tests/lab/sounds/generate.py`
synthesises music/speech/silence that the Asterisk lab plays down a real call;
if a fixture drifts into the wrong class, every lab result built on it is
quietly meaningless — a hold-music scenario that never classifies as music
proves nothing about the hold slayer.

The first version of these fixtures passed on the opening 3s window and drifted
to MUSIC after, which a single-window check would not have caught. Hence the
sweep across every window.

Skipped when the fixtures have not been generated: they are gitignored (~680K,
reproducible from a fixed seed), so a fresh checkout has none until
`python tests/lab/sounds/generate.py` runs.
"""

import subprocess
import sys
from pathlib import Path

import numpy as np
import pytest

from config import Settings
from models.call import AudioClassification
from services.audio_classifier import SAMPLE_RATE, AudioClassifier

SOUNDS_DIR = Path(__file__).parent / "lab" / "sounds"
GENERATOR = SOUNDS_DIR / "generate.py"

# The lab writes 8 kHz .sln; the classifier works at 16 kHz.
LAB_RATE = 8000
WINDOW_SAMPLES = SAMPLE_RATE * 3  # classifier's 3s analysis window

FIXTURES = [
    ("lab-music.sln", AudioClassification.MUSIC),
    ("lab-speech.sln", AudioClassification.LIVE_HUMAN),
    ("lab-silence.sln", AudioClassification.SILENCE),
]


def _load_16k(path: Path) -> np.ndarray:
    """Load an 8 kHz .sln and upsample to the classifier's 16 kHz."""
    return np.repeat(np.fromfile(path, dtype="<i2"), SAMPLE_RATE // LAB_RATE)


def _windows(samples: np.ndarray, step: int):
    """Yield successive analysis windows; at least one, even for short files."""
    end = max(1, len(samples) - WINDOW_SAMPLES)
    for offset in range(0, end, step):
        yield samples[offset : offset + WINDOW_SAMPLES].astype("<i2").tobytes()


@pytest.fixture(scope="module")
def classifier():
    return AudioClassifier(settings=Settings().classifier)


@pytest.mark.parametrize("filename,expected", FIXTURES)
def test_fixture_classifies_correctly_in_every_window(filename, expected, classifier):
    """Every window must classify correctly — not just the first.

    Stepped at half the window length so windows overlap: a fixture that only
    works on aligned boundaries would still be a trap in a live call, where
    the window has no relationship to where the audio started.
    """
    path = SOUNDS_DIR / filename
    if not path.exists():
        pytest.skip(f"{filename} not generated — run {GENERATOR}")

    samples = _load_16k(path)
    results = [
        classifier.classify_chunk(w).audio_type
        for w in _windows(samples, step=WINDOW_SAMPLES // 2)
    ]

    wrong = [(i, r.value) for i, r in enumerate(results) if r is not expected]
    assert not wrong, (
        f"{filename} must classify as {expected.value} in all "
        f"{len(results)} windows; wrong: {wrong}"
    )


def test_generator_is_deterministic(tmp_path):
    """Same bytes on every run — the whole point of synthesising them.

    Real hold music varies per call, so a classifier regression on the PSTN is
    indistinguishable from noise. Fixed-seed audio makes the answer binary.
    """
    if not GENERATOR.exists():
        pytest.skip("generator not present")

    def run(target: Path) -> dict[str, bytes]:
        subprocess.run(
            [sys.executable, str(GENERATOR), str(target)],
            check=True,
            capture_output=True,
        )
        return {p.name: p.read_bytes() for p in sorted(target.glob("*.sln"))}

    first = run(tmp_path / "a")
    second = run(tmp_path / "b")

    assert first, "generator produced no .sln files"
    assert first.keys() == second.keys()
    for name in first:
        assert first[name] == second[name], f"{name} differs between runs"