import argparse
import json
import re
from tqdm import tqdm


HIGHLEVEL_CATEGORIES = {
    "speed": ["KEEP", "ACCELERATE", "DECELERATE", "STOP"],
    "path": ["STRAIGHT", "LEFT_TURN", "RIGHT_TURN", "LEFT_CHANGE", "RIGHT_CHANGE", "UNKNOWN"],
}
REQUIRED_HIGHLEVEL_SUBTASKS = set(HIGHLEVEL_CATEGORIES)


def get_numpy():
    import numpy as np
    return np


def clean_text(s: str):
    if not isinstance(s, str):
        return ""
    s = s.strip()
    s = re.sub(r"[.\n\r]+", " ", s)
    s = re.sub(r"\s+", " ", s)
    return s.strip()


def parse_highlevel_prediction(text, subtask):
    if subtask not in HIGHLEVEL_CATEGORIES:
        raise ValueError(f"Unexpected planning high-level subtask: {subtask!r}")

    text = clean_text(text).upper()
    categories = HIGHLEVEL_CATEGORIES[subtask]
    matches = [
        word for word in categories
        if re.search(rf"(?<![A-Z_]){re.escape(word)}(?![A-Z_])", text)
    ]
    return matches[0] if len(matches) == 1 else None


def parse_traj(text):
    """
    Parse trajectory text like "[0.001, -0.002], [0.003, -0.004]".
    Returns an array with shape [N, 2].
    """
    np = get_numpy()
    if not isinstance(text, str):
        return np.zeros((0, 2))

    # Match integers, floats, and scientific notation.
    nums = re.findall(r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?", text)
    if len(nums) < 2:
        return np.zeros((0, 2))
    if len(nums) % 2 != 0:
        return np.zeros((0, 2))

    arr = np.array(nums, dtype=float)
    arr = arr.reshape(-1, 2)
    return arr

def compute_l2_error(gt, pred, dt=0.5):
    """
    gt, pred: np.array of shape [10, 2]
    Returns: {1s, 3s, 5s, mean}
    """
    if gt.shape != pred.shape or gt.shape[0] == 0:
        return {"1s": None, "3s": None, "5s": None, "mean": None}

    np = get_numpy()
    errors = np.linalg.norm(gt - pred, axis=1)
    time_horizons = [1.0, 3.0, 5.0]
    results = {}
    for t in time_horizons:
        idx = int(t / dt) - 1
        idx = min(idx, len(errors) - 1)
        results[f"{t:.0f}s"] = float(errors[idx])
    results["mean"] = float(np.mean(errors))
    return results


def evaluate(pred_json):
    with open(pred_json, "r", encoding="utf-8") as f:
        data = json.load(f)

    if not data:
        raise ValueError(f"No samples found in {pred_json}")

    highlevel_totals = {subtask: 0 for subtask in HIGHLEVEL_CATEGORIES}
    highlevel_correct = {subtask: 0 for subtask in HIGHLEVEL_CATEGORIES}
    highlevel_classwise = {
        subtask: {category: {"total": 0, "correct": 0} for category in categories}
        for subtask, categories in HIGHLEVEL_CATEGORIES.items()
    }
    highlevel_groups = {}
    trajectory_items = []
    traj_errors = []

    mismatch_high = []

    for item in data:
        category = item["category"]

        if category == "Planning-HighLevel":
            original_id = item.get("original_id")
            subtask = item.get("subtask")
            if not original_id:
                raise ValueError("Planning high-level sample is missing original_id")
            if subtask not in HIGHLEVEL_CATEGORIES:
                raise ValueError(f"Missing or invalid planning high-level subtask: {subtask!r}")

            group = highlevel_groups.setdefault(original_id, {})
            if subtask in group:
                raise ValueError(f"Duplicate planning high-level subtask {subtask!r} for {original_id}")
            group[subtask] = item
        elif category == "Planning-Trajectory":
            trajectory_items.append(item)
        else:
            raise ValueError(f"Unexpected planning category: {category!r}")

    for original_id, group in highlevel_groups.items():
        if set(group) != REQUIRED_HIGHLEVEL_SUBTASKS:
            raise ValueError(f"Incomplete planning high-level subtask pair for {original_id}: {sorted(group)}")

    joint_correct = 0
    for original_id, group in tqdm(highlevel_groups.items(), desc="Evaluating planning intent pairs"):
        is_joint_correct = True
        for subtask, item in group.items():
            gt_raw = item["conversations"][1]["value"]
            pred_raw = item.get("model_output", "")
            gt = parse_highlevel_prediction(gt_raw, subtask)
            pred = parse_highlevel_prediction(pred_raw, subtask)
            if gt is None:
                raise ValueError(f"Invalid planning {subtask} ground-truth answer: {gt_raw!r}")

            highlevel_totals[subtask] += 1
            highlevel_classwise[subtask][gt]["total"] += 1
            is_correct = gt == pred
            is_joint_correct = is_joint_correct and is_correct
            if is_correct:
                highlevel_correct[subtask] += 1
                highlevel_classwise[subtask][gt]["correct"] += 1
            else:
                mismatch_high.append({
                    "original_id": original_id,
                    "image": item["image"],
                    "subtask": subtask,
                    "gt": gt,
                    "pred": pred,
                    "model_output": pred_raw,
                })
        joint_correct += is_joint_correct

    for item in tqdm(trajectory_items, desc="Evaluating planning trajectories"):
        gt_raw = item["conversations"][1]["value"]
        pred_raw = item.get("model_output", "")
        gt_traj = parse_traj(gt_raw)
        pred_traj = parse_traj(pred_raw)
        if gt_traj.shape[0] != 10:
            raise ValueError(f"Invalid planning trajectory ground truth for {item['image']}: {gt_raw!r}")
        if pred_traj.shape[0] != 10:
            raise ValueError(
                f"Invalid planning trajectory prediction for {item['image']}: "
                f"expected exactly 10 waypoints, got {pred_traj.shape[0]}"
            )
        traj_errors.append(compute_l2_error(gt_traj, pred_traj))

    results = {}
    total_high = sum(highlevel_totals.values())
    original_questions = len(highlevel_groups)

    if total_high > 0:
        results["HighLevel"] = {
            "total": total_high,
            "original_questions": original_questions,
            "overall_accuracy (%)": round(sum(highlevel_correct.values()) / total_high * 100, 2),
            "joint_correct": joint_correct,
            "joint_accuracy (%)": round(joint_correct / original_questions * 100, 2),
            "subtasks": {
                subtask: {
                    "total": highlevel_totals[subtask],
                    "accuracy (%)": round(highlevel_correct[subtask] / highlevel_totals[subtask] * 100, 2)
                    if highlevel_totals[subtask]
                    else None,
                    "classwise": {
                        category: round(stats["correct"] / stats["total"] * 100, 2) if stats["total"] else None
                        for category, stats in highlevel_classwise[subtask].items()
                    },
                }
                for subtask in HIGHLEVEL_CATEGORIES
            },
        }

    total_traj = len(trajectory_items)
    if total_traj > 0:
        results["Trajectory"] = {
            "total": total_traj,
            "valid_predictions": total_traj,
            "invalid_predictions": 0,
        }
        if traj_errors:
            np = get_numpy()
            traj_errs_np = {
                k: np.mean([error[k] for error in traj_errors if error[k] is not None])
                for k in ["1s", "3s", "5s", "mean"]
            }
            results["Trajectory"]["avg_L2_error_m"] = {k: round(v, 4) for k, v in traj_errs_np.items()}

    print("\n=== Evaluation Summary ===")
    print(json.dumps(results, indent=2))

    result_path = pred_json.replace(".json", "_eval_results.json")
    with open(result_path, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2, ensure_ascii=False)

    with open(pred_json.replace(".json", "_highlevel_mismatch.json"), "w", encoding="utf-8") as f:
        json.dump(mismatch_high, f, indent=2, ensure_ascii=False)
    print(f"Evaluation summary saved to {result_path}")

    return results


def parse_args():
    parser = argparse.ArgumentParser(description="Evaluate EventDrive planning task results.")
    parser.add_argument("--pred-json", required=True, help="Path to prediction JSON with model_output fields.")
    return parser.parse_args()


if __name__ == "__main__":
    args = parse_args()
    evaluate(args.pred_json)