#!/usr/bin/env python3
"""
Generate delta CSV from a directory of frame files.

Outputs left_delta and right_delta in seconds. Nulls only on scene change.

Usage:
    python clean_delta.py /path/to/rgb_dir -o delta.csv
    python clean_delta.py /path/to/rgb_dir -o delta.csv --fps-json fps.json
"""

import argparse
import csv
import json
from pathlib import Path

DEFAULT_FPS: dict[str, float] = {
    # part0 scenes
    "atanasie_DJI_0652_full": 29.97,
    "gradistei_DJI_0787_0788_0789_combined_sliced_3510_13110": 29.97,
    "herculane_DJI_0021_full": 29.97,
    "jupiter_DJI_0703_0704_0705_combined_sliced_10650_21715": 29.97,
    "olanesti_DJI_0416_full": 29.97,
    "petrova_DJI_0525_0526_combined_sliced_2850_11850": 29.97,
    "slanic_DJI_0956_0957_combined_sliced_780_9780": 29.97,
    # part1 scenes
    # (slanic_DJI_0956_0957_combined_sliced_780_9780 already included above)
}


def parse_frame_name(name: str) -> tuple[str, int] | None:
    """
    Parse 'scene_prefix_123' into ('scene_prefix', 123).
    Returns None if name is empty or doesn't end with a number.
    """
    if not name:
        return None

    parts = name.rsplit("_", maxsplit=1)
    if len(parts) != 2:
        return None

    scene_prefix, frame_number_str = parts
    if not frame_number_str.isdigit():
        return None

    return scene_prefix, int(frame_number_str)


def get_fps(scene: str, fps_map: dict[str, float]) -> float:
    """Get FPS for a scene, default to 29.97 if not found."""
    return fps_map.get(scene, 29.97)


def compute_delta_seconds(
    current: str,
    neighbor: str,
    fps_map: dict[str, float],
) -> float | None:
    """
    Compute delta in seconds between current and neighbor.
    Returns None if different scenes.
    """
    current_stem = Path(current).stem
    neighbor_stem = Path(neighbor).stem

    current_parsed = parse_frame_name(current_stem)
    neighbor_parsed = parse_frame_name(neighbor_stem)

    if current_parsed is None or neighbor_parsed is None:
        return None

    current_scene, current_frame = current_parsed
    neighbor_scene, neighbor_frame = neighbor_parsed

    if current_scene != neighbor_scene:
        return None

    fps = get_fps(current_scene, fps_map)
    frame_delta = neighbor_frame - current_frame
    return round(frame_delta / fps, 6)


def load_frame_names(rgb_directory: Path) -> list[str]:
    """Load and sort frame names from rgb directory."""
    frame_names: list[str] = []
    for file_path in rgb_directory.iterdir():
        if file_path.is_file():
            frame_names.append(file_path.name)

    def sort_key(full_name: str) -> tuple[str, int]:
        stem = Path(full_name).stem
        parsed = parse_frame_name(stem)
        if parsed is None:
            return (full_name, 0)
        return parsed

    return sorted(frame_names, key=sort_key)


def generate_delta_csv(
    rgb_directory: Path,
    output_path: Path,
    fps_map: dict[str, float],
) -> None:
    """Generate delta CSV from rgb directory of frames."""
    frame_names = load_frame_names(rgb_directory)
    total_frames = len(frame_names)

    if total_frames == 0:
        print(f"No frames found in {rgb_directory}")
        return

    nulled_left = 0
    nulled_right = 0

    rows: list[dict[str, str | float]] = []

    for i, name in enumerate(frame_names):
        left_name = frame_names[i - 1] if i > 0 else ""
        right_name = frame_names[i + 1] if i < total_frames - 1 else ""

        row: dict[str, str | float] = {"name": name}

        if left_name:
            left_delta = compute_delta_seconds(name, left_name, fps_map)
            if left_delta is not None:
                row["left_name"] = left_name
                row["left_delta"] = left_delta
            else:
                row["left_name"] = ""
                row["left_delta"] = ""
                nulled_left += 1
        else:
            row["left_name"] = ""
            row["left_delta"] = ""

        if right_name:
            right_delta = compute_delta_seconds(name, right_name, fps_map)
            if right_delta is not None:
                row["right_name"] = right_name
                row["right_delta"] = right_delta
            else:
                row["right_name"] = ""
                row["right_delta"] = ""
                nulled_right += 1
        else:
            row["right_name"] = ""
            row["right_delta"] = ""

        rows.append(row)

    fieldnames = ["name", "left_name", "left_delta", "right_name", "right_delta"]
    with open(output_path, "w", newline="") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)

    print(f"Created {output_path}")
    print(f"Total frames: {total_frames}")
    print(f"Nulled left: {nulled_left} (scene change)")
    print(f"Nulled right: {nulled_right} (scene change)")


def main() -> None:
    parser = argparse.ArgumentParser(description="Generate delta CSV from frame files.")
    parser.add_argument("rgb_directory", type=Path, help="RGB directory containing frame files (e.g., .../rgb/part0)")
    parser.add_argument("-o", "--output", type=Path, default=Path("delta.csv"), help="Output CSV path")
    parser.add_argument("--fps-json", type=Path, help="JSON file mapping scene prefix to FPS")

    args = parser.parse_args()

    fps_map = DEFAULT_FPS.copy()
    if args.fps_json:
        with open(args.fps_json) as f:
            fps_map.update(json.load(f))

    generate_delta_csv(args.rgb_directory, args.output, fps_map)


if __name__ == "__main__":
    main()