"""
_common.py — shared plumbing for the transcription scripts.

Every transcribe_*.py does the same three things:
  1. read the list of clips (clip_id + wav path) for a language,
  2. run each clip through one engine,
  3. write results/<engine>.csv in the shared schema: clip_id,engine,transcript

This module holds steps 1 and 3 so each engine script only has to implement
"given a wav path, return a transcript string". That keeps the engines honest:
they all read the exact same audio and write the exact same shape, which is the
whole point of a fair benchmark.
"""

import csv
import os

REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
AUDIO_DIR = os.path.join(REPO_ROOT, "audio")
RESULTS_DIR = os.path.join(REPO_ROOT, "results")
GROUND_TRUTH_CSV = os.path.join(AUDIO_DIR, "ground_truth.csv")


def load_clips(language):
    """
    Return [(clip_id, wav_path), ...] for one language, read from
    ground_truth.csv. Verifies each wav actually exists on disk so a missing
    file fails loudly here instead of deep inside an engine call.
    """
    if not os.path.exists(GROUND_TRUTH_CSV):
        raise SystemExit(
            f"[STOP] {GROUND_TRUTH_CSV} not found. Run prepare_data.py first "
            f"(Step 3) to generate the clips and ground truth."
        )

    clips = []
    with open(GROUND_TRUTH_CSV, newline="", encoding="utf-8") as f:
        reader = csv.DictReader(f)
        for row in reader:
            if row.get("language") != language:
                continue
            clip_id = row["clip_id"]
            wav_path = os.path.join(AUDIO_DIR, language, f"{clip_id}.wav")
            if not os.path.exists(wav_path):
                raise SystemExit(
                    f"[STOP] Ground truth lists '{clip_id}' but {wav_path} is "
                    f"missing. Re-run prepare_data.py for '{language}'."
                )
            clips.append((clip_id, wav_path))

    if not clips:
        raise SystemExit(
            f"[STOP] No clips found for language '{language}' in "
            f"{GROUND_TRUTH_CSV}. Did prepare_data.py run for this language?"
        )
    return clips


def write_results(engine, rows):
    """
    Write results/<engine>.csv with the shared schema. `rows` is a list of
    (clip_id, transcript) — the engine name is filled in here so it's spelled
    identically for the scorer to join on.
    """
    os.makedirs(RESULTS_DIR, exist_ok=True)
    out_path = os.path.join(RESULTS_DIR, f"{engine}.csv")
    with open(out_path, "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerow(["clip_id", "engine", "transcript"])
        for clip_id, transcript in rows:
            writer.writerow([clip_id, engine, transcript])
    print(f"\n[done] Wrote {len(rows)} rows to {out_path}")
    return out_path


def require_env(name, how_to_fix):
    """Fetch an API key from the environment or stop with a clear message."""
    value = os.environ.get(name)
    if not value:
        raise SystemExit(
            f"[STOP] Environment variable {name} is not set.\n{how_to_fix}"
        )
    return value