#!/usr/bin/env python3
"""Visualize lift encoder rewards on offline demo image sequences.

Uses the same subgoal-based reward logic as train_policy.py (not the simpler
single goal_emb distance from the handover reference script).
"""

import argparse
import csv
import glob
import os
import re
from typing import Dict, List, Tuple

import cv2
import matplotlib.pyplot as plt
import numpy as np
import torch

import utils
from train_policy import compute_progress_to_subgoal, preprocess_for_reward_model


DEFAULT_PRETRAIN_PATH = (
    "/home/lei/Documents/tong/irl4idm/multi-task-tcc-robosuite/experiments/"
    "pretrain_runs/dataset=mimicgen_algo=xirl_task=lift"
)
DEFAULT_DEMO_ROOT = (
    "/home/lei/Documents/tong/irl4idm/multi-task-tcc-robosuite/experiments/"
    "datasets/mimicgen/train/lift"
)
DEFAULT_DEMO_INDICES = list(range(10))


def default_demo_folders(indices=None):
    indices = DEFAULT_DEMO_INDICES if indices is None else indices
    return [os.path.join(DEFAULT_DEMO_ROOT, str(i)) for i in indices]


def natural_sort_key(path: str):
    name = os.path.basename(path)
    return [
        int(text) if text.isdigit() else text.lower()
        for text in re.split(r"([0-9]+)", name)
    ]


def list_image_paths(folder_path: str) -> List[str]:
    patterns = ("*.png", "*.jpg", "*.jpeg")
    image_files = []
    for pattern in patterns:
        image_files.extend(glob.glob(os.path.join(folder_path, pattern)))
    return sorted(image_files, key=natural_sort_key)


def pixel_to_tensor(image_rgb: np.ndarray, device: torch.device) -> torch.Tensor:
    tensor = torch.from_numpy(image_rgb).permute(2, 0, 1).float()[None, None, ...]
    return (tensor / 255.0).to(device)


def load_demo_frames(folder_path: str) -> List[np.ndarray]:
    image_paths = list_image_paths(folder_path)
    if not image_paths:
        raise FileNotFoundError(f"No images found in {folder_path}")

    frames = []
    for image_path in image_paths:
        image_bgr = cv2.imread(image_path)
        if image_bgr is None:
            raise RuntimeError(f"Failed to read image: {image_path}")
        frames.append(preprocess_for_reward_model(image_bgr))
    return frames


class LiftDemoRewardCalculator:
    def __init__(
        self,
        pretrain_path: str,
        device: str = "cuda",
        task_text: str = "Lift",
        epsilon: float = 0.25,
    ):
        self.device = torch.device(device if torch.cuda.is_available() else "cpu")
        self.task_text = task_text
        self.epsilon = epsilon

        print(f"Loading lift encoder from {pretrain_path} on {self.device}...")
        _, self.model = utils.load_model_checkpoint(pretrain_path, self.device)
        self.subgoal_embs = utils.load_pickle(pretrain_path, "subgoals_emb.pkl")
        self.scale_factors = utils.load_pickle(pretrain_path, "subgoal_scale_factors.pkl")

    def encode_pair(self, frame_t: np.ndarray, frame_tp1: np.ndarray) -> np.ndarray:
        pair = torch.cat(
            [
                pixel_to_tensor(frame_t, self.device),
                pixel_to_tensor(frame_tp1, self.device),
            ],
            dim=1,
        )
        with torch.no_grad():
            embs = self.model.infer(pair, [self.task_text, self.task_text]).numpy().embs
        return np.asarray(embs).squeeze()

    def process_demo(self, folder_path: str) -> Dict[str, np.ndarray]:
        frames = load_demo_frames(folder_path)
        subgoal_idx = 1
        subgoal_emb = self.subgoal_embs[subgoal_idx]

        distances = []
        rewards = []
        subgoal_indices = []
        progress_values = []

        for step in range(len(frames) - 1):
            emb_pair = self.encode_pair(frames[step], frames[step + 1])
            segment_scale = 1.0 / np.linalg.norm(
                self.subgoal_embs[subgoal_idx] - self.subgoal_embs[subgoal_idx - 1],
                axis=-1,
            )
            progress, _, d_tp1, hit = compute_progress_to_subgoal(
                emb=emb_pair,
                subgoal_emb=subgoal_emb,
                scale_factor=self.scale_factors[subgoal_idx - 1],
                segment_scale=segment_scale,
                epsilon=self.epsilon,
            )

            d_tp1 = float(np.asarray(d_tp1).reshape(-1)[0])
            progress = float(np.asarray(progress).reshape(-1)[0])
            hit = bool(np.asarray(hit).reshape(-1)[0])

            reward = -0.1 * d_tp1
            if hit and subgoal_idx < len(self.subgoal_embs) - 1:
                reward += 7.5
                subgoal_idx += 1
                subgoal_emb = self.subgoal_embs[subgoal_idx]

            distances.append(d_tp1)
            rewards.append(reward)
            subgoal_indices.append(subgoal_idx)
            progress_values.append(progress)

        return {
            "distances": np.asarray(distances),
            "rewards": np.asarray(rewards),
            "subgoal_indices": np.asarray(subgoal_indices),
            "progress": np.asarray(progress_values),
            "final_subgoal_idx": subgoal_idx,
            "num_frames": len(frames),
        }


def find_subgoal_changes(subgoal_indices: np.ndarray) -> List[int]:
    changes = []
    for idx in range(len(subgoal_indices) - 1):
        if subgoal_indices[idx] != subgoal_indices[idx + 1]:
            changes.append(idx + 1)
    return changes


def plot_demo_rewards(
    demo_results: List[Tuple[str, Dict[str, np.ndarray]]],
    output_path: str,
):
    num_demos = len(demo_results)
    row_height = 2.2 if num_demos > 4 else 4.0
    fig, axes = plt.subplots(
        num_demos, 2, figsize=(14, row_height * num_demos), squeeze=False
    )

    for row, (label, result) in enumerate(demo_results):
        distances = result["distances"]
        rewards = result["rewards"]
        subgoal_indices = result["subgoal_indices"]
        steps = np.arange(len(distances))
        changes = find_subgoal_changes(subgoal_indices)

        ax_dist = axes[row, 0]
        ax_dist.plot(steps, distances, color="tab:blue", linewidth=1.5)
        ax_dist.set_title(f"{label} — distance to current subgoal")
        ax_dist.set_xlabel("Frame transition (t -> t+1)")
        ax_dist.set_ylabel("d_tp1 (lower is closer)")
        ax_dist.grid(True, linestyle="--", alpha=0.4)
        for change_step in changes:
            ax_dist.axvline(
                x=change_step,
                color="red",
                linestyle=":",
                linewidth=1.5,
            )

        ax_rew = axes[row, 1]
        ax_rew.plot(steps, rewards, color="tab:green", linewidth=1.5, label="step reward")
        ax_rew.plot(steps, np.cumsum(rewards), color="tab:orange", linewidth=1.5, label="cumulative")
        ax_rew.set_title(
            f"{label} — RL reward (reached subgoal {result['final_subgoal_idx']})"
        )
        ax_rew.set_xlabel("Frame transition (t -> t+1)")
        ax_rew.set_ylabel("Reward")
        ax_rew.grid(True, linestyle="--", alpha=0.4)
        ax_rew.legend(loc="lower right")

    plt.tight_layout()
    plt.savefig(output_path, dpi=200)
    plt.close()
    print(f"Saved plot to {output_path}")


def save_csv(
    demo_results: List[Tuple[str, Dict[str, np.ndarray]]],
    output_path: str,
):
    with open(output_path, "w", newline="") as fp:
        writer = csv.writer(fp)
        header = ["step"]
        for label, _ in demo_results:
            safe_label = label.replace(" ", "_")
            header.extend(
                [
                    f"{safe_label}_distance",
                    f"{safe_label}_reward",
                    f"{safe_label}_subgoal_idx",
                ]
            )
        writer.writerow(header)

        max_len = max(len(result["distances"]) for _, result in demo_results)
        for step in range(max_len):
            row = [step]
            for _, result in demo_results:
                if step < len(result["distances"]):
                    row.extend(
                        [
                            result["distances"][step],
                            result["rewards"][step],
                            result["subgoal_indices"][step],
                        ]
                    )
                else:
                    row.extend(["", "", ""])
            writer.writerow(row)

    print(f"Saved CSV to {output_path}")


def parse_args():
    parser = argparse.ArgumentParser(
        description="Visualize lift encoder rewards on demo image folders."
    )
    parser.add_argument(
        "--pretrain_path",
        default=DEFAULT_PRETRAIN_PATH,
        help="Path to lift pretrain run with checkpoints and subgoal pickles.",
    )
    parser.add_argument(
        "--demo_root",
        default=DEFAULT_DEMO_ROOT,
        help="Root folder containing numbered demo subfolders (0, 1, ...).",
    )
    parser.add_argument(
        "--demo_indices",
        default=",".join(str(i) for i in DEFAULT_DEMO_INDICES),
        help="Comma-separated demo folder indices under --demo_root, e.g. 0,1,2.",
    )
    parser.add_argument(
        "--demo_folder",
        action="append",
        dest="demo_folders",
        help="Explicit demo folder path. Overrides --demo_root/--demo_indices.",
    )
    parser.add_argument(
        "--demo_label",
        action="append",
        dest="demo_labels",
        help="Label for each demo folder (same order as --demo_folder).",
    )
    parser.add_argument(
        "--output_plot",
        default="lift_demo_reward_plot.png",
        help="Output PNG path.",
    )
    parser.add_argument(
        "--output_csv",
        default="lift_demo_reward_log.csv",
        help="Output CSV path.",
    )
    parser.add_argument("--task_text", default="Lift")
    parser.add_argument("--epsilon", type=float, default=0.25)
    parser.add_argument("--device", default="cuda")
    return parser.parse_args()


def main():
    args = parse_args()
    if args.demo_folders:
        demo_folders = args.demo_folders
    else:
        indices = [int(x.strip()) for x in args.demo_indices.split(",") if x.strip()]
        demo_folders = [os.path.join(args.demo_root, str(i)) for i in indices]
    if args.demo_labels:
        demo_labels = args.demo_labels
    else:
        demo_labels = [f"Demo {os.path.basename(path)}" for path in demo_folders]

    if len(demo_labels) != len(demo_folders):
        raise ValueError("Number of --demo_label values must match --demo_folder values.")

    calc = LiftDemoRewardCalculator(
        pretrain_path=args.pretrain_path,
        device=args.device,
        task_text=args.task_text,
        epsilon=args.epsilon,
    )

    demo_results = []
    for label, folder in zip(demo_labels, demo_folders):
        print(f"\nProcessing {label}: {folder}")
        result = calc.process_demo(folder)
        print(
            f"  frames={result['num_frames']}, "
            f"transitions={len(result['distances'])}, "
            f"final_subgoal={result['final_subgoal_idx']}, "
            f"mean_reward={result['rewards'].mean():.3f}"
        )
        demo_results.append((label, result))

    plot_demo_rewards(demo_results, args.output_plot)
    save_csv(demo_results, args.output_csv)


if __name__ == "__main__":
    main()