#!/usr/bin/env python3


from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path
from typing import Any, Iterable

import bpy
from mathutils import Matrix, Vector


OBJECT_TYPES = {"MESH", "EMPTY", "ARMATURE", "CURVE", "SURFACE", "FONT"}


def parse_args() -> argparse.Namespace:
    argv_source = getattr(bpy.app, "argv", None) or sys.argv
    argv: list[str] = []
    if "--" in argv_source:
        argv = argv_source[argv_source.index("--") + 1 :]

    parser = argparse.ArgumentParser(description="Render aligned eval images from a run_big_eval report")
    parser.add_argument("--report_json", required=True)
    parser.add_argument("--out_dir", required=True)
    parser.add_argument("--models", default=None, help="Comma-separated model keys; defaults to report order.")
    parser.add_argument("--render_gt", action=argparse.BooleanOptionalAction, default=True)
    parser.add_argument("--resolution_x", type=int, default=768)
    parser.add_argument("--resolution_y", type=int, default=432)
    parser.add_argument("--samples", type=int, default=32)
    parser.add_argument("--engine", choices=["BLENDER_EEVEE", "BLENDER_EEVEE_NEXT", "CYCLES"], default="BLENDER_EEVEE")
    parser.add_argument("--transparent", action=argparse.BooleanOptionalAction, default=False)
    return parser.parse_args(argv)


def clear_scene() -> None:
    bpy.ops.object.select_all(action="SELECT")
    bpy.ops.object.delete()
    for collection in list(bpy.data.collections):
        bpy.data.collections.remove(collection)
    for block in (
        bpy.data.meshes,
        bpy.data.materials,
        bpy.data.images,
        bpy.data.lights,
        bpy.data.cameras,
        bpy.data.curves,
        bpy.data.armatures,
    ):
        for item in list(block):
            if item.users == 0:
                block.remove(item)


def load_scene(path: Path) -> None:
    ext = path.suffix.lower()
    if ext == ".blend":
        bpy.ops.wm.open_mainfile(filepath=str(path))
        return
    clear_scene()
    if ext in {".glb", ".gltf"}:
        bpy.ops.import_scene.gltf(filepath=str(path))
        return
    raise ValueError(f"Unsupported scene asset: {path}")


def active_camera() -> bpy.types.Object:
    scene = bpy.context.scene
    if scene.camera is not None and scene.camera.type == "CAMERA":
        return scene.camera
    cameras = [obj for obj in scene.objects if obj.type == "CAMERA"]
    if not cameras:
        raise FileNotFoundError("GT scene has no camera to copy for rendering.")
    return cameras[0]


def copy_camera_data(src: bpy.types.Camera) -> bpy.types.Camera:
    dst = bpy.data.cameras.new("Eval_GT_Camera_Data")
    dst.type = src.type
    dst.lens = src.lens
    dst.sensor_width = src.sensor_width
    dst.sensor_height = src.sensor_height
    dst.sensor_fit = src.sensor_fit
    dst.shift_x = src.shift_x
    dst.shift_y = src.shift_y
    dst.clip_start = src.clip_start
    dst.clip_end = src.clip_end
    dst.ortho_scale = src.ortho_scale
    dst.dof.use_dof = False
    return dst


def baked_gt_camera(gt_scene: Path, gt_matrix: list[list[float]], gt_frame: int) -> dict[str, Any]:
    load_scene(gt_scene)
    scene = bpy.context.scene
    scene.frame_set(gt_frame)
    bpy.context.view_layer.update()
    cam = active_camera()
    eval_matrix = Matrix(gt_matrix) @ cam.matrix_world.copy()
    return {
        "matrix_world": [[float(v) for v in row] for row in eval_matrix],
        "data": {
            "type": cam.data.type,
            "lens": float(cam.data.lens),
            "sensor_width": float(cam.data.sensor_width),
            "sensor_height": float(cam.data.sensor_height),
            "sensor_fit": cam.data.sensor_fit,
            "shift_x": float(cam.data.shift_x),
            "shift_y": float(cam.data.shift_y),
            "clip_start": float(cam.data.clip_start),
            "clip_end": float(cam.data.clip_end),
            "ortho_scale": float(cam.data.ortho_scale),
        },
    }


def add_baked_camera(camera_info: dict[str, Any]) -> bpy.types.Object:
    data_info = camera_info["data"]
    cam_data = bpy.data.cameras.new("Eval_GT_Camera_Data")
    cam_data.type = data_info["type"]
    cam_data.lens = data_info["lens"]
    cam_data.sensor_width = data_info["sensor_width"]
    cam_data.sensor_height = data_info["sensor_height"]
    cam_data.sensor_fit = data_info["sensor_fit"]
    cam_data.shift_x = data_info["shift_x"]
    cam_data.shift_y = data_info["shift_y"]
    cam_data.clip_start = data_info["clip_start"]
    cam_data.clip_end = max(data_info["clip_end"], 1000.0)
    cam_data.ortho_scale = data_info["ortho_scale"]
    cam = bpy.data.objects.new("Eval_GT_Camera", cam_data)
    bpy.context.scene.collection.objects.link(cam)
    cam.matrix_world = Matrix(camera_info["matrix_world"])
    bpy.context.scene.camera = cam
    return cam


def root_objects(objects: Iterable[bpy.types.Object]) -> list[bpy.types.Object]:
    object_set = set(objects)
    return [obj for obj in objects if obj.parent not in object_set]


def remove_cameras_and_lights() -> None:
    for obj in list(bpy.context.scene.objects):
        if obj.type in {"CAMERA", "LIGHT"}:
            bpy.data.objects.remove(obj, do_unlink=True)


def apply_alignment(matrix: list[list[float]]) -> None:
    objects = [obj for obj in bpy.context.scene.objects if obj.type in OBJECT_TYPES]
    parent = bpy.data.objects.new("Eval_Alignment", None)
    bpy.context.scene.collection.objects.link(parent)
    parent.matrix_world = Matrix(matrix)
    for obj in root_objects(objects):
        obj.parent = parent
        obj.matrix_parent_inverse = Matrix.Identity(4)


def scene_bounds() -> tuple[Vector, Vector] | None:
    bpy.context.view_layer.update()
    mins: list[Vector] = []
    maxs: list[Vector] = []
    for obj in bpy.context.scene.objects:
        if obj.type != "MESH":
            continue
        corners = [obj.matrix_world @ Vector(corner) for corner in obj.bound_box]
        mins.append(Vector((min(v.x for v in corners), min(v.y for v in corners), min(v.z for v in corners))))
        maxs.append(Vector((max(v.x for v in corners), max(v.y for v in corners), max(v.z for v in corners))))
    if not mins:
        return None
    return (
        Vector((min(v.x for v in mins), min(v.y for v in mins), min(v.z for v in mins))),
        Vector((max(v.x for v in maxs), max(v.y for v in maxs), max(v.z for v in maxs))),
    )


def add_eval_light() -> None:
    bounds = scene_bounds()
    if bounds is None:
        loc = Vector((3.0, -4.0, 5.0))
        size = 4.0
        energy = 450.0
    else:
        bmin, bmax = bounds
        center = 0.5 * (bmin + bmax)
        diag = max((bmax - bmin).length, 1.0)
        loc = center + Vector((0.35 * diag, -0.65 * diag, 1.1 * diag))
        size = max(3.0, 0.55 * diag)
        energy = 500.0
    light_data = bpy.data.lights.new("Eval_Key_Light", "AREA")
    light = bpy.data.objects.new("Eval_Key_Light", light_data)
    bpy.context.scene.collection.objects.link(light)
    light.location = loc
    light.data.size = size
    light.data.energy = energy


def configure_render(args: argparse.Namespace, output: Path) -> None:
    scene = bpy.context.scene
    engine = args.engine
    try:
        scene.render.engine = engine
    except TypeError:
        if engine in {"BLENDER_EEVEE", "BLENDER_EEVEE_NEXT"}:
            fallback = "BLENDER_EEVEE_NEXT" if engine == "BLENDER_EEVEE" else "BLENDER_EEVEE"
            scene.render.engine = fallback
            engine = fallback
        else:
            raise
    if engine == "CYCLES":
        scene.cycles.samples = args.samples
    elif hasattr(scene, "eevee"):
        scene.eevee.taa_render_samples = args.samples
    scene.render.resolution_x = args.resolution_x
    scene.render.resolution_y = args.resolution_y
    scene.render.resolution_percentage = 100
    scene.render.film_transparent = bool(args.transparent)
    scene.render.image_settings.file_format = "PNG"
    scene.render.filepath = str(output)
    scene.view_settings.view_transform = "Filmic"
    scene.view_settings.look = "Medium High Contrast"
    scene.view_settings.exposure = 0.0
    scene.view_settings.gamma = 1.0
    scene.world.color = (0.04, 0.04, 0.04)


def frame_pairs_for(report: dict[str, Any], key: str) -> list[tuple[int, int]]:
    details = report.get("iou_b", {}).get(key, {}).get("frame_details", [])
    pairs: list[tuple[int, int]] = []
    for item in details:
        if "gt_frame_no" in item and "pred_frame_no" in item:
            pairs.append((int(item["gt_frame_no"]), int(item["pred_frame_no"])))
    if pairs:
        return pairs
    return [(1, 1)]


def default_models(report: dict[str, Any]) -> list[str]:
    keys = [row["model"] for row in report.get("summary", []) if row.get("model") in report.get("alignments", {})]
    if keys:
        return keys
    return [key for key in report.get("alignments", {}) if key != "gt"]


def render_one(
    *,
    args: argparse.Namespace,
    key: str,
    scene_path: Path,
    matrix: list[list[float]],
    camera_info: dict[str, Any],
    target_frame: int,
    output: Path,
) -> None:
    load_scene(scene_path)
    bpy.context.scene.frame_set(target_frame)
    bpy.context.view_layer.update()
    remove_cameras_and_lights()
    apply_alignment(matrix)
    add_baked_camera(camera_info)
    add_eval_light()
    output.parent.mkdir(parents=True, exist_ok=True)
    configure_render(args, output)
    bpy.ops.render.render(write_still=True)
    print(f"RENDERED key={key} frame={target_frame} output={output}")


def main() -> None:
    args = parse_args()
    report_path = Path(args.report_json).resolve()
    report = json.loads(report_path.read_text(encoding="utf-8"))
    out_dir = Path(args.out_dir).resolve()
    model_keys = [x.strip() for x in args.models.split(",") if x.strip()] if args.models else default_models(report)

    gt_scene = Path(report["paths"]["gt"]["scene"])
    first_key = model_keys[0]
    gt_matrix = report["alignments"][first_key]["gt_matrix"]
    manifest: dict[str, Any] = {
        "report_json": str(report_path),
        "gt_scene": str(gt_scene),
        "models": model_keys,
        "renders": {},
    }

    if args.render_gt:
        gt_pairs = frame_pairs_for(report, first_key)
        manifest["renders"]["gt"] = []
        for idx, (gt_frame, _) in enumerate(gt_pairs):
            camera_info = baked_gt_camera(gt_scene, gt_matrix, gt_frame)
            output = out_dir / "gt" / f"frame_{idx:03d}_gt{gt_frame:04d}.png"
            render_one(
                args=args,
                key="gt",
                scene_path=gt_scene,
                matrix=gt_matrix,
                camera_info=camera_info,
                target_frame=gt_frame,
                output=output,
            )
            manifest["renders"]["gt"].append({"gt_frame": gt_frame, "pred_frame": gt_frame, "path": str(output)})

    for key in model_keys:
        pred_scene = Path(report["paths"][key]["scene"])
        pred_matrix = report["alignments"][key]["pred_matrix"]
        pairs = frame_pairs_for(report, key)
        manifest["renders"][key] = []
        for idx, (gt_frame, pred_frame) in enumerate(pairs):
            camera_info = baked_gt_camera(gt_scene, gt_matrix, gt_frame)
            output = out_dir / key / f"frame_{idx:03d}_gt{gt_frame:04d}_pred{pred_frame:04d}.png"
            render_one(
                args=args,
                key=key,
                scene_path=pred_scene,
                matrix=pred_matrix,
                camera_info=camera_info,
                target_frame=pred_frame,
                output=output,
            )
            manifest["renders"][key].append({"gt_frame": gt_frame, "pred_frame": pred_frame, "path": str(output)})

    manifest_path = out_dir / "render_manifest.json"
    manifest_path.write_text(json.dumps(manifest, indent=2) + "\n", encoding="utf-8")
    print(f"WROTE_MANIFEST {manifest_path}")


if __name__ == "__main__":
    main()