#!/usr/bin/env python3
"""aria-transcribe-route — Hybrid-Router zwischen Groq Whisper + Transkriptor.

Drop-in-Replacement für `groq-whisper.py <file>` — selbe stdout-Schnittstelle.

Routing-Logik (duration-based):
- File-Audio ≤60 s → Groq (low-latency, single-speaker, $0.04/h pay-per-use)
- File-Audio  >60 s → Transkriptor (Pro-Plan flat-rate, Speaker-Diarization, bessere Quality)
- Transkriptor-Failure → Fallback Groq + Log

Override via Env-Var:
- TRANSCRIBE_FORCE=groq        — immer Groq
- TRANSCRIBE_FORCE=transkriptor — immer Transkriptor
- TRANSCRIBE_THRESHOLD_SECONDS=NN — Cutoff anpassen (default 60)

Output: stdout = Plain-Text (gleich wie groq-whisper.py)
Stderr: routing-decision log
Exit: 0 OK, 1 Fehler

CLI:
   python3 aria-transcribe-route.py <audio_file>
   python3 aria-transcribe-route.py <audio_file> --language de-DE --service Standard
"""
from __future__ import annotations

import argparse
import os
import subprocess
import sys
from pathlib import Path

GROQ_SCRIPT = "/root/aria/scripts/groq-whisper.py"
TRANSKRIPTOR_SCRIPT = "/root/aria/scripts/transkriptor-transcribe.py"
DEFAULT_THRESHOLD = 60.0  # seconds


def _duration_seconds(path: Path) -> float | None:
    try:
        out = subprocess.check_output(
            ["ffprobe", "-v", "error", "-show_entries", "format=duration",
             "-of", "default=noprint_wrappers=1:nokey=1", str(path)],
            timeout=20,
        )
        return float(out.decode().strip())
    except Exception as exc:  # noqa: BLE001
        sys.stderr.write(f"[route] ffprobe failed: {exc}\n")
        return None


def _run_groq(path: Path) -> int:
    """Run groq-whisper.py — preserves stdout-Pipe."""
    proc = subprocess.run(
        [sys.executable, GROQ_SCRIPT, str(path)],
        stdout=sys.stdout.fileno(),
        stderr=sys.stderr.fileno(),
    )
    return proc.returncode


def _run_transkriptor(path: Path, *, language: str, service: str) -> int:
    """Run transkriptor-transcribe.py file --wait — pipes transcript to stdout."""
    proc = subprocess.run(
        [sys.executable, TRANSKRIPTOR_SCRIPT, "file", str(path),
         "--language", language, "--service", service, "--wait"],
        stdout=sys.stdout.fileno(),
        stderr=sys.stderr.fileno(),
    )
    return proc.returncode


def main() -> int:
    parser = argparse.ArgumentParser(description="Hybrid transcribe router")
    parser.add_argument("path", help="audio file path")
    parser.add_argument("--language", default="auto")
    parser.add_argument("--service", default="Standard", choices=["Standard", "Subtitle"])
    parser.add_argument("--force", choices=["groq", "transkriptor"], default=None,
                        help="override duration-based routing")
    args = parser.parse_args()

    path = Path(args.path)
    if not path.exists():
        sys.stderr.write(f"[route] file not found: {path}\n")
        return 1

    force = args.force or os.environ.get("TRANSCRIBE_FORCE")
    threshold = float(os.environ.get("TRANSCRIBE_THRESHOLD_SECONDS", DEFAULT_THRESHOLD))

    duration = _duration_seconds(path)
    duration_str = f"{duration:.1f}s" if duration else "unknown"

    if force == "groq":
        choice = "groq"
        reason = "force=groq"
    elif force == "transkriptor":
        choice = "transkriptor"
        reason = "force=transkriptor"
    elif duration is None:
        choice = "groq"
        reason = "duration-unknown, default groq"
    elif duration <= threshold:
        choice = "groq"
        reason = f"duration {duration_str} ≤ threshold {threshold}s"
    else:
        choice = "transkriptor"
        reason = f"duration {duration_str} > threshold {threshold}s"

    sys.stderr.write(f"[route] {path.name} → {choice} ({reason})\n")

    if choice == "groq":
        rc = _run_groq(path)
    else:
        # Transkriptor doesn't accept "auto" — fall back to en-US which auto-detects
        lang = "en-US" if args.language == "auto" else args.language
        rc = _run_transkriptor(path, language=lang, service=args.service)
        if rc == 3:
            # KAR-695: Quota-Guard hat Upload verhindert — direkt Groq, kein Fehler
            sys.stderr.write("[route] transkriptor quota erschoepft (rc=3, KAR-695), fallback to groq\n")
            rc = _run_groq(path)
        elif rc != 0:
            sys.stderr.write(f"[route] transkriptor failed (rc={rc}), fallback to groq\n")
            rc = _run_groq(path)

    return rc


if __name__ == "__main__":
    sys.exit(main())