#!/usr/bin/env python3
"""Evaluate a single inference run: PSNR vs baseline, reuse rate, peak memory."""

import argparse
import json
import re
import sys

_BASELINE_CACHE = {}


def load_video_frames(path, max_frames=None, stride=1):
    import cv2
    import numpy as np

    cap = cv2.VideoCapture(path)
    frames = []
    idx = 0
    while True:
        ret, img = cap.read()
        if not ret:
            break
        if idx % stride == 0:
            frames.append(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
            if max_frames is not None and len(frames) >= max_frames:
                break
        idx += 1
    cap.release()
    return np.stack(frames) if frames else None


def align_frames(gt, gen):
    import cv2
    import numpy as np

    n = min(len(gt), len(gen))
    gt = gt[:n]
    gen = gen[:n]
    if gt.shape[1:3] != gen.shape[1:3]:
        h, w = gt.shape[1], gt.shape[2]
        gen = np.stack([cv2.resize(f, (w, h)) for f in gen])
    return gt, gen


def psnr(gt, gen):
    import numpy as np

    gt, gen = align_frames(gt, gen)
    mse = np.mean((gt.astype(np.float32) - gen.astype(np.float32)) ** 2)
    if mse == 0:
        return float("inf")
    return 10 * np.log10(255**2 / mse)


def ssim_simple(gt, gen):
    import numpy as np

    gt, gen = align_frames(gt, gen)
    gt_f = gt.astype(np.float32) / 255.0
    gen_f = gen.astype(np.float32) / 255.0
    mu_g = gt_f.mean()
    mu_p = gen_f.mean()
    var_g = gt_f.var()
    var_p = gen_f.var()
    cov = ((gt_f - mu_g) * (gen_f - mu_p)).mean()
    c1, c2 = 0.01**2, 0.03**2
    return ((2 * mu_g * mu_p + c1) * (2 * cov + c2)) / ((mu_g**2 + mu_p**2 + c1) * (var_g + var_p + c2))


def black_ratio(frames, thresh=5):
    import numpy as np
    return float(np.mean(frames.max(axis=-1) < thresh))


def parse_log(log_path):
    reuse_rates = []
    peak_gb = None
    with open(log_path, "r", errors="ignore") as f:
        text = f.read()
    for m in re.finditer(r"reuse_rate=([\d.]+)%", text):
        reuse_rates.append(float(m.group(1)))
    m = re.search(r"Peak memory allocated:\s*([\d.]+)\s*GB", text)
    if m:
        peak_gb = float(m.group(1))
    avg_reuse = sum(reuse_rates) / len(reuse_rates) if reuse_rates else None
    return avg_reuse, peak_gb


def parse_metric(metric_path):
    with open(metric_path, "r") as f:
        payload = json.load(f)
    summary = payload.get("chunk_execution_summary", {})
    rates = [v["reuse_rate"] for v in summary.values()]
    return (sum(rates) / len(rates) * 100) if rates else None


def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--baseline", required=True)
    parser.add_argument("--generated", required=True)
    parser.add_argument("--log", required=True)
    parser.add_argument("--metric", default="")
    args = parser.parse_args()

    gt = load_video_frames(args.baseline)
    gen = load_video_frames(args.generated)
    if gt is None or gen is None:
        print("PSNR=NA,SSIM=NA,BLACK=NA,REUSE=NA,PEAK=NA")
        return

    p = psnr(gt, gen)
    s = ssim_simple(gt, gen)
    b = black_ratio(gen)
    reuse, peak = parse_log(args.log)
    if args.metric:
        metric_reuse = parse_metric(args.metric)
        if metric_reuse is not None:
            reuse = metric_reuse

    psnr_s = "inf" if p == float("inf") else f"{p:.4f}"
    ssim_s = f"{s:.6f}"
    black_s = f"{b:.6f}"
    reuse_s = f"{reuse:.2f}" if reuse is not None else "NA"
    peak_s = f"{peak:.2f}" if peak is not None else "NA"
    print(f"PSNR={psnr_s}")
    print(f"SSIM={ssim_s}")
    print(f"BLACK={black_s}")
    print(f"REUSE={reuse_s}")
    print(f"PEAK={peak_s}")


if __name__ == "__main__":
    main()