#!/usr/bin/env python3


from __future__ import annotations

import argparse
import json
import subprocess
import sys
from pathlib import Path
from typing import Any


def parse_args() -> argparse.Namespace:
    p = argparse.ArgumentParser(description="Run alignment, GT-camera rendering, and rendered visual metrics.")
    p.add_argument("--sample_id", required=True)
    p.add_argument("--data_root", default="data")
    p.add_argument("--gt_key", default="gt")
    p.add_argument("--models", required=True, help="Comma-separated model keys under data_root.")
    p.add_argument("--blender_bin", required=True)
    p.add_argument("--clip_model_path", required=True)
    p.add_argument("--out_dir", required=True)
    p.add_argument(
        "--alignment",
        choices=["identity", "bbox", "object_bbox", "depth_bbox", "depth_camera"],
        default="bbox",
    )
    p.add_argument(
        "--ground_policy",
        choices=["exclude", "include"],
        default="exclude",
        help="Whether bbox alignment and geometry IoU exclude detected ground planes.",
    )
    p.add_argument(
        "--geometry_frame_mode",
        default="first_only",
        help="Geometry frames used for IoU-B extraction: first_only, first_mid_last, last_only, or exact:<frame>.",
    )
    p.add_argument("--camera_convention", choices=["auto", "world_to_camera", "camera_to_world"], default="auto")
    p.add_argument("--camera_rotation_only", action="store_true")
    p.add_argument("--image_glob", default="frames/*,selected_frames/*,eval_frames/*,scene.png")
    p.add_argument("--scene_filename", default=None)
    p.add_argument("--clip_batch_size", type=int, default=32)
    p.add_argument("--resolution_x", type=int, default=768)
    p.add_argument("--resolution_y", type=int, default=432)
    p.add_argument("--samples", type=int, default=32)
    p.add_argument("--render_engine", choices=["BLENDER_EEVEE", "BLENDER_EEVEE_NEXT", "CYCLES"], default="BLENDER_EEVEE")
    p.add_argument("--transparent", action=argparse.BooleanOptionalAction, default=False)
    p.add_argument("--skip_rendered_visual_metrics", action="store_true")
    p.add_argument("--keep_selected_image_metrics", action="store_true")
    p.add_argument(
        "--strict_selected_images",
        action="store_true",
        help="Fail if selected images are missing when --keep_selected_image_metrics is used.",
    )
    return p.parse_args()


def project_root() -> Path:
    return Path(__file__).resolve().parents[1]


def run(cmd: list[str]) -> None:
    print("\n>>> " + " ".join(cmd), flush=True)
    proc = subprocess.run(cmd, text=True)
    if proc.returncode != 0:
        raise SystemExit(proc.returncode)


def load_json(path: Path) -> dict[str, Any]:
    return json.loads(path.read_text(encoding="utf-8"))


def write_json(path: Path, payload: dict[str, Any]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")


def merge_final_report(
    *,
    geometry_report: Path,
    render_manifest: Path | None,
    rendered_visual_report: Path | None,
    final_report: Path,
) -> None:
    geometry = load_json(geometry_report)
    rendered_visual = load_json(rendered_visual_report) if rendered_visual_report and rendered_visual_report.exists() else None

    visual_by_model: dict[str, Any] = {}
    if rendered_visual:
        visual_by_model = {row["model"]: row for row in rendered_visual.get("summary", [])}

    summary: list[dict[str, Any]] = []
    for row in geometry.get("summary", []):
        key = row["model"]
        visual = visual_by_model.get(key, {})
        pl_raw = visual.get("pl_raw")
        n_clip_raw = visual.get("n_clip_raw")
        summary.append(
            {
                "model": key,
                "scene_aabb_iou_mean": row.get("scene_aabb_iou_mean", 0.0),
                "scene_obb_iou_mean": row.get("scene_obb_iou_mean", 0.0),
                "object_aabb_iou_penalized_mean": row.get("object_aabb_iou_penalized_mean", 0.0),
                "object_obb_iou_penalized_mean": row.get("object_obb_iou_penalized_mean", 0.0),
                "pl": 100.0 * pl_raw if pl_raw is not None else None,
                "n_clip": 10.0 * n_clip_raw if n_clip_raw is not None else None,
                "rendered_pl_raw": pl_raw,
                "rendered_pl_score_100": visual.get("pl_score_100"),
                "rendered_n_clip_raw": n_clip_raw,
                "rendered_n_clip_score_100": visual.get("n_clip_score_100"),
                "rendered_clip_similarity_mean": visual.get("clip_similarity_mean"),
                "rendered_frame_count": visual.get("frame_count"),
                "alignment_mode": row.get("alignment_mode"),
                "alignment_scale": row.get("alignment_scale"),
            }
        )

    payload = {
        "sample_id": geometry.get("sample_id"),
        "definition": {
            "geometry": "IoU-B on aligned .blend/.glb/.gltf geometry.",
            "object_iou": "Hungarian object matching on AABB IoU; unmatched/missing objects are penalized by max(gt_count,pred_count).",
            "rendered_visual": "GT-camera renders after alignment, then PL and VIGA-style image-image N-CLIP.",
            "pl": "100 * mean normalized RGB MSE; lower is better.",
            "n_clip": "10 * mean(1 - CLIPSim); lower is better.",
        },
        "paths": {
            "geometry_report": str(geometry_report),
            "render_manifest": str(render_manifest) if render_manifest else None,
            "rendered_visual_report": str(rendered_visual_report) if rendered_visual_report else None,
        },
        "geometry_report": geometry,
        "rendered_visual_report": rendered_visual,
        "summary": summary,
        "rankings": {
            "scene_aabb_desc": sorted(summary, key=lambda x: x["scene_aabb_iou_mean"], reverse=True),
            "scene_obb_desc": sorted(summary, key=lambda x: x["scene_obb_iou_mean"], reverse=True),
            "object_aabb_pen_desc": sorted(summary, key=lambda x: x["object_aabb_iou_penalized_mean"], reverse=True),
            "pl_asc": sorted(summary, key=lambda x: x.get("pl") if x.get("pl") is not None else float("inf")),
            "n_clip_asc": sorted(summary, key=lambda x: x.get("n_clip") if x.get("n_clip") is not None else float("inf")),
            "rendered_pl_score_desc": sorted(summary, key=lambda x: x.get("rendered_pl_score_100") or 0.0, reverse=True),
            "rendered_nclip_score_desc": sorted(summary, key=lambda x: x.get("rendered_n_clip_score_100") or 0.0, reverse=True),
        },
    }
    write_json(final_report, payload)
    print(json.dumps(summary, indent=2, ensure_ascii=False))
    print(f"SAVED {final_report}")


def main() -> None:
    args = parse_args()
    root = project_root()
    out_dir = Path(args.out_dir).resolve()
    reports_dir = out_dir / "reports"
    renders_dir = out_dir / "renders"
    alignments_dir = out_dir / "alignments"
    reports_dir.mkdir(parents=True, exist_ok=True)

    geometry_report = reports_dir / "geometry_alignment_report.json"
    render_manifest = renders_dir / "render_manifest.json"
    rendered_visual_report = reports_dir / "rendered_visual_metrics.json"
    final_report = reports_dir / "final_report.json"

    geometry_cmd = [
        sys.executable,
        str(root / "scripts" / "run_big_eval.py"),
        "--sample_id",
        args.sample_id,
        "--data_root",
        args.data_root,
        "--gt_key",
        args.gt_key,
        "--models",
        args.models,
        "--blender_bin",
        args.blender_bin,
        "--clip_model_path",
        args.clip_model_path,
        "--clip_batch_size",
        str(args.clip_batch_size),
        "--out_json",
        str(geometry_report),
        "--alignment_dir",
        str(alignments_dir),
        "--scene_meta_dir",
        str(out_dir / "scene_meta"),
        "--alignment",
        args.alignment,
        "--ground_policy",
        args.ground_policy,
        "--geometry_frame_mode",
        args.geometry_frame_mode,
        "--camera_convention",
        args.camera_convention,
        "--image_glob",
        args.image_glob,
    ]
    if not args.strict_selected_images:
        geometry_cmd.append("--allow_missing_images")
    if args.camera_rotation_only:
        geometry_cmd.append("--camera_rotation_only")
    if args.scene_filename:
        geometry_cmd.extend(["--scene_filename", args.scene_filename])
    if not args.keep_selected_image_metrics:
        geometry_cmd.append("--skip_selected_image_metrics")
    run(geometry_cmd)

    render_cmd = [
        args.blender_bin,
        "--factory-startup",
        "--background",
        "--python",
        str(root / "scripts" / "render_aligned_eval_images.py"),
        "--",
        "--report_json",
        str(geometry_report),
        "--out_dir",
        str(renders_dir),
        "--models",
        args.models,
        "--resolution_x",
        str(args.resolution_x),
        "--resolution_y",
        str(args.resolution_y),
        "--samples",
        str(args.samples),
        "--engine",
        args.render_engine,
    ]
    if args.transparent:
        render_cmd.append("--transparent")
    run(render_cmd)

    if not args.skip_rendered_visual_metrics:
        visual_cmd = [
            sys.executable,
            str(root / "scripts" / "eval_rendered_visual_metrics.py"),
            "--manifest",
            str(render_manifest),
            "--clip_model_path",
            args.clip_model_path,
            "--out_json",
            str(rendered_visual_report),
            "--models",
            args.models,
            "--batch_size",
            str(args.clip_batch_size),
        ]
        run(visual_cmd)
    else:
        rendered_visual_report = None

    merge_final_report(
        geometry_report=geometry_report,
        render_manifest=render_manifest,
        rendered_visual_report=rendered_visual_report,
        final_report=final_report,
    )


if __name__ == "__main__":
    main()