"""Evaluate an exported main UniCal checkpoint on frozen C2L stage-5 test rows.

Requires the separately licensed UniCal source package; no pretrained download.
"""

from __future__ import annotations

import argparse
import hashlib
import json
from pathlib import Path

import numpy as np
import torch
import unical
from hydra import compose, initialize_config_dir
from hydra.utils import instantiate
from scipy.spatial.transform import Rotation
from unical.utils.transform import rotation_6d_to_matrix


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--checkpoint", required=True, type=Path)
    parser.add_argument("--data-dir", required=True, type=Path)
    parser.add_argument("--raw-root", required=True, type=Path)
    parser.add_argument("--output", required=True, type=Path)
    parser.add_argument("--device", choices=["cpu", "cuda"], default="cpu")
    parser.add_argument("--num-workers", type=int, default=0)
    parser.add_argument("--batch-size", type=int, default=2)
    parser.add_argument("--max-samples", type=int)
    parser.add_argument(
        "--dataset-protocol",
        choices=("legacy_v1", "full_projection_v1_1"),
        default="legacy_v1",
        help="Label convention being evaluated; checkpoints remain the original v1-trained models.",
    )
    args = parser.parse_args()
    if args.max_samples is not None and args.max_samples < 1:
        parser.error("--max-samples must be positive")
    if args.output.exists():
        raise FileExistsError(args.output)
    root = Path(unical.__file__).resolve().parents[2]
    torch.set_float32_matmul_precision("high")
    overrides = [
        "data=kitti_c2l",
        f"data.data_dir={args.data_dir.resolve()}",
        f"data.kitti_raw_root={args.raw_root.resolve()}",
        "data.stages=[5]",
        f"data.batch_size={args.batch_size}",
        f"data.num_workers={args.num_workers}",
        "data.preprocessor.cfg.width=256",
        "data.preprocessor.cfg.height=256",
        "model.backbone.image_size=256",
        "model.backbone.pretrained=null",
    ]
    with initialize_config_dir(config_dir=str(root / "configs"), version_base="1.3"):
        cfg = compose(config_name="train", overrides=overrides)
    dm = instantiate(cfg.data)
    dm.setup("test")
    state = torch.load(args.checkpoint, map_location="cpu", weights_only=True)
    model = instantiate(cfg.model).to(args.device).eval()
    model.load_state_dict(state["state_dict"], strict=True)
    records = []
    with torch.inference_mode():
        for batch in dm.test_dataloader():
            translation, r6 = model(
                batch._replace(
                    img=batch.img.to(args.device), lidar_map=batch.lidar_map.to(args.device)
                )
            )
            translation = translation.float().cpu().numpy()
            rotation = rotation_6d_to_matrix(r6.float()).cpu().numpy()
            target_t, target_r = (value.numpy() for value in batch.target_reg)
            angles = np.rad2deg(
                (Rotation.from_matrix(rotation).inv() * Rotation.from_matrix(target_r)).magnitude()
            )
            errors = np.abs(translation - target_t).mean(axis=1) * 100
            for i, meta in enumerate(batch.metadata):
                records.append(
                    {
                        "sequence": meta["sequence"],
                        "frame_index": int(meta["frame_index"]),
                        "translation_mae_cm": float(errors[i]),
                        "rotation_degrees": float(angles[i]),
                    }
                )
            if args.max_samples is not None and len(records) >= args.max_samples:
                records = records[: args.max_samples]
                break
    if (
        not records
        or not np.isfinite(
            [[row["translation_mae_cm"], row["rotation_degrees"]] for row in records]
        ).all()
    ):
        raise ValueError("Empty or non-finite evaluation")

    def mean_metrics(rows):
        return {
            key: float(np.mean([row[key] for row in rows]))
            for key in ("translation_mae_cm", "rotation_degrees")
        }

    result = {
        "protocol": "native-frozen-stage5",
        "dataset_protocol": args.dataset_protocol,
        "checkpoint_sha256": hashlib.sha256(args.checkpoint.read_bytes()).hexdigest(),
        "test_metadata_sha256": hashlib.sha256(
            (args.data_dir / "test.parquet").read_bytes()
        ).hexdigest(),
        "checkpoint_training_protocol": "legacy_v1",
        "samples": len(records),
        "device": args.device,
        "smoke_only": args.max_samples is not None,
        "training_seed": state["training_seed"],
        "epoch_zero_based": state["epoch"],
        "global_step": state["global_step"],
        "metrics": mean_metrics(records),
        "per_sequence": {
            seq: mean_metrics([row for row in records if row["sequence"] == seq])
            for seq in sorted({row["sequence"] for row in records})
        },
        "records": records,
    }
    args.output.parent.mkdir(parents=True, exist_ok=True)
    args.output.write_text(json.dumps(result, indent=2) + "\n")
    print(json.dumps({key: value for key, value in result.items() if key != "records"}, indent=2))


if __name__ == "__main__":
    main()