#!/usr/bin/env python3
"""Smoke-test training-ready NPZ manifests with a PyTorch DataLoader."""

from __future__ import annotations

import argparse
from pathlib import Path

import numpy as np
import pandas as pd
import torch
from torch.utils.data import DataLoader, Dataset


def center_crop_or_pad(array: np.ndarray, target_shape: tuple[int, ...]) -> np.ndarray:
    result = np.zeros(target_shape, dtype=array.dtype)
    src_slices = []
    dst_slices = []
    for src_size, dst_size in zip(array.shape, target_shape):
        if src_size >= dst_size:
            start = (src_size - dst_size) // 2
            src_slices.append(slice(start, start + dst_size))
            dst_slices.append(slice(0, dst_size))
        else:
            start = (dst_size - src_size) // 2
            src_slices.append(slice(0, src_size))
            dst_slices.append(slice(start, start + src_size))
    result[tuple(dst_slices)] = array[tuple(src_slices)]
    return result


class WawTaceDataset(Dataset):
    def __init__(self, manifest_path: Path, patch_size: tuple[int, int, int]):
        self.root = manifest_path.resolve().parents[1]
        self.df = pd.read_csv(manifest_path)
        self.patch_size = patch_size

    def __len__(self) -> int:
        return len(self.df)

    def __getitem__(self, index: int) -> dict[str, torch.Tensor]:
        row = self.df.iloc[index]
        with np.load(self.root / row["npz_path"]) as data:
            image = center_crop_or_pad(data["image"], (4, *self.patch_size))
            liver = center_crop_or_pad(data["liver_mask"], self.patch_size)
            tumor = center_crop_or_pad(data["tumor_mask"], self.patch_size)
            phase_available = data["phase_available"].astype(np.float32)
            label_progression = np.asarray(row["label_progression"], dtype=np.float32)
        return {
            "image": torch.from_numpy(image.astype(np.float32)),
            "liver_mask": torch.from_numpy(liver.astype(np.int64)),
            "tumor_mask": torch.from_numpy(tumor.astype(np.int64)),
            "phase_available": torch.from_numpy(phase_available),
            "label_progression": torch.from_numpy(label_progression[None]),
        }


class MsdLiverDataset(Dataset):
    def __init__(self, manifest_path: Path, patch_size: tuple[int, int, int]):
        self.root = manifest_path.resolve().parents[1]
        self.df = pd.read_csv(manifest_path)
        self.patch_size = patch_size

    def __len__(self) -> int:
        return len(self.df)

    def __getitem__(self, index: int) -> dict[str, torch.Tensor]:
        row = self.df.iloc[index]
        with np.load(self.root / row["npz_path"]) as data:
            image = center_crop_or_pad(data["image"], (1, *self.patch_size))
            label = center_crop_or_pad(data["label"], self.patch_size)
        return {
            "image": torch.from_numpy(image.astype(np.float32)),
            "label": torch.from_numpy(label.astype(np.int64)),
        }


class HccTaceSegDataset(MsdLiverDataset):
    pass


def parse_patch_size(value: str) -> tuple[int, int, int]:
    parts = tuple(int(x) for x in value.split(","))
    if len(parts) != 3:
        raise ValueError("--patch-size must be z,y,x")
    return parts


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--dataset", choices=["waw", "msd", "hcc"], default="waw")
    parser.add_argument("--batch-size", type=int, default=2)
    parser.add_argument("--patch-size", default="96,128,128", help="Patch size in z,y,x order.")
    args = parser.parse_args()

    patch_size = parse_patch_size(args.patch_size)
    if args.dataset == "waw":
        dataset: Dataset = WawTaceDataset(Path("manifests/waw_tace_training_manifest.csv"), patch_size)
    elif args.dataset == "msd":
        dataset = MsdLiverDataset(Path("manifests/msd_liver_training_manifest.csv"), patch_size)
    else:
        dataset = HccTaceSegDataset(Path("manifests/hcc_tace_seg_training_manifest.csv"), patch_size)

    loader = DataLoader(dataset, batch_size=args.batch_size, shuffle=True, num_workers=0)
    batch = next(iter(loader))
    for key, value in batch.items():
        print(key, tuple(value.shape), value.dtype)


if __name__ == "__main__":
    main()