#!/usr/bin/env python3
"""Collect CDF evaluation text outputs and sampler latency into a CSV table."""

from __future__ import annotations

import argparse
import csv
import json
import re
from pathlib import Path
from typing import Dict, Optional


METRIC_PATTERNS = {
    "inception_score": re.compile(r"^Inception Score:\s*([-+0-9.eE]+)"),
    "fid": re.compile(r"^FID:\s*([-+0-9.eE]+)"),
    "sfid": re.compile(r"^sFID:\s*([-+0-9.eE]+)"),
    "precision": re.compile(r"^Precision:\s*([-+0-9.eE]+)"),
    "recall": re.compile(r"^Recall:\s*([-+0-9.eE]+)"),
}


def parse_ratio_from_name(path: Path) -> Optional[str]:
    match = re.search(
        r"ratio-([-+]?(?:\d+(?:\.\d*)?|\.\d+))(?=$|\.(?:txt|json|npz|csv)$|[^0-9.])",
        path.name,
    )
    return match.group(1) if match else None


def parse_metric_file(path: Path) -> Dict[str, str]:
    row: Dict[str, str] = {}
    for line in path.read_text(encoding="utf-8", errors="ignore").splitlines():
        line = line.strip()
        for key, pattern in METRIC_PATTERNS.items():
            match = pattern.match(line)
            if match:
                row[key] = match.group(1)
    return row


def load_latency(path: Path) -> Dict[str, str]:
    data = json.loads(path.read_text(encoding="utf-8"))
    return {
        "latency_sec": str(data.get("total_seconds", "")),
        "seconds_per_sample": str(data.get("seconds_per_sample", "")),
        "images_per_second": str(data.get("images_per_second", "")),
    }


def collect_rows(output_dir: Path):
    rows: Dict[str, Dict[str, str]] = {}

    for metric_path in sorted(output_dir.glob("metrics-ratio-*.txt")):
        ratio = parse_ratio_from_name(metric_path)
        if ratio is None:
            continue
        rows.setdefault(ratio, {"ratio": ratio})
        rows[ratio].update(parse_metric_file(metric_path))

    samples_dir = output_dir / "samples"
    for latency_path in sorted(samples_dir.glob("seed-*-ratio-*/latency.json")):
        ratio = parse_ratio_from_name(latency_path.parent)
        if ratio is None:
            continue
        rows.setdefault(ratio, {"ratio": ratio})
        rows[ratio].update(load_latency(latency_path))
        npz_path = latency_path.parent.with_suffix(".npz")
        if npz_path.exists():
            rows[ratio]["npz_path"] = str(npz_path)

    for latency_path in sorted(output_dir.glob("ratio-*/latency.json")):
        ratio = parse_ratio_from_name(latency_path.parent)
        if ratio is None:
            continue
        rows.setdefault(ratio, {"ratio": ratio})
        rows[ratio].update(load_latency(latency_path))
        npz_path = output_dir / f"ratio-{ratio}.npz"
        if npz_path.exists():
            rows[ratio]["npz_path"] = str(npz_path)

    for clip_path in sorted(output_dir.glob("clip-ratio-*.json")):
        ratio = parse_ratio_from_name(clip_path)
        if ratio is None:
            continue
        rows.setdefault(ratio, {"ratio": ratio})
        data = json.loads(clip_path.read_text(encoding="utf-8"))
        rows[ratio]["clip_score"] = str(data.get("clip_score_mean", ""))

    baseline_latency = None
    if "0.0" in rows and rows["0.0"].get("latency_sec"):
        baseline_latency = float(rows["0.0"]["latency_sec"])

    for ratio, row in rows.items():
        if baseline_latency is not None and row.get("latency_sec"):
            latency = float(row["latency_sec"])
            row["speedup"] = str(baseline_latency / latency) if latency > 0 else ""
        else:
            row.setdefault("speedup", "")

    return [rows[key] for key in sorted(rows.keys(), key=lambda item: float(item))]


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--output-dir", required=True, type=Path)
    parser.add_argument("--output", type=Path, default=None)
    args = parser.parse_args()

    rows = collect_rows(args.output_dir)
    output = args.output or args.output_dir / "metrics.csv"
    output.parent.mkdir(parents=True, exist_ok=True)

    fieldnames = [
        "ratio",
        "fid",
        "inception_score",
        "sfid",
        "precision",
        "recall",
        "clip_score",
        "latency_sec",
        "seconds_per_sample",
        "images_per_second",
        "speedup",
        "npz_path",
    ]
    with output.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        for row in rows:
            writer.writerow({key: row.get(key, "") for key in fieldnames})
    print(f"Wrote {len(rows)} rows to {output}")


if __name__ == "__main__":
    main()