"""
Test Preprocessing with Visualizations

Quick test of DROID preprocessing pipeline with visual output:
- Processes small number of episodes (5-10)
- Uses cartesian_position + refined_extrinsics filtering
- Generates visualization images showing projected tracks
- Saves NPZ files for inspection
"""

import numpy as np
import tensorflow_datasets as tfds
from pathlib import Path
import argparse
import cv2
import sys
from tqdm import tqdm
import os

# Force TensorFlow to use CPU to avoid GPU memory issues
os.environ['CUDA_VISIBLE_DEVICES'] = ''
os.environ['TF_FORCE_GPU_ALLOW_GROWTH'] = 'true'

# Add parent directory to path
sys.path.append(str(Path(__file__).parent.parent))

from utils.load_camera_calibration import CameraCalibrationLoader
from utils.franka_mesh_projection import FrankaMeshProjector


def visualize_tracks(img: np.ndarray,
                    tracks: np.ndarray,
                    visibility: np.ndarray,
                    title: str = "") -> np.ndarray:
    """
    Visualize 32 tracks on image.

    Args:
        img: RGB image (H, W, 3)
        tracks: Track points (32, 2)
        visibility: Visibility mask (32,)
        title: Title for image

    Returns:
        Annotated image
    """
    viz = img.copy()

    # Draw grid points (0-24) in blue
    for i in range(25):
        if visibility[i]:
            pt = tuple(tracks[i].astype(int))
            cv2.circle(viz, pt, 4, (0, 0, 255), -1)

    # Draw mesh points (25-31) in green
    for i in range(25, 32):
        if visibility[i]:
            pt = tuple(tracks[i].astype(int))
            cv2.circle(viz, pt, 5, (0, 255, 0), -1)
            cv2.putText(viz, str(i-25), (pt[0]+7, pt[1]-7),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.4, (0, 255, 0), 1)

    # Add title
    cv2.putText(viz, title, (10, 30),
               cv2.FONT_HERSHEY_SIMPLEX, 0.8, (255, 255, 255), 2)

    # Add statistics
    visible_grid = np.sum(visibility[:25])
    visible_mesh = np.sum(visibility[25:])
    cv2.putText(viz, f"Grid: {visible_grid}/25  Mesh: {visible_mesh}/7", (10, 60),
               cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 0), 1)

    return viz


def test_preprocessing(droid_path: str,
                      calib_dir: str,
                      output_dir: str,
                      num_episodes: int = 5,
                      use_cartesian: bool = True,
                      require_refined: bool = True):
    """
    Test preprocessing with visualizations.

    Args:
        droid_path: Path to DROID RLDS dataset
        calib_dir: Path to camera calibration directory
        output_dir: Output directory for test results
        num_episodes: Number of episodes to process
        use_cartesian: Use cartesian_position (vs FK)
        require_refined: Require refined_extrinsics
    """
    print("=" * 80)
    print("DROID Preprocessing Test with Visualizations")
    print("=" * 80)
    print(f"  Output: {output_dir}")
    print(f"  Episodes: {num_episodes}")
    print(f"  Projection: {'cartesian_position' if use_cartesian else 'joint_position (FK)'}")
    print(f"  Require refined: {require_refined}")
    print()

    # Create output directories
    output_path = Path(output_dir)
    npz_path = output_path / "npz_files"
    viz_path = output_path / "visualizations"
    npz_path.mkdir(parents=True, exist_ok=True)
    viz_path.mkdir(parents=True, exist_ok=True)

    # Initialize tools
    calib_loader = CameraCalibrationLoader(calib_dir)
    projector = FrankaMeshProjector(use_gui=False)

    # Load RLDS dataset
    print("Loading DROID dataset...")
    builder = tfds.builder_from_directory(droid_path)
    dataset = builder.as_dataset(split='train')

    # Get list of all calibration files for UUID matching
    calib_path = Path(calib_dir)
    calib_files = sorted(calib_path.glob("*_cameras.json"))
    uuid_list = [f.stem.replace('_cameras', '') for f in calib_files]
    print(f"Found {len(uuid_list)} camera calibration files")

    # Filter to refined only
    if require_refined:
        refined_uuids = [uuid for uuid in uuid_list if calib_loader.has_refined_extrinsics(uuid)]
        print(f"  {len(refined_uuids)}/{len(uuid_list)} have refined_extrinsics ({100*len(refined_uuids)/len(uuid_list):.1f}%)")
        uuid_list = refined_uuids

    # Process episodes
    processed = 0
    skipped = 0
    skipped_reasons = {
        'no_uuid': 0,
        'no_calib': 0,
        'decode_error': 0,
        'other': 0
    }

    pbar = tqdm(total=num_episodes, desc="Processing")

    for episode_idx, episode in enumerate(dataset):
        if processed >= num_episodes:
            break

        try:
            # Try to match UUID first (before loading steps)
            uuid = uuid_list[episode_idx % len(uuid_list)]

            # Load calibration
            try:
                dual_params = calib_loader.get_dual_view_params(
                    uuid,
                    param_type='refined',
                    require_refined=require_refined
                )

                if dual_params is None:
                    skipped += 1
                    skipped_reasons['no_calib'] += 1
                    continue

            except Exception as e:
                skipped += 1
                skipped_reasons['no_calib'] += 1
                continue

            # IMPORTANT: Don't call list() on episode['steps'] - iterate directly
            # This avoids loading entire episode into memory
            all_tracks_ext = []
            all_tracks_wrist = []
            all_vis_ext = []
            all_vis_wrist = []
            all_images_ext = []
            all_images_wrist = []

            decode_failed = False
            step_count = 0
            max_steps_per_episode = 30  # Limit to 30 steps for testing

            # Iterate steps incrementally without loading all at once
            for step_idx, step in enumerate(episode['steps']):
                # Limit steps per episode
                if step_idx >= max_steps_per_episode:
                    break

                step_count += 1
                # Get robot state
                if use_cartesian:
                    cart_pos = step['observation']['cartesian_position'].numpy()
                else:
                    joint_pos = step['observation']['joint_position'].numpy()

                # Load images
                img_ext_bytes = step['observation']['exterior_image_1_left'].numpy()
                img_ext = cv2.imdecode(np.frombuffer(img_ext_bytes, dtype=np.uint8), cv2.IMREAD_COLOR)

                img_wrist_bytes = step['observation']['wrist_image_left'].numpy()
                img_wrist = cv2.imdecode(np.frombuffer(img_wrist_bytes, dtype=np.uint8), cv2.IMREAD_COLOR)

                if img_ext is None or img_wrist is None:
                    decode_failed = True
                    break

                # Resize and convert
                img_ext = cv2.resize(img_ext, (448, 448))
                img_ext = cv2.cvtColor(img_ext, cv2.COLOR_BGR2RGB)
                all_images_ext.append(img_ext)

                img_wrist = cv2.resize(img_wrist, (448, 448))
                img_wrist = cv2.cvtColor(img_wrist, cv2.COLOR_BGR2RGB)
                all_images_wrist.append(img_wrist)

                # Project tracks
                K_ext, E_ext = dual_params['exterior_1']
                K_wrist, E_wrist = dual_params['wrist']

                if use_cartesian:
                    tracks_ext, vis_ext = projector.project_32_points_cartesian(
                        cart_pos, K_ext, E_ext, img_h=448, img_w=448, rotation_format='euler_xyz'
                    )
                    tracks_wrist, vis_wrist = projector.project_32_points_cartesian(
                        cart_pos, K_wrist, E_wrist, img_h=448, img_w=448, rotation_format='euler_xyz'
                    )
                else:
                    tracks_ext, vis_ext = projector.project_32_points(
                        joint_pos, K_ext, E_ext, img_h=448, img_w=448
                    )
                    tracks_wrist, vis_wrist = projector.project_32_points(
                        joint_pos, K_wrist, E_wrist, img_h=448, img_w=448
                    )

                all_tracks_ext.append(tracks_ext)
                all_tracks_wrist.append(tracks_wrist)
                all_vis_ext.append(vis_ext)
                all_vis_wrist.append(vis_wrist)

                # Create visualizations for first, middle, and last frames
                viz_indices = [0, max_steps_per_episode//2, max_steps_per_episode-1]
                if step_idx in viz_indices:
                    viz_ext = visualize_tracks(
                        img_ext,
                        tracks_ext,
                        vis_ext,
                        title=f"Episode {processed} | Frame {step_idx} | Exterior"
                    )
                    viz_wrist = visualize_tracks(
                        img_wrist,
                        tracks_wrist,
                        vis_wrist,
                        title=f"Episode {processed} | Frame {step_idx} | Wrist"
                    )

                    # Save visualizations
                    cv2.imwrite(
                        str(viz_path / f"ep{processed:03d}_frame{step_idx:04d}_exterior.jpg"),
                        cv2.cvtColor(viz_ext, cv2.COLOR_RGB2BGR)
                    )
                    cv2.imwrite(
                        str(viz_path / f"ep{processed:03d}_frame{step_idx:04d}_wrist.jpg"),
                        cv2.cvtColor(viz_wrist, cv2.COLOR_RGB2BGR)
                    )

            if decode_failed:
                skipped += 1
                skipped_reasons['decode_error'] += 1
                continue

            # Skip if too few steps
            if step_count < 10:
                skipped += 1
                skipped_reasons['other'] += 1
                continue

            # Convert to arrays
            tracks_ext = np.array(all_tracks_ext)
            tracks_wrist = np.array(all_tracks_wrist)
            vis_ext = np.array(all_vis_ext)
            vis_wrist = np.array(all_vis_wrist)
            images_ext = np.array(all_images_ext)
            images_wrist = np.array(all_images_wrist)

            # Get language instruction from first stored step
            language = "unknown"  # Default if not available

            # Save NPZ
            npz_file = npz_path / f"episode_{processed:03d}.npz"
            np.savez_compressed(
                npz_file,
                tracks_exterior=tracks_ext,
                tracks_wrist=tracks_wrist,
                vis_exterior=vis_ext,
                vis_wrist=vis_wrist,
                images_exterior=images_ext,
                images_wrist=images_wrist,
                language=language,
                uuid=uuid,
                num_steps=step_count
            )

            processed += 1
            pbar.update(1)

        except Exception as e:
            print(f"\nError processing episode {episode_idx}: {e}")
            skipped += 1
            skipped_reasons['other'] += 1
            continue

    pbar.close()

    # Print summary
    print("\n" + "=" * 80)
    print("Test Preprocessing Complete")
    print("=" * 80)
    print(f"  Processed: {processed} episodes")
    print(f"  Skipped: {skipped} episodes")
    print(f"    No calibration: {skipped_reasons['no_calib']}")
    print(f"    Decode error: {skipped_reasons['decode_error']}")
    print(f"    Other: {skipped_reasons['other']}")
    print()
    print(f"  NPZ files: {npz_path}")
    print(f"  Visualizations: {viz_path}")
    print(f"    ({processed * 6} images generated)")
    print("=" * 80)

    # Create montage of first episode visualizations
    if processed > 0:
        print("\nCreating summary montage...")
        montage_images = []

        # Look for existing visualization files for first episode
        viz_files = sorted(viz_path.glob("ep000_frame*_exterior.jpg"))

        for ext_file in viz_files[:3]:  # Take up to 3 frames
            wrist_file = ext_file.parent / ext_file.name.replace('_exterior.jpg', '_wrist.jpg')

            if ext_file.exists() and wrist_file.exists():
                img_ext = cv2.imread(str(ext_file))
                img_wrist = cv2.imread(str(wrist_file))
                if img_ext is not None and img_wrist is not None:
                    montage_images.append(np.hstack([img_ext, img_wrist]))

        if montage_images:
            montage = np.vstack(montage_images)
            montage_file = viz_path / "summary_montage.jpg"
            cv2.imwrite(str(montage_file), montage)
            print(f"  ✓ Saved summary montage: {montage_file}")


def main():
    parser = argparse.ArgumentParser(
        description="Test DROID preprocessing with visualizations"
    )

    parser.add_argument(
        '--droid-path',
        type=str,
        default='/mnt/kevin/data/droid/droid/1.0.0',
        help='Path to DROID RLDS dataset'
    )
    parser.add_argument(
        '--calib-dir',
        type=str,
        default='/root/workspace/code/wmrl/Dual-Dynamics-Models/DROID-main/vision/u/wenlongh/datasets/droid_v4/cameras',
        help='Path to camera calibration directory'
    )
    parser.add_argument(
        '--output-dir',
        type=str,
        default='/tmp/droid_preprocessing_test',
        help='Output directory for test results'
    )
    parser.add_argument(
        '--num-episodes',
        type=int,
        default=5,
        help='Number of episodes to process'
    )
    parser.add_argument(
        '--use-cartesian',
        action='store_true',
        default=True,
        help='Use cartesian_position (default: True)'
    )
    parser.add_argument(
        '--use-joints',
        dest='use_cartesian',
        action='store_false',
        help='Use joint_position with FK'
    )
    parser.add_argument(
        '--require-refined',
        action='store_true',
        default=True,
        help='Require refined_extrinsics (default: True)'
    )
    parser.add_argument(
        '--no-require-refined',
        dest='require_refined',
        action='store_false',
        help='Allow measured extrinsics'
    )

    args = parser.parse_args()

    test_preprocessing(
        args.droid_path,
        args.calib_dir,
        args.output_dir,
        args.num_episodes,
        args.use_cartesian,
        args.require_refined
    )


if __name__ == "__main__":
    main()