#!/usr/bin/env python
"""Visualizes LiDAR->camera projection under ground-truth vs. decalibrated extrinsics.

For a chosen (sequence, frame), plots the LiDAR point cloud projected onto the
camera image side by side: ground truth on the left, one panel per selected
decalibration stage on the right, points colored by depth. Useful both as a
sanity check while generating the dataset and as a quick way to see how
severe each difficulty stage actually looks.

Requires the `viz` extra: pip install kitti-c2l[viz]

Usage:
    # Every stage found for one frame
    python scripts/visualize_projection.py --parquet data/train.parquet \\
        --kitti-raw-root /path/to/KITTI --sequence 01 --frame 0 --output overlay.png

    # A single specific row
    python scripts/visualize_projection.py --parquet data/train.parquet \\
        --kitti-raw-root /path/to/KITTI --sample-id 01_000000_stage1 --output overlay.png

    # Only stages 1 and 5, for a quick easy-vs-hard comparison
    python scripts/visualize_projection.py --parquet data/train.parquet \\
        --kitti-raw-root /path/to/KITTI --sequence 04 --frame 3 --stages 1,5 --output overlay.png
"""

from __future__ import annotations

import argparse
import sys
from pathlib import Path

import matplotlib

matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
import pyarrow.parquet as pq

sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "src"))

from kitti_c2l.geometry import project_to_image, transform_points  # noqa: E402
from kitti_c2l.loader.dataset import load_image, load_points_cm, row_extrinsic  # noqa: E402

MIN_DEPTH_CM = 200.0
MAX_DEPTH_CM = 8000.0


def _select_rows(
    table_rows: list[dict],
    sample_id: str | None,
    sequence: str | None,
    frame: int | None,
    stages: set[int] | None,
) -> list[dict]:
    if sample_id is not None:
        matches = [r for r in table_rows if r["sample_id"] == sample_id]
        if not matches:
            raise ValueError(f"No row with sample_id={sample_id!r}")
        return matches

    if sequence is not None and frame is not None:
        matches = [r for r in table_rows if r["sequence"] == sequence and r["frame_index"] == frame]
        if not matches:
            raise ValueError(f"No rows for sequence={sequence!r}, frame={frame}")
        if stages is not None:
            matches = [r for r in matches if r["stage"] in stages]
            if not matches:
                raise ValueError(f"No rows for sequence={sequence!r}, frame={frame}, stages={sorted(stages)}")
        return sorted(matches, key=lambda r: r["stage"])

    print("No --sample-id or --sequence/--frame given; using the first row in the file.", file=sys.stderr)
    return table_rows[:1]


def _project_valid(
    points_cm: np.ndarray, rotation: np.ndarray, translation_cm: np.ndarray, intrinsics: np.ndarray, width: int, height: int
) -> tuple[np.ndarray, np.ndarray]:
    """Returns (pixels (M, 2), depths_cm (M,)) for points that land in-frame within the valid depth range."""
    points_cam = transform_points(points_cm, rotation, translation_cm)
    pixels = project_to_image(points_cam, intrinsics)
    depths = points_cam[:, 2]

    valid = (
        (depths > MIN_DEPTH_CM)
        & (depths < MAX_DEPTH_CM)
        & (pixels[:, 0] >= 0)
        & (pixels[:, 0] < width)
        & (pixels[:, 1] >= 0)
        & (pixels[:, 1] < height)
    )
    return pixels[valid], depths[valid]


def _plot_panel(ax, image: np.ndarray, pixels: np.ndarray, depths: np.ndarray, title: str) -> None:
    ax.imshow(image)
    if pixels.shape[0] > 0:
        order = np.argsort(-depths)  # far first, so near points draw on top
        scatter = ax.scatter(
            pixels[order, 0], pixels[order, 1], c=depths[order] / 100.0, cmap="turbo", s=3, alpha=0.85
        )
        plt.colorbar(scatter, ax=ax, fraction=0.03, pad=0.01, label="depth (m)")
    ax.set_title(title, fontsize=9)
    ax.axis("off")


def visualize(
    parquet_path: str | Path,
    kitti_raw_root: str | Path,
    output_path: str | Path,
    sample_id: str | None = None,
    sequence: str | None = None,
    frame: int | None = None,
    stages: set[int] | None = None,
) -> Path:
    table_rows = pq.read_table(parquet_path).to_pylist()
    rows = _select_rows(table_rows, sample_id, sequence, frame, stages)

    n_cols = 1 + len(rows)  # ground truth + one panel per selected (sequence, frame, stage) row
    fig, axes = plt.subplots(1, n_cols, figsize=(5 * n_cols, 5))
    if n_cols == 1:
        axes = [axes]

    first_row = rows[0]
    image = load_image(kitti_raw_root, first_row)
    points_cm = load_points_cm(kitti_raw_root, first_row)
    width, height = int(first_row["image_width"]), int(first_row["image_height"])

    gt_rotation, gt_translation = row_extrinsic(first_row, use_ground_truth=True)
    gt_pixels, gt_depths = _project_valid(points_cm, gt_rotation, gt_translation, np.array(first_row["camera_intrinsics"]).reshape(3, 3), width, height)
    _plot_panel(axes[0], image, gt_pixels, gt_depths, f"Ground truth\nseq {first_row['sequence']} frame {first_row['frame_index']}")

    for ax, row in zip(axes[1:], rows, strict=True):
        rotation, translation = row_extrinsic(row, use_ground_truth=False)
        intrinsics = np.array(row["camera_intrinsics"]).reshape(3, 3)
        pixels, depths = _project_valid(points_cm, rotation, translation, intrinsics, width, height)
        title = f"Stage {row['stage']} (±{row['stage_max_rotation_deg']:g}°/±{row['stage_max_translation_cm']:g}cm)"
        _plot_panel(ax, image, pixels, depths, title)

    fig.tight_layout()
    output_path = Path(output_path)
    output_path.parent.mkdir(parents=True, exist_ok=True)
    fig.savefig(output_path, dpi=150)
    plt.close(fig)
    return output_path


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("--parquet", required=True, help="Path to a published {split}.parquet file.")
    parser.add_argument("--kitti-raw-root", required=True, help="Local KITTI raw root, see README.md.")
    parser.add_argument("--output", default="projection.png")
    parser.add_argument("--sample-id", default=None, help="Exact sample_id, e.g. 01_000000_stage1.")
    parser.add_argument("--sequence", default=None, help="Sequence id, e.g. 01. Use with --frame.")
    parser.add_argument("--frame", type=int, default=None, help="0-based frame index within the sequence.")
    parser.add_argument("--stages", default=None, help="Comma-separated stage ids to show, e.g. 1,5 (default: all found).")
    args = parser.parse_args()

    stages = {int(s) for s in args.stages.split(",")} if args.stages else None
    output_path = visualize(
        args.parquet,
        args.kitti_raw_root,
        args.output,
        sample_id=args.sample_id,
        sequence=args.sequence,
        frame=args.frame,
        stages=stages,
    )
    print(f"wrote {output_path}")
    return 0


if __name__ == "__main__":
    sys.exit(main())