from __future__ import annotations

import argparse
import json
from pathlib import Path

import torch
import yaml
from torch.utils.data import DataLoader

from src.metrics import (
    assd_voxels,
    binary_classification_metrics,
    concordance_index,
    dice_score,
    expected_calibration_error,
    iou_score,
)
from src.models import CohortAwareCTModel
from src.train import build_dataset, collate_optional


def main() -> None:
    parser = argparse.ArgumentParser(description="Evaluate a trained checkpoint.")
    parser.add_argument("--config", required=True)
    parser.add_argument("--checkpoint", required=True)
    parser.add_argument("--output-json")
    args = parser.parse_args()

    cfg = yaml.safe_load(Path(args.config).read_text())
    dataset = build_dataset(cfg)
    loader = DataLoader(dataset, batch_size=cfg["train"].get("batch_size", 2), shuffle=False, collate_fn=collate_optional)
    model_cfg = cfg["model"]
    model = CohortAwareCTModel(
        in_channels=model_cfg.get("in_channels", 1),
        feature_dim=model_cfg.get("feature_dim", 256),
        clinical_dim=model_cfg.get("clinical_dim", 0),
        survival_bins=model_cfg.get("survival_bins", 0),
        use_pet=model_cfg.get("use_pet", True),
        use_support=model_cfg.get("use_support", True),
        clinical_use_missingness=model_cfg.get("clinical_use_missingness", True),
        gate_mode=model_cfg.get("gate_mode", "selective"),
    )
    try:
        state = torch.load(args.checkpoint, map_location="cpu", weights_only=True)
    except TypeError:
        state = torch.load(args.checkpoint, map_location="cpu")
    model.load_state_dict(state["model"])
    model.eval()

    logits = []
    ct_logits = []
    pet_logits = []
    utilities = []
    labels = []
    dice = []
    ious = []
    assds = []
    risks = []
    times = []
    events = []
    with torch.no_grad():
        for batch in loader:
            outputs = model(batch)
            if "label" in batch and not torch.isnan(batch["label"]).all():
                logits.append(outputs["fused_logit"])
                ct_logits.append(outputs["ct_logit"])
                pet_logits.append(outputs["pet_logit"])
                utilities.append(outputs["pet_utility"])
                labels.append(batch["label"])
            if "mask" in batch:
                dice.append(dice_score(outputs["support_logits"], batch["mask"]))
                ious.append(iou_score(outputs["support_logits"], batch["mask"]))
                assds.append(assd_voxels(outputs["support_logits"], batch["mask"]))
            if "hazard_logits" in outputs and "time" in batch and "event" in batch:
                hazard = torch.sigmoid(outputs["hazard_logits"])
                risks.append(hazard.sum(dim=1))
                times.append(batch["time"])
                events.append(batch["event"])
    metrics: dict[str, float] = {}
    if logits:
        all_logits = torch.cat(logits)
        all_labels = torch.cat(labels)
        metrics.update(binary_classification_metrics(all_logits, all_labels))
        metrics["ece"] = expected_calibration_error(all_logits, all_labels)
        metrics["ct_only_brier"] = binary_classification_metrics(torch.cat(ct_logits), all_labels)["brier"]
        metrics["pet_fusion_brier"] = binary_classification_metrics(torch.cat(pet_logits), all_labels)["brier"]
        metrics["selected_pet_ratio"] = float((torch.cat(utilities) >= 0.5).float().mean())
    if dice:
        metrics["dice"] = sum(dice) / len(dice)
        metrics["iou"] = sum(ious) / len(ious)
        metrics["assd"] = sum(assds) / len(assds)
    if risks:
        metrics["c_index"] = concordance_index(torch.cat(risks), torch.cat(times), torch.cat(events))
    if args.output_json:
        out = Path(args.output_json)
        out.parent.mkdir(parents=True, exist_ok=True)
        out.write_text(json.dumps(metrics, indent=2, sort_keys=True) + "\n")
    print(metrics)


if __name__ == "__main__":
    main()