import cv2
import numpy as np
import json
from pathlib import Path


def load_depth(depth_path):
    depth = cv2.imread(str(depth_path), cv2.IMREAD_UNCHANGED)
    if depth is None:
        raise FileNotFoundError(f"Cannot read: {depth_path}")
    if depth.dtype != np.uint16:
        raise ValueError(f"Expected uint16, got {depth.dtype}. Use cv2.IMREAD_UNCHANGED!")
    return depth


def display_depth(depth_path, wait_key=0):
    depth = load_depth(depth_path)
    mask = depth > 0
    depth_vis = np.zeros_like(depth, dtype=np.uint8)
    if mask.any():
        valid = depth[mask].astype(np.float32)
        depth_vis[mask] = ((valid - valid.min()) /
                           (valid.max() - valid.min()) * 255).astype(np.uint8)
    depth_color = cv2.applyColorMap(depth_vis, cv2.COLORMAP_JET)
    depth_color[~mask] = [0, 0, 0]
    cv2.imshow("Depth (JET)", depth_color)
    cv2.imshow("Depth (Gray)", depth_vis)
    cv2.waitKey(wait_key)
    cv2.destroyAllWindows()
    return depth


def load_camera_intrinsics(scene_camera_path, frame_id=1):
    with open(scene_camera_path) as f:
        sc = json.load(f)
    cam = sc[str(frame_id)]
    K = np.array(cam["cam_K"]).reshape(3, 3)
    depth_scale = cam.get("depth_scale", 1.0)
    return K, depth_scale


def load_pose_gt(scene_gt_path, frame_id=1, obj_idx=0):
    with open(scene_gt_path) as f:
        sg = json.load(f)
    gt = sg[str(frame_id)][obj_idx]
    R = np.array(gt["cam_R_m2c"]).reshape(3, 3)
    t = np.array(gt["cam_t_m2c"])
    return R, t


def depth_to_pointcloud(depth, K, depth_scale=1.0):
    h, w = depth.shape
    fx, fy = K[0, 0], K[1, 1]
    cx, cy = K[0, 2], K[1, 2]
    u = np.arange(w)
    v = np.arange(h)
    uu, vv = np.meshgrid(u, v)
    z = depth.astype(np.float64) * depth_scale / 1000.0
    x = (uu - cx) * z / fx
    y = (vv - cy) * z / fy
    mask = depth > 0
    points = np.stack([x[mask], y[mask], z[mask]], axis=-1)
    return points


def project_points_to_image(points_3d, K, R, t):
    p_cam = R @ points_3d.T + t.reshape(3, 1)
    z = p_cam[2]
    valid = z > 0
    x_img = K[0, 0] * p_cam[0][valid] / z[valid] + K[0, 2]
    y_img = K[1, 1] * p_cam[1][valid] / z[valid] + K[1, 2]
    return np.stack([x_img, y_img], axis=-1)


if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("Usage: python huhb3d_utils.py <dataset_dir> [object_name]")
        sys.exit(1)

    dataset_dir = Path(sys.argv[1])
    obj_name = sys.argv[2] if len(sys.argv) > 2 else "flange"
    obj_dir = dataset_dir / obj_name

    print(f"Dataset: {dataset_dir}")
    print(f"Object:  {obj_name}")

    K, ds = load_camera_intrinsics(obj_dir / "scene_camera.json")
    print(f"Camera K:\n{K}")
    print(f"depth_scale: {ds}")

    R, t = load_pose_gt(obj_dir / "scene_gt.json")
    print(f"R_m2c:\n{R}")
    print(f"t_m2c: {t} mm")

    depth = load_depth(obj_dir / "depth/depth_0001.png")
    nz = depth[depth > 0]
    print(f"Depth range: [{nz.min()}, {nz.max()}] mm")

    pc = depth_to_pointcloud(depth, K, ds)
    print(f"Point cloud: {pc.shape[0]} points")

    display_depth(obj_dir / "depth/depth_0001.png")