from __future__ import annotations

import argparse
from pathlib import Path

import torch
import torch.nn.functional as F
import yaml
from torch.utils.data import DataLoader, random_split

from src.datasets import LIDCDataset, LungPETCTDxDataset, ManifestDataset, NSCLCRadiomicsDataset
from src.losses import brier_loss, discrete_time_nll, segmentation_loss
from src.models import CohortAwareCTModel


def build_dataset(cfg: dict):
    ds = cfg["dataset"]
    name = ds["name"]
    kwargs = {
        "manifest_csv": ds["manifest_csv"],
        "root": ds.get("root"),
        "clinical_cols": ds.get("clinical_cols", []),
    }
    if name == "lidc":
        return LIDCDataset(task=cfg.get("task", "classification"), **kwargs)
    if name == "lung_pet_ct_dx":
        return LungPETCTDxDataset(**kwargs)
    if name == "nsclc_radiomics":
        return NSCLCRadiomicsDataset(**kwargs)
    return ManifestDataset(**kwargs)


def collate_optional(batch: list[dict]) -> dict:
    out: dict = {}
    keys = set().union(*(item.keys() for item in batch))
    for key in keys:
        values = [item.get(key) for item in batch]
        if isinstance(values[0], torch.Tensor):
            if all(v is not None and tuple(v.shape) == tuple(values[0].shape) for v in values):
                out[key] = torch.stack(values)
        elif key in ("patient_id", "lesion_id"):
            out[key] = values
    return out


def build_loss(outputs: dict[str, torch.Tensor], batch: dict[str, torch.Tensor], task: str) -> torch.Tensor:
    return build_weighted_loss(outputs, batch, task)


def build_weighted_loss(
    outputs: dict[str, torch.Tensor],
    batch: dict[str, torch.Tensor],
    task: str,
    calibration_weight: float = 0.05,
) -> torch.Tensor:
    losses = []
    if "mask" in batch and "support_logits" in outputs:
        losses.append(segmentation_loss(outputs["support_logits"], batch["mask"]))
    if "label" in batch and not torch.isnan(batch["label"]).all():
        label = torch.nan_to_num(batch["label"].float(), nan=0.0)
        losses.append(F.binary_cross_entropy_with_logits(outputs["fused_logit"], label))
        losses.append(0.2 * F.binary_cross_entropy_with_logits(outputs["ct_logit"], label))
        if calibration_weight > 0:
            losses.append(calibration_weight * brier_loss(outputs["fused_logit"], label))
    if task == "survival" and "hazard_logits" in outputs and "time" in batch and "event" in batch:
        bin_index = torch.nan_to_num(batch["time"], nan=0.0).long()
        event = torch.nan_to_num(batch["event"], nan=0.0)
        losses.append(discrete_time_nll(outputs["hazard_logits"], bin_index, event))
    if not losses:
        raise ValueError("No supervised targets found in batch")
    return sum(losses)


def main() -> None:
    parser = argparse.ArgumentParser(description="Train a reproduction model.")
    parser.add_argument("--config", required=True)
    args = parser.parse_args()

    cfg = yaml.safe_load(Path(args.config).read_text())
    torch.manual_seed(int(cfg.get("seed", 17)))
    dataset = build_dataset(cfg)
    train_len = max(1, int(0.8 * len(dataset)))
    val_len = len(dataset) - train_len
    train_ds, _ = random_split(dataset, [train_len, val_len], generator=torch.Generator().manual_seed(cfg.get("seed", 17)))

    train_cfg = cfg["train"]
    loader = DataLoader(
        train_ds,
        batch_size=train_cfg.get("batch_size", 2),
        shuffle=True,
        num_workers=train_cfg.get("num_workers", 0),
        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"),
    )
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model.to(device)
    opt = torch.optim.AdamW(model.parameters(), lr=train_cfg.get("lr", 1e-4), weight_decay=1e-4)

    out_dir = Path(train_cfg["output_dir"])
    out_dir.mkdir(parents=True, exist_ok=True)
    for epoch in range(int(train_cfg.get("epochs", 1))):
        model.train()
        total = 0.0
        for batch in loader:
            batch = {k: v.to(device) if isinstance(v, torch.Tensor) else v for k, v in batch.items()}
            opt.zero_grad(set_to_none=True)
            outputs = model(batch)
            loss = build_weighted_loss(
                outputs,
                batch,
                cfg.get("task", "classification"),
                calibration_weight=float(train_cfg.get("calibration_weight", 0.05)),
            )
            loss.backward()
            opt.step()
            total += float(loss.detach().cpu())
        ckpt = {"model": model.state_dict(), "config": cfg, "epoch": epoch}
        torch.save(ckpt, out_dir / "last.pt")
        print(f"epoch={epoch + 1} loss={total / max(len(loader), 1):.4f}")


if __name__ == "__main__":
    main()