#!/usr/bin/env python3
"""
eval/preprocess_gt_videos.py

Apply the same spatial preprocessing used by SpaceTimePilot to the GT videos
in camxtime_evaluation_gt, so they match the network output format exactly.

Pipeline (mirrors spacetimepilot/dataset/utils.py):
  1. Load up to 81 frames at stride=1
  2. crop_and_resize: aspect-ratio preserving scale so image covers 832×480
  3. CenterCrop to exactly 832×480
  4. Pad with last frame if shorter than 81 frames
  5. Write as 30fps H264 MP4

For 1080×1080 source: scale to 832×832, then crop 176px top/bottom → 832×480.

Usage (run from repo root):
    python eval/preprocess_gt_videos.py \\
        --input  camxtime_evaluation_gt \\
        --output camxtime_evaluation_gt_preprocessed
"""

import argparse
import multiprocessing
import shutil
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path

import imageio.v2 as imageio
import numpy as np
from PIL import Image
from tqdm import tqdm

TARGET_W   = 832
TARGET_H   = 480
NUM_FRAMES = 81
FPS        = 30


def crop_and_resize(img: Image.Image) -> Image.Image:
    w, h  = img.size
    scale = max(TARGET_W / w, TARGET_H / h)
    return img.resize((round(w * scale), round(h * scale)), Image.BILINEAR)


def center_crop(img: Image.Image) -> Image.Image:
    w, h = img.size
    return img.crop(((w - TARGET_W) // 2, (h - TARGET_H) // 2,
                     (w - TARGET_W) // 2 + TARGET_W, (h - TARGET_H) // 2 + TARGET_H))


def preprocess_frame(arr: np.ndarray) -> np.ndarray:
    img = Image.fromarray(arr).convert("RGB")
    return np.array(center_crop(crop_and_resize(img)))


def process_video(src: Path, dst: Path) -> None:
    reader = imageio.get_reader(str(src))
    total  = reader.count_frames()
    frames = [preprocess_frame(reader.get_data(i)) for i in range(min(NUM_FRAMES, total))]
    reader.close()
    while len(frames) < NUM_FRAMES:
        frames.append(frames[-1].copy())
    writer = imageio.get_writer(str(dst), fps=FPS, codec="libx264", quality=8)
    for f in frames:
        writer.append_data(f)
    writer.close()


def process_scene(args):
    scene_dir, out_dir = Path(args[0]), Path(args[1])
    out_scene = out_dir / scene_dir.name
    out_scene.mkdir(parents=True, exist_ok=True)
    n_built = n_skipped = 0
    for vid in sorted(scene_dir.glob("*.mp4")):
        out_vid = out_scene / vid.name
        if out_vid.exists():
            n_skipped += 1
        else:
            process_video(vid, out_vid)
            n_built += 1
        for ext in (".json", ".txt"):
            src = vid.with_suffix(ext)
            if src.exists():
                dst = out_scene / src.name
                if not dst.exists():
                    shutil.copy2(src, dst)
    cam_json = scene_dir / "camera_data.json"
    if cam_json.exists() and not (out_scene / "camera_data.json").exists():
        shutil.copy2(cam_json, out_scene / "camera_data.json")
    return scene_dir.name, n_built, n_skipped


def main():
    parser = argparse.ArgumentParser(
        description="Preprocess GT videos to 832×480 / 81 frames to match network output."
    )
    parser.add_argument("--input",   required=True,
                        help="camxtime_evaluation_gt root")
    parser.add_argument("--output",  required=True,
                        help="Output root (camxtime_evaluation_gt_preprocessed)")
    parser.add_argument("--scenes",  nargs="+")
    parser.add_argument("--workers", type=int,
                        default=min(32, multiprocessing.cpu_count()))
    args = parser.parse_args()

    input_dir  = Path(args.input)
    output_dir = Path(args.output)
    output_dir.mkdir(parents=True, exist_ok=True)
    scenes = ([input_dir / s for s in args.scenes] if args.scenes
              else sorted(p for p in input_dir.iterdir() if p.is_dir()))

    print(f"CPUs: {multiprocessing.cpu_count()}  |  workers: {args.workers}  "
          f"|  target: {TARGET_W}×{TARGET_H}, {NUM_FRAMES}f @ {FPS}fps  "
          f"|  scenes: {len(scenes)}\n")

    tasks = [(s, output_dir) for s in scenes]
    n_done = n_errors = 0

    with ProcessPoolExecutor(max_workers=args.workers) as pool:
        futures = {pool.submit(process_scene, t): Path(t[0]).name for t in tasks}
        with tqdm(total=len(futures), desc="Overall", unit="scene",
                  dynamic_ncols=True) as pbar:
            for fut in as_completed(futures):
                name = futures[fut]
                try:
                    _, built, skipped = fut.result()
                    n_done += 1
                    tqdm.write(f"  OK    {name:<12s}  {built} preprocessed, {skipped} skipped")
                except Exception as exc:
                    n_errors += 1
                    tqdm.write(f"  ERR   {name:<12s}  {exc}")
                pbar.set_postfix(done=n_done, err=n_errors)
                pbar.update(1)

    print(f"\nFinished — {n_done} scenes done, {n_errors} errors")
    print(f"Output: {output_dir}")


if __name__ == "__main__":
    main()