import os
import io
from pathlib import Path

import pandas as pd
import numpy as np
from PIL import Image


INPUT_PARQUET_PATHS = [
    r"./data/fold1-00000-of-00001.parquet",
    r"./data/fold2-00000-of-00001.parquet",
    r"./data/fold3-00000-of-00001.parquet",
]

SPLIT_CSV_PATH = r"./PanNuke_split.csv"

OUTPUT_TRAIN_ROOT = Path(r"./train_images")
OUTPUT_TEST_ROOT = Path(r"./test_images")

IMAGE_COLUMN = "image"
CLASS_LABEL_COLUMN = "tissue"
IMAGE_EXT = ".png"

TISSUE_ID_TO_NAME: dict[int, str] = {
    0: "Adrenal Gland",
    1: "Bile Duct",
    2: "Bladder",
    3: "Breast",
    4: "Cervix",
    5: "Colon",
    6: "Esophagus",
    7: "Head and Neck",
    8: "Kidney",
    9: "Liver",
    10: "Lung",
    11: "Ovarian",
    12: "Pancreatic",
    13: "Prostate",
    14: "Skin",
    15: "Stomach",
    16: "Testis",
    17: "Thyroid",
    18: "Uterus",
}

CLASS_ORDER = list(TISSUE_ID_TO_NAME.values())


def load_split_mapping(csv_path: str) -> dict[str, str]:
    df = pd.read_csv(csv_path)
    df.columns = df.columns.str.strip()
    mapping = {}
    for _, row in df.iterrows():
        img_path = str(row["image_path"]).strip()
        split = str(row["split"]).strip().lower()
        mapping[img_path] = split
    print(f"[INFO] Loaded split CSV: {len(mapping)} entries "
          f"(train: {sum(1 for v in mapping.values() if v == 'train')}, "
          f"test: {sum(1 for v in mapping.values() if v == 'test')})")
    return mapping


def is_null_like(x):
    if x is None:
        return True
    if isinstance(x, (bytes, bytearray, dict, list, tuple, np.ndarray, Image.Image)):
        return False
    try:
        result = pd.isna(x)
        if isinstance(result, (bool, np.bool_)):
            return bool(result)
        return False
    except Exception:
        return False


def try_decode_pil_from_bytes(data):
    try:
        img = Image.open(io.BytesIO(data))
        img.load()
        return img
    except Exception:
        return None


def try_decode_image(obj):
    if is_null_like(obj):
        return None
    if isinstance(obj, Image.Image):
        return obj
    if isinstance(obj, (bytes, bytearray)):
        return try_decode_pil_from_bytes(obj)
    if isinstance(obj, np.ndarray):
        try:
            arr = obj.astype(np.uint8) if obj.dtype != np.uint8 else obj
            if arr.ndim in (2, 3):
                return Image.fromarray(arr)
        except Exception:
            return None
    if isinstance(obj, list):
        try:
            arr = np.array(obj)
            arr = arr.astype(np.uint8) if arr.dtype != np.uint8 else arr
            if arr.ndim in (2, 3):
                return Image.fromarray(arr)
        except Exception:
            return None
    if isinstance(obj, dict):
        if "bytes" in obj and obj["bytes"] is not None:
            return try_decode_pil_from_bytes(obj["bytes"])
        if "array" in obj and obj["array"] is not None:
            try:
                arr = np.array(obj["array"])
                arr = arr.astype(np.uint8) if arr.dtype != np.uint8 else arr
                if arr.ndim in (2, 3):
                    return Image.fromarray(arr)
            except Exception:
                pass
        if "path" in obj and obj["path"] and os.path.exists(str(obj["path"])):
            try:
                img = Image.open(obj["path"])
                img.load()
                return img
            except Exception:
                pass
    return None


def save_image(img: Image.Image, save_path: Path):
    save_path.parent.mkdir(parents=True, exist_ok=True)
    if img.mode not in ["1", "L", "LA", "P", "RGB", "RGBA", "I", "I;16"]:
        img = img.convert("RGB")
    img.save(save_path)


def unique_save_path(folder: Path, stem: str, ext: str) -> Path:
    p = folder / f"{stem}{ext}"
    k = 1
    while p.exists():
        p = folder / f"{stem}_{k}{ext}"
        k += 1
    return p


def resolve_class_name(raw_label) -> str | None:
    try:
        tissue_id = int(float(str(raw_label).strip()))
    except (ValueError, TypeError):
        return None
    return TISSUE_ID_TO_NAME.get(tissue_id, None)


def process_parquet(parquet_path: Path, fold_num: int, split_mapping: dict[str, str]) -> dict:
    print(f"\n[INFO] Reading fold{fold_num}: {parquet_path.name}")
    df = pd.read_parquet(parquet_path)
    print(f"[INFO] Rows: {len(df)} | Columns: {list(df.columns)}")

    class_counts: dict[str, dict[str, int]] = {}
    saved = 0
    failed = 0
    no_split = 0

    for local_idx, row in enumerate(df.itertuples(index=False)):
        stem = f"fold{fold_num}_{local_idx:08d}"

        raw_label = getattr(row, CLASS_LABEL_COLUMN)
        if is_null_like(raw_label):
            print(f"  [WARN] {stem} has empty class label, skipped")
            failed += 1
            continue

        class_name = resolve_class_name(raw_label)
        if class_name is None:
            print(f"  [WARN] {stem} label '{raw_label}' is not in mapping table, skipped")
            failed += 1
            continue

        relative_path = f"{class_name}/{stem}{IMAGE_EXT}"
        split = split_mapping.get(relative_path, None)

        if split is None:
            alt_stem = f"fold{fold_num}_{local_idx}"
            alt_path = f"{class_name}/{alt_stem}{IMAGE_EXT}"
            split = split_mapping.get(alt_path, None)

        if split is None:
            print(f"  [WARN] {relative_path} not found in split CSV, skipped")
            no_split += 1
            failed += 1
            continue

        if split == "train":
            output_root = OUTPUT_TRAIN_ROOT
        elif split == "test":
            output_root = OUTPUT_TEST_ROOT
        else:
            print(f"  [WARN] {relative_path} has unknown split '{split}', skipped")
            failed += 1
            continue

        img = try_decode_image(getattr(row, IMAGE_COLUMN))
        if img is None:
            print(f"  [WARN] {stem} failed to decode image, skipped")
            failed += 1
            continue

        out_folder = output_root / class_name
        save_path = unique_save_path(out_folder, stem, IMAGE_EXT)

        try:
            save_image(img, save_path)
            if class_name not in class_counts:
                class_counts[class_name] = {"train": 0, "test": 0}
            class_counts[class_name][split] += 1
            saved += 1
        except Exception as e:
            print(f"  [ERROR] Failed to save ({save_path}): {e}")
            failed += 1

        done = saved + failed
        if done % 500 == 0:
            print(f"  ... Processed {done}/{len(df)} (saved {saved} / failed {failed})")

    print(f"[INFO] fold{fold_num} finished: saved {saved} / failed {failed} "
          f"(no_split_info: {no_split})")
    return class_counts


def print_summary(total_class_counts: dict):
    print("\n" + "=" * 70)
    print(f"[DONE] Train directory: {OUTPUT_TRAIN_ROOT}")
    print(f"[DONE] Test  directory: {OUTPUT_TEST_ROOT}")
    print(f"[DONE] Class statistics (total {len(total_class_counts)} classes):")
    print(f"  {'Class':<20s} {'Train':>8s} {'Test':>8s} {'Total':>8s}")
    print(f"  {'-'*20} {'-'*8} {'-'*8} {'-'*8}")

    total_train = 0
    total_test = 0
    for cls in CLASS_ORDER:
        counts = total_class_counts.get(cls, {"train": 0, "test": 0})
        train_n = counts.get("train", 0)
        test_n = counts.get("test", 0)
        total_train += train_n
        total_test += test_n
        print(f"  {cls:<20s} {train_n:>8d} {test_n:>8d} {train_n + test_n:>8d}")

    print(f"  {'-'*20} {'-'*8} {'-'*8} {'-'*8}")
    print(f"  {'TOTAL':<20s} {total_train:>8d} {total_test:>8d} {total_train + total_test:>8d}")
    print("=" * 70)


def main():
    for root in [OUTPUT_TRAIN_ROOT, OUTPUT_TEST_ROOT]:
        root.mkdir(parents=True, exist_ok=True)
        for cls in CLASS_ORDER:
            (root / cls).mkdir(parents=True, exist_ok=True)

    split_mapping = load_split_mapping(SPLIT_CSV_PATH)

    total_class_counts: dict[str, dict[str, int]] = {}

    for fold_num, parquet_path_str in enumerate(INPUT_PARQUET_PATHS, start=1):
        parquet_path = Path(parquet_path_str)
        if not parquet_path.exists():
            raise FileNotFoundError(f"Parquet file not found: {parquet_path}")

        class_counts = process_parquet(parquet_path, fold_num, split_mapping)
        for cls, counts in class_counts.items():
            if cls not in total_class_counts:
                total_class_counts[cls] = {"train": 0, "test": 0}
            for split_key in ["train", "test"]:
                total_class_counts[cls][split_key] += counts.get(split_key, 0)

    print_summary(total_class_counts)


if __name__ == "__main__":
    main()