"""Build ``points3d.ply`` from the first frame of every static camera.

The camera metadata uses Blender camera coordinates: +X right, +Y up, and
+Z backward. Depth therefore projects along -Z before the camera-to-world
transform is applied. ``CineCamera_Moving`` is intentionally excluded.
"""

from __future__ import annotations

import argparse
import json
from pathlib import Path, PurePosixPath
import re
import tempfile

import numpy as np
from PIL import Image


STATIC_CAMERA_METADATA = re.compile(r"^blender_(CineCamera_\d+)\.json$")


def static_camera_metadata(render_dir: Path) -> list[Path]:
    def camera_index(path: Path) -> int:
        match = STATIC_CAMERA_METADATA.fullmatch(path.name)
        if match is None:
            return -1
        return int(match.group(1).removeprefix("CineCamera_"))

    files = [
        path
        for path in render_dir.glob("blender_CineCamera_*.json")
        if STATIC_CAMERA_METADATA.fullmatch(path.name)
    ]
    return sorted(files, key=camera_index)


def first_frame_paths(render_dir: Path, frame: dict) -> tuple[Path, Path]:
    raw_path = str(frame["file_path"]).replace("\\", "/")
    relative = PurePosixPath(raw_path)
    parts = list(relative.parts)
    try:
        rgb_index = parts.index("rgb")
    except ValueError as exc:
        raise ValueError(f"Camera frame path does not contain an rgb component: {raw_path}") from exc

    rgb_relative = relative if relative.suffix.lower() == ".jpg" else relative.with_suffix(".jpg")
    parts[rgb_index] = "depth"
    depth_relative = PurePosixPath(*parts).with_suffix(".npz")
    return render_dir.joinpath(*rgb_relative.parts), render_dir.joinpath(*depth_relative.parts)


def load_rgb(path: Path) -> np.ndarray:
    with Image.open(path) as image:
        rgb = np.asarray(image.convert("RGB"))
    if rgb.ndim == 2:
        rgb = np.repeat(rgb[..., None], 3, axis=-1)
    if rgb.ndim != 3 or rgb.shape[2] < 3:
        raise ValueError(f"Unsupported RGB image shape for {path}: {rgb.shape}")
    rgb = rgb[..., :3]
    if rgb.dtype != np.uint8:
        if np.issubdtype(rgb.dtype, np.floating) and np.nanmax(rgb) <= 1.0:
            rgb = rgb * 255.0
        rgb = np.clip(rgb, 0, 255).astype(np.uint8)
    return rgb


def write_binary_ply(path: Path, points: np.ndarray, colors: np.ndarray) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    vertex_type = np.dtype(
        [
            ("x", "<f8"),
            ("y", "<f8"),
            ("z", "<f8"),
            ("red", "u1"),
            ("green", "u1"),
            ("blue", "u1"),
        ]
    )
    vertices = np.empty(len(points), dtype=vertex_type)
    vertices["x"], vertices["y"], vertices["z"] = points.T
    vertices["red"], vertices["green"], vertices["blue"] = colors.T
    header = (
        "ply\n"
        "format binary_little_endian 1.0\n"
        "comment Created by PhysInOne Camera and Rendering Tools\n"
        f"element vertex {len(vertices)}\n"
        "property double x\n"
        "property double y\n"
        "property double z\n"
        "property uchar red\n"
        "property uchar green\n"
        "property uchar blue\n"
        "end_header\n"
    ).encode("ascii")

    with tempfile.NamedTemporaryFile(dir=path.parent, suffix=".ply", delete=False) as handle:
        temporary = Path(handle.name)
        handle.write(header)
        vertices.tofile(handle)
    try:
        if temporary.stat().st_size <= len(header):
            raise RuntimeError(f"PLY writer produced no vertices: {temporary}")
        temporary.chmod(0o664)
        temporary.replace(path)
    finally:
        temporary.unlink(missing_ok=True)


def valid_ply(path: Path) -> bool:
    if not path.is_file() or path.stat().st_size == 0:
        return False
    try:
        with path.open("rb") as handle:
            header = handle.read(2048).split(b"end_header\n", 1)[0].decode("ascii")
        match = re.search(r"^element vertex (\d+)$", header, flags=re.MULTILINE)
        return header.startswith("ply\n") and match is not None and int(match.group(1)) > 0
    except (OSError, UnicodeDecodeError, ValueError):
        return False


def generate_points3d(
    render_dir: Path,
    output: Path | None = None,
    depth_threshold: float = 20.0,
    max_points: int = 100_000,
    seed: int = 0,
) -> dict[str, int | float | str]:
    """Generate one point cloud using frame zero from every static view.

    Random priorities implement a bounded-memory uniform sample across all
    valid pixels from all views. The seed makes the output reproducible.
    """

    render_dir = render_dir.expanduser().resolve()
    output = render_dir / "points3d.ply" if output is None else output.expanduser().resolve()
    if depth_threshold <= 0:
        raise ValueError("depth_threshold must be positive")
    if max_points <= 0:
        raise ValueError("max_points must be positive")

    metadata_files = static_camera_metadata(render_dir)
    if not metadata_files:
        raise RuntimeError(f"No static blender_CineCamera_<index>.json files under {render_dir}")

    rng = np.random.default_rng(seed)
    kept_keys = np.empty(0, dtype=np.float64)
    kept_points = np.empty((0, 3), dtype=np.float64)
    kept_colors = np.empty((0, 3), dtype=np.uint8)
    valid_pixels = 0
    used_views = 0

    for metadata_path in metadata_files:
        with metadata_path.open("r", encoding="utf-8") as handle:
            document = json.load(handle)
        frames = document.get("frames", [])
        if not frames:
            raise RuntimeError(f"Camera metadata has no frames: {metadata_path}")

        frame = frames[0]
        rgb_path, depth_path = first_frame_paths(render_dir, frame)
        if not rgb_path.is_file() or not depth_path.is_file():
            raise FileNotFoundError(
                f"Missing first-frame input for {metadata_path.name}: rgb={rgb_path}, depth={depth_path}"
            )

        with np.load(depth_path) as depth_file:
            if "depth" not in depth_file:
                raise KeyError(f"Missing 'depth' array in {depth_path}")
            depth = np.asarray(depth_file["depth"], dtype=np.float64)
        rgb = load_rgb(rgb_path)
        if depth.ndim != 2 or rgb.shape[:2] != depth.shape:
            raise ValueError(
                f"RGB/depth shape mismatch for {metadata_path.name}: rgb={rgb.shape}, depth={depth.shape}"
            )

        height, width = depth.shape
        image_width = int(document.get("img_w", width))
        image_height = int(document.get("img_h", height))
        if (image_height, image_width) != (height, width):
            raise ValueError(
                f"Metadata/image shape mismatch for {metadata_path.name}: "
                f"metadata={(image_height, image_width)}, image={(height, width)}"
            )
        camera_angle_x = float(document["camera_angle_x"])
        focal = 0.5 * image_width / np.tan(0.5 * camera_angle_x)
        transform = np.asarray(frame["transform_matrix"], dtype=np.float64)
        if transform.shape != (4, 4):
            raise ValueError(f"Expected a 4x4 transform matrix in {metadata_path}")

        valid = np.isfinite(depth) & (depth > 0.0) & (depth < depth_threshold)
        flat_indices = np.flatnonzero(valid)
        if flat_indices.size == 0:
            raise RuntimeError(f"No valid first-frame depth pixels in {metadata_path.name}")
        valid_pixels += int(flat_indices.size)
        used_views += 1

        priorities = rng.random(flat_indices.size)
        if flat_indices.size > max_points:
            selected = np.argpartition(priorities, max_points - 1)[:max_points]
            flat_indices = flat_indices[selected]
            priorities = priorities[selected]

        rows, columns = np.divmod(flat_indices, width)
        z = depth.reshape(-1)[flat_indices]
        camera_points = np.column_stack(
            (
                (columns - image_width / 2.0) * z / focal,
                -(rows - image_height / 2.0) * z / focal,
                -z,
            )
        )
        world_points = camera_points @ transform[:3, :3].T + transform[:3, 3]
        colors = rgb.reshape(-1, 3)[flat_indices]

        kept_keys = np.concatenate((kept_keys, priorities))
        kept_points = np.concatenate((kept_points, world_points), axis=0)
        kept_colors = np.concatenate((kept_colors, colors), axis=0)
        if kept_keys.size > max_points:
            selected = np.argpartition(kept_keys, max_points - 1)[:max_points]
            kept_keys = kept_keys[selected]
            kept_points = kept_points[selected]
            kept_colors = kept_colors[selected]

    if used_views != len(metadata_files):
        raise RuntimeError(f"Used {used_views}/{len(metadata_files)} static views")
    write_binary_ply(output, kept_points, kept_colors)
    if not valid_ply(output):
        raise RuntimeError(f"Generated PLY did not pass validation: {output}")
    return {
        "views": used_views,
        "valid_pixels": valid_pixels,
        "points": int(len(kept_points)),
        "depth_threshold": depth_threshold,
        "output": str(output),
    }


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("render_dir", type=Path)
    parser.add_argument("--output", type=Path, default=None)
    parser.add_argument("--depth-threshold", type=float, default=20.0)
    parser.add_argument("--max-points", type=int, default=100_000)
    parser.add_argument("--seed", type=int, default=0)
    return parser.parse_args()


def main() -> int:
    args = parse_args()
    result = generate_points3d(
        args.render_dir,
        args.output,
        args.depth_threshold,
        args.max_points,
        args.seed,
    )
    print(json.dumps(result, indent=2, sort_keys=True))
    return 0


if __name__ == "__main__":
    raise SystemExit(main())