from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

import bpy
import numpy as np


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

    parser = argparse.ArgumentParser(description="Extract camera pose and approximate depth from a scene")
    parser.add_argument("--input", required=True, help="Input .blend/.glb/.gltf scene")
    parser.add_argument("--output_dir", required=True, help="Output directory for camera.json and depth.npy")
    parser.add_argument("--frame", type=int, default=None, help="Frame to evaluate; default scene.frame_start")
    parser.add_argument("--max_depth_samples", type=int, default=300000)
    parser.add_argument("--seed", type=int, default=42)
    return parser.parse_args(argv)


def load_input_scene(input_path: str) -> Path:
    path = Path(input_path).resolve()
    if not path.exists():
        raise FileNotFoundError(f"Input scene does not exist: {path}")

    ext = path.suffix.lower()
    if ext == ".blend":
        bpy.ops.wm.open_mainfile(filepath=str(path))
    elif ext in {".glb", ".gltf"}:
        bpy.ops.object.select_all(action="SELECT")
        bpy.ops.object.delete()
        bpy.ops.import_scene.gltf(filepath=str(path))
    else:
        raise ValueError(f"Unsupported input scene extension: {path.suffix}")
    return path


def pick_camera(scene: bpy.types.Scene) -> bpy.types.Object:
    if scene.camera is not None:
        return scene.camera
    cameras = [obj for obj in scene.objects if obj.type == "CAMERA"]
    if not cameras:
        raise FileNotFoundError("Scene has no camera; cannot auto-extract camera/depth metadata.")
    return cameras[0]


def world_vertices(obj_eval: bpy.types.Object, mesh: bpy.types.Mesh) -> np.ndarray:
    local = np.empty(len(mesh.vertices) * 3, dtype=np.float32)
    mesh.vertices.foreach_get("co", local)
    local = local.reshape(-1, 3)

    mat = np.array(obj_eval.matrix_world, dtype=np.float32)
    rot = mat[:3, :3]
    trans = mat[:3, 3]
    return (local @ rot.T + trans).astype(np.float32, copy=False)


def collect_depths(scene: bpy.types.Scene, camera: bpy.types.Object, max_samples: int, seed: int) -> np.ndarray:
    depsgraph = bpy.context.evaluated_depsgraph_get()
    w2c = np.array(camera.matrix_world.inverted(), dtype=np.float64)
    depths: list[np.ndarray] = []

    for obj in scene.objects:
        if obj.type != "MESH" or obj.hide_render:
            continue

        obj_eval = obj.evaluated_get(depsgraph)
        mesh = obj_eval.to_mesh(preserve_all_data_layers=False, depsgraph=depsgraph)
        if mesh is None:
            continue
        try:
            if len(mesh.vertices) == 0:
                continue
            verts = world_vertices(obj_eval, mesh).astype(np.float64)
            cam = verts @ w2c[:3, :3].T + w2c[:3, 3]

            depth = -cam[:, 2]
            depth = depth[np.isfinite(depth) & (depth > 1e-8)]
            if depth.size:
                depths.append(depth.astype(np.float32, copy=False))
        finally:
            obj_eval.to_mesh_clear()

    if not depths:
        return np.zeros((0,), dtype=np.float32)

    values = np.concatenate(depths, axis=0)
    if max_samples > 0 and values.size > max_samples:
        rng = np.random.default_rng(seed)
        idx = rng.choice(values.size, size=max_samples, replace=False)
        values = values[idx]
    return values.astype(np.float32, copy=False)


def main() -> None:
    args = parse_args()
    scene_path = load_input_scene(args.input)
    scene = bpy.context.scene
    frame = int(args.frame) if args.frame is not None else int(scene.frame_start)
    scene.frame_set(frame)

    camera = pick_camera(scene)
    camera_to_world = np.array(camera.matrix_world, dtype=np.float64)
    world_to_camera = np.array(camera.matrix_world.inverted(), dtype=np.float64)
    depths = collect_depths(scene, camera, args.max_depth_samples, args.seed)

    output_dir = Path(args.output_dir).resolve()
    output_dir.mkdir(parents=True, exist_ok=True)
    depth_path = output_dir / "depth.npy"
    camera_path = output_dir / "camera.json"
    np.save(depth_path, depths)

    payload = {
        "scene": str(scene_path),
        "frame": frame,
        "camera_name": camera.name,
        "world_to_camera": world_to_camera.tolist(),
        "camera_to_world": camera_to_world.tolist(),
        "depth_path": str(depth_path),
        "depth_count": int(depths.size),
        "depth_median": float(np.median(depths)) if depths.size else None,
        "depth_definition": "positive mesh vertex depth in Blender camera coordinates, depth=-z_camera",
    }
    camera_path.write_text(json.dumps(payload, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
    print(json.dumps({"camera": str(camera_path), "depth": str(depth_path), "depth_count": int(depths.size)}))


if __name__ == "__main__":
    main()