from __future__ import annotations

import argparse
from pathlib import Path

import pandas as pd
import torch

from fall.config import load_config
from fall.models import build_model
from fall.train import evaluate, make_dataset, make_loader, make_loss
from fall.utils import ensure_dir, get_device, write_json


def run_evaluation(config_path: str | Path, checkpoint_path: str | Path, manifest: str | None, split: str, tag: str) -> dict:
    cfg = load_config(config_path)
    if manifest:
        cfg["data"]["manifest"] = manifest
    device = get_device(str(cfg.get("device", "cuda")))
    ds = make_dataset(cfg, split)
    input_dim = ds.input_dim if cfg["data"].get("type", "pose") == "pose" else None
    model = build_model(cfg["model"]["name"], input_dim, cfg["model"]).to(device)
    ckpt = torch.load(checkpoint_path, map_location=device)
    model.load_state_dict(ckpt["model"])
    loader = make_loader(ds, cfg, split, shuffle=False)
    df = pd.read_csv(cfg["data"]["manifest"])
    criterion = make_loss(df, cfg, device)
    loss, metrics, pred = evaluate(model, loader, criterion, device)
    metrics = {"loss": loss, **metrics}
    out_dir = ensure_dir(Path(cfg["output_dir"]) / "eval")
    pred.to_csv(out_dir / f"{tag}_predictions.csv", index=False)
    write_json(metrics, out_dir / f"{tag}_metrics.json")
    print(metrics)
    return metrics


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", required=True)
    parser.add_argument("--checkpoint", required=True)
    parser.add_argument("--manifest")
    parser.add_argument("--split", default="test")
    parser.add_argument("--tag", default="test")
    args = parser.parse_args()
    run_evaluation(args.config, args.checkpoint, args.manifest, args.split, args.tag)


if __name__ == "__main__":
    main()