"""
Compare two GGUF models against the DictationQuality corpus and print a
side-by-side summary.

Usage:
    python scripts/compare_models.py \
        --baseline /path/to/mumble-cleanup-q4km.gguf \
        --candidate data/models/mumble-cleanup-v2-q4km.gguf \
        --corpus EchoFlow/Tests/EchoFlowUIReviewTests/Fixtures/DictationQuality
"""

import argparse
import json
from pathlib import Path

from evaluate import evaluate_case, load_corpus
from llama_cpp import Llama


def evaluate_model(path: Path, transcripts: list, expected: dict, n_ctx: int = 4096):
    print(f"Evaluating {path.name}...")
    model = Llama(model_path=str(path), n_ctx=n_ctx, verbose=False)
    results = [evaluate_case(model, case, expected.get(case["id"], {})) for case in transcripts]
    passed = sum(1 for r in results if r["passed"])
    avg = sum(r["latency_ms"] for r in results) / max(1, len(results))
    max_lat = max(r["latency_ms"] for r in results)
    return {
        "path": str(path),
        "passed": passed,
        "total": len(results),
        "avg_latency_ms": round(avg, 1),
        "max_latency_ms": max_lat,
        "results": results,
    }


def main():
    parser = argparse.ArgumentParser(description="Compare two GGUF cleanup models")
    parser.add_argument("--baseline", type=Path, required=True)
    parser.add_argument("--candidate", type=Path, required=True)
    parser.add_argument("--corpus", type=Path, required=True)
    parser.add_argument("--output", type=Path, default=Path("data/eval/comparison.json"))
    args = parser.parse_args()

    transcripts, expected = load_corpus(args.corpus)
    baseline = evaluate_model(args.baseline, transcripts, expected)
    candidate = evaluate_model(args.candidate, transcripts, expected)

    print("\n" + "=" * 60)
    print(f"{'Metric':<30} {'Baseline':>12} {'Candidate':>12}")
    print("=" * 60)
    print(f"{'Pass rate':<30} {baseline['passed']}/{baseline['total']:>8} {candidate['passed']}/{candidate['total']:>8}")
    print(f"{'Avg latency (ms)':<30} {baseline['avg_latency_ms']:>12} {candidate['avg_latency_ms']:>12}")
    print(f"{'Max latency (ms)':<30} {baseline['max_latency_ms']:>12} {candidate['max_latency_ms']:>12}")

    deltas = []
    for b, c in zip(baseline["results"], candidate["results"]):
        if b["passed"] and not c["passed"]:
            deltas.append(f"REGRESSION: {c['id']} -> '{c['output']}'")
        elif not b["passed"] and c["passed"]:
            deltas.append(f"IMPROVEMENT: {c['id']} -> '{c['output']}'")

    if deltas:
        print("\nPer-case changes:")
        for d in deltas[:20]:
            print(f"  {d}")

    args.output.parent.mkdir(parents=True, exist_ok=True)
    with args.output.open("w", encoding="utf-8") as f:
        json.dump({"baseline": baseline, "candidate": candidate, "deltas": deltas}, f, indent=2, ensure_ascii=False)
    print(f"\nComparison saved to {args.output}")


if __name__ == "__main__":
    main()