"""Rendering kernels extracted from the local RoboSnap/Marble pipeline.
No original source files are modified. Camera-gauge normalization and SH0 match
accepted GS renders; foreground uses the original pyrender material settings.
"""
from __future__ import annotations
import json
import math
import os
import sys
from pathlib import Path
from typing import Any
os.environ.setdefault("PYOPENGL_PLATFORM", "egl")
os.environ['PATH'] = str(Path(sys.executable).parent) + os.pathsep + os.environ.get('PATH', '')

class ContractError(ValueError):
    pass

def load_gaussians(path: Path, device: str):
    import numpy as np
    import torch
    from plyfile import PlyData

    vertices = PlyData.read(str(path))["vertex"].data
    names = set(vertices.dtype.names or ())
    required = {
        "x",
        "y",
        "z",
        "f_dc_0",
        "f_dc_1",
        "f_dc_2",
        "opacity",
        "scale_0",
        "scale_1",
        "scale_2",
        "rot_0",
        "rot_1",
        "rot_2",
        "rot_3",
    }
    missing = sorted(required - names)
    if missing:
        raise ValueError(f"{path} is not a Gaussian PLY; missing: {', '.join(missing)}")

    stack = lambda keys: np.column_stack([vertices[key].astype(np.float32, copy=False) for key in keys])
    means_np = stack(["x", "y", "z"])
    scales_np = np.exp(stack(["scale_0", "scale_1", "scale_2"]))
    quats_np = stack(["rot_0", "rot_1", "rot_2", "rot_3"])
    quats_np /= np.clip(np.linalg.norm(quats_np, axis=1, keepdims=True), 1e-12, None)
    opacities_np = 1.0 / (1.0 + np.exp(-vertices["opacity"].astype(np.float32, copy=False)))
    dc = stack(["f_dc_0", "f_dc_1", "f_dc_2"])
    rest_names = sorted(
        (name for name in names if name.startswith("f_rest_")),
        key=lambda name: int(name.rsplit("_", 1)[1]),
    )
    if rest_names:
        rest = stack(rest_names)
        if rest.shape[1] % 3:
            raise ValueError(f"Unexpected SH field count in {path}: {rest.shape[1]}")
        rest = rest.reshape(len(rest), 3, rest.shape[1] // 3)
        harmonics_np = np.concatenate([dc[:, :, None], rest], axis=2).transpose(0, 2, 1)
    else:
        harmonics_np = dc[:, None, :]

    to_device = lambda array: torch.from_numpy(np.ascontiguousarray(array)).to(device=device)
    return {
        "means": to_device(means_np),
        "scales": to_device(scales_np),
        "quats": to_device(quats_np),
        "opacities": to_device(opacities_np),
        "harmonics": to_device(harmonics_np),
        "means_np": means_np,
        "dc_np": dc,
    }

def render_gaussians(gaussians, w2c, k, width: int, height: int, background_color):
    import numpy as np
    import torch
    from gsplat import rasterization

    view = torch.from_numpy(np.asarray(w2c, dtype=np.float32)).to(gaussians["means"].device)[None]
    intrinsics = torch.from_numpy(np.asarray(k, dtype=np.float32)).to(gaussians["means"].device)[None]
    background = torch.tensor(background_color, dtype=torch.float32, device=gaussians["means"].device)[None]
    degree = int(round(gaussians["harmonics"].shape[1] ** 0.5)) - 1
    rendered, alpha, _ = rasterization(
        means=gaussians["means"],
        quats=gaussians["quats"],
        scales=gaussians["scales"],
        opacities=gaussians["opacities"],
        colors=gaussians["harmonics"],
        viewmats=view,
        Ks=intrinsics,
        width=width,
        height=height,
        backgrounds=background,
        render_mode="RGB+ED",
        packed=False,
        sh_degree=degree,
    )
    rgb = rendered[0, :, :, :3].clamp(0.0, 1.0).detach().cpu().numpy()
    depth = rendered[0, :, :, 3].detach().cpu().numpy()
    coverage = alpha[0, :, :, 0].detach().cpu().numpy()
    return rgb, depth, coverage


def load_camera(path: Path, frame_index: int, width: int | None, height: int | None):
    import numpy as np

    data = np.load(path)
    if "w2c_render" not in data:
        raise KeyError(f"w2c_render is missing from {path}")
    intrinsic_key = next(
        (key for key in ("intrinsics_render", "intrinsics_vipe", "intrinsics_da3_pred") if key in data),
        None,
    )
    if intrinsic_key is None:
        raise KeyError(f"No render intrinsics found in {path}")
    w2cs = np.asarray(data["w2c_render"], dtype=np.float64)
    intrinsics = np.asarray(data[intrinsic_key], dtype=np.float64)
    idx = max(0, min(int(frame_index), len(w2cs) - 1))
    w2c = w2cs[idx]
    if w2c.shape == (3, 4):
        padded = np.eye(4, dtype=np.float64)
        padded[:3, :4] = w2c
        w2c = padded
    k = intrinsics[min(idx, len(intrinsics) - 1)].copy()
    source_width = max(1, int(round(2.0 * float(k[0, 2]))))
    source_height = max(1, int(round(2.0 * float(k[1, 2]))))
    target_width = int(width or source_width)
    target_height = int(height or source_height)
    if (target_width, target_height) != (source_width, source_height):
        k[0, :] *= target_width / source_width
        k[1, :] *= target_height / source_height
    return w2c, k, target_width, target_height, idx, intrinsic_key


def load_foreground_intrinsics(path: Path, width: int, height: int):
    import numpy as np

    data = json.loads(path.read_text(encoding="utf-8"))
    if "intrinsic_original_pixels" not in data or "original_size_wh" not in data:
        raise KeyError(f"VGGT original-pixel intrinsics are missing from {path}")
    k = np.asarray(data["intrinsic_original_pixels"], dtype=np.float64).copy()
    source_width, source_height = (int(value) for value in data["original_size_wh"])
    k[0, :] *= width / source_width
    k[1, :] *= height / source_height
    return k, "intrinsic_original_pixels"


def load_gravity_camera(path: Path, w2c_background):
    import numpy as np

    data = json.loads(path.read_text(encoding="utf-8"))
    transform = np.asarray(data["transform_gravity_from_background"], dtype=np.float64)
    return np.asarray(w2c_background, dtype=np.float64) @ np.linalg.inv(transform), data


def render_mesh(path: Path, w2c, k, width: int, height: int):
    import numpy as np
    import pyrender
    import trimesh

    mesh_scene = trimesh.load(str(path), force="scene", process=False)
    if not isinstance(mesh_scene, trimesh.Scene):
        wrapped = trimesh.Scene()
        wrapped.add_geometry(mesh_scene)
        mesh_scene = wrapped
    scene = pyrender.Scene.from_trimesh_scene(
        mesh_scene,
        bg_color=np.array([0.0, 0.0, 0.0, 0.0]),
        ambient_light=np.array([0.75, 0.75, 0.75]),
    )
    camera = pyrender.IntrinsicsCamera(
        fx=float(k[0, 0]),
        fy=float(k[1, 1]),
        cx=float(k[0, 2]),
        cy=float(k[1, 2]),
        znear=0.01,
        zfar=10000.0,
    )
    cv_to_gl = np.diag([1.0, -1.0, -1.0, 1.0])
    camera_pose = np.linalg.inv(w2c) @ cv_to_gl
    scene.add(camera, pose=camera_pose)
    scene.add(pyrender.DirectionalLight(color=np.ones(3), intensity=2.0), pose=camera_pose)
    renderer = pyrender.OffscreenRenderer(viewport_width=width, viewport_height=height)
    try:
        color, depth = renderer.render(
            scene,
            flags=pyrender.RenderFlags.RGBA | pyrender.RenderFlags.SKIP_CULL_FACES,
        )
    finally:
        renderer.delete()
    return color.astype(np.float32) / 255.0, depth.astype(np.float32)


def stack_fields(vertices: Any, names: list[str]) -> Any:
    import numpy as np

    return np.column_stack(
        [vertices[name].astype(np.float32, copy=False) for name in names]
    )


def render_gaussian_vertices(
    vertices: Any,
    w2c: Any,
    intrinsic: Any,
    width: int,
    height: int,
    device: str,
) -> tuple[Any, Any, Any]:
    import numpy as np
    import torch
    from gsplat import rasterization

    means_np = stack_fields(vertices, ["x", "y", "z"])
    scales_np = np.exp(stack_fields(vertices, ["scale_0", "scale_1", "scale_2"]))
    quats_np = stack_fields(vertices, ["rot_0", "rot_1", "rot_2", "rot_3"])
    quat_norm = np.linalg.norm(quats_np, axis=1, keepdims=True)
    if not np.isfinite(means_np).all() or not np.isfinite(scales_np).all():
        raise ContractError("Gaussian means/scales contain non-finite values")
    if np.any(quat_norm <= 1e-12) or not np.isfinite(quat_norm).all():
        raise ContractError("Gaussian quaternion is zero or non-finite")
    quats_np /= quat_norm
    opacity_np = 1.0 / (
        1.0 + np.exp(-vertices["opacity"].astype(np.float32, copy=False))
    )
    harmonics_np = stack_fields(vertices, ["f_dc_0", "f_dc_1", "f_dc_2"])[
        :, None, :
    ]
    to_device = lambda array: torch.from_numpy(np.ascontiguousarray(array)).to(device=device)
    tensors = {
        "means": to_device(means_np),
        "scales": to_device(scales_np),
        "quats": to_device(quats_np),
        "opacities": to_device(opacity_np),
        "colors": to_device(harmonics_np),
    }
    view = torch.from_numpy(np.asarray(w2c, dtype=np.float32))[None].to(device=device)
    k_tensor = torch.from_numpy(np.asarray(intrinsic, dtype=np.float32))[None].to(device=device)
    background = torch.tensor([[0.96, 0.96, 0.96]], dtype=torch.float32, device=device)
    with torch.inference_mode():
        rendered, alpha, _ = rasterization(
            means=tensors["means"],
            quats=tensors["quats"],
            scales=tensors["scales"],
            opacities=tensors["opacities"],
            colors=tensors["colors"],
            viewmats=view,
            Ks=k_tensor,
            width=int(width),
            height=int(height),
            backgrounds=background,
            render_mode="RGB+ED",
            packed=False,
            sh_degree=0,
        )
    output = rendered[0].detach().cpu().numpy()
    coverage = alpha[0, :, :, 0].detach().cpu().numpy()
    rgb = np.clip(output[:, :, :3], 0.0, 1.0)
    depth = output[:, :, 3]
    del tensors, rendered, alpha, output, view, k_tensor, background
    if device.startswith("cuda"):
        torch.cuda.empty_cache()
    return rgb, depth, coverage


def quaternion_multiply_wxyz(first: Any, second: Any) -> Any:
    import numpy as np

    w1, x1, y1, z1 = np.moveaxis(np.asarray(first), -1, 0)
    w2, x2, y2, z2 = np.moveaxis(np.asarray(second), -1, 0)
    return np.column_stack(
        [
            w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
            w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
            w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2,
            w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2,
        ]
    )


def normalize_reloaded_output_for_render(
    vertices: Any,
    extrinsic_4x4: Any,
    intrinsic: Any,
    gauge_scale: float,
) -> tuple[Any, dict[str, Any]]:
    """Numerically normalize a reloaded output PLY for an equivalent camera render."""

    import numpy as np
    from scipy.spatial.transform import Rotation

    if not math.isfinite(gauge_scale) or gauge_scale <= 0.0:
        raise ContractError("render normalization requires a finite positive gauge")
    extrinsic = np.asarray(extrinsic_4x4, dtype=np.float64)
    intrinsic = np.asarray(intrinsic, dtype=np.float64)
    normalized = vertices.copy()
    xyz_world = stack_fields(vertices, ["x", "y", "z"]).astype(np.float64)
    xyz_camera = (extrinsic[:3, :3] @ xyz_world.T).T + extrinsic[:3, 3]
    xyz_normalized = xyz_camera / gauge_scale
    for index, name in enumerate(("x", "y", "z")):
        normalized[name] = xyz_normalized[:, index].astype(normalized[name].dtype)

    log_gauge = math.log(gauge_scale)
    for name in ("scale_0", "scale_1", "scale_2"):
        normalized[name] = (
            vertices[name].astype(np.float64) - log_gauge
        ).astype(normalized[name].dtype)

    quaternions_world = stack_fields(
        vertices, ["rot_0", "rot_1", "rot_2", "rot_3"]
    ).astype(np.float64)
    quaternions_world /= np.linalg.norm(
        quaternions_world, axis=1, keepdims=True
    )
    xyzw = Rotation.from_matrix(extrinsic[:3, :3]).as_quat()
    quaternion_camera_from_world = np.asarray(
        [[xyzw[3], xyzw[0], xyzw[1], xyzw[2]]],
        dtype=np.float64,
    )
    quaternions_camera = quaternion_multiply_wxyz(
        quaternion_camera_from_world, quaternions_world
    )
    quaternions_camera /= np.linalg.norm(
        quaternions_camera, axis=1, keepdims=True
    )
    for index, name in enumerate(("rot_0", "rot_1", "rot_2", "rot_3")):
        normalized[name] = quaternions_camera[:, index].astype(
            normalized[name].dtype
        )

    sample = np.linspace(
        0, len(vertices) - 1, min(20000, len(vertices)), dtype=np.int64
    )
    before = xyz_camera[sample]
    after = np.column_stack(
        [
            normalized[name][sample].astype(np.float64)
            for name in ("x", "y", "z")
        ]
    )
    reconstructed = gauge_scale * after
    relative_position_error = np.linalg.norm(
        reconstructed - before, axis=1
    ) / np.maximum(np.linalg.norm(before, axis=1), 1e-8)
    valid = (
        np.isfinite(before).all(axis=1)
        & np.isfinite(after).all(axis=1)
        & (np.abs(before[:, 2]) > 1e-6)
        & (np.abs(after[:, 2]) > 1e-6)
    )
    if int(valid.sum()) < 100:
        raise ContractError("too few finite points for render-normalization proof")

    def project(points: Any) -> Any:
        return np.column_stack(
            [
                intrinsic[0, 0] * points[:, 0] / points[:, 2] + intrinsic[0, 2],
                intrinsic[1, 1] * points[:, 1] / points[:, 2] + intrinsic[1, 2],
            ]
        )

    projection_error = np.linalg.norm(
        project(before[valid]) - project(after[valid]), axis=1
    )
    normalized_quaternions = np.column_stack(
        [
            normalized[name][sample].astype(np.float64)
            for name in ("rot_0", "rot_1", "rot_2", "rot_3")
        ]
    )
    normalized_quaternions /= np.linalg.norm(
        normalized_quaternions, axis=1, keepdims=True
    )
    expected_orientation = np.einsum(
        "ij,njk->nik",
        extrinsic[:3, :3],
        Rotation.from_quat(
            quaternions_world[sample][:, [1, 2, 3, 0]]
        ).as_matrix(),
    )
    actual_orientation = Rotation.from_quat(
        normalized_quaternions[:, [1, 2, 3, 0]]
    ).as_matrix()
    relative_orientation = np.einsum(
        "nij,nkj->nik", expected_orientation, actual_orientation
    )
    orientation_error_deg = np.rad2deg(
        Rotation.from_matrix(relative_orientation).magnitude()
    )
    scale_reconstruction_error = np.max(
        np.abs(
            np.column_stack(
                [
                    normalized[name][sample].astype(np.float64)
                    + log_gauge
                    - vertices[name][sample].astype(np.float64)
                    for name in ("scale_0", "scale_1", "scale_2")
                ]
            )
        ),
        axis=1,
    )
    return normalized, {
        "source": "reloaded aligned output PLY",
        "source_reloaded_after_full_resolution_write": True,
        "normalization": (
            "world means -> camera means / gauge; log-scales -= log(gauge); "
            "quaternions left-multiplied by camera rotation; identity view"
        ),
        "camera_centered_numerical_normalization_scale": gauge_scale,
        "single_view_projection_semantics_changed": False,
        "output_file_modified_by_normalization": False,
        "gaussian_count": len(vertices),
        "sample_count": len(sample),
        "finite_projection_samples": int(valid.sum()),
        "projection_error_p99_px": float(np.quantile(projection_error, 0.99)),
        "projection_error_max_px": float(projection_error.max()),
        "relative_position_error_p99": float(
            np.quantile(relative_position_error, 0.99)
        ),
        "relative_position_error_max": float(relative_position_error.max()),
        "orientation_error_p99_deg": float(
            np.quantile(orientation_error_deg, 0.99)
        ),
        "orientation_error_max_deg": float(orientation_error_deg.max()),
        "log_scale_reconstruction_error_max": float(
            scale_reconstruction_error.max()
        ),
    }