import os, torch, nibabel as nib, numpy as np
from glob import glob
from torch.utils.data import DataLoader
import torch

# function that takes four slices from 4 modalities and stack them
def stack_slices(t1c, t2f, t1n, t2w):
    stacked_slices = np.stack((t1c, t2f, t1n, t2w), axis=0)
    return stacked_slices


# function that takes the segmentation mask and turn it into a 4 channel mask
def convert_to_multichannel(mask):
    """
    Convert labels to multi channels based on brats classes:
    The provided segmentation labels have values of:

    1 for NCR (necrotic)
    2 for ED (edema)
    3 for ET (enhancing tumor)
    0 for background.
    The possible classes are TC (Tumor core == NCR and ET), WT (Whole tumor)
    , ET (Enhancing tumor) and background.

    """
    results = []
    # merge label 1 and label 3 to construct TC
    results.append( np.logical_or(mask == 1, mask == 3) )
    # merge labels 1, 2 and 3 to construct WT
    results.append( mask != 0 )
    # merge label 3 to keep ET
    results.append( mask == 3 )
    # merge label 0 to keep background
    results.append( mask == 0 )

    return np.stack(results, axis=0).astype(np.uint8)
class MyIterableDataset(torch.utils.data.IterableDataset):
    def __init__(self, images_t1c, images_t2f, images_t1n, images_t2w, segs):
        self.images_t1c = images_t1c
        self.images_t2f = images_t2f
        self.images_t1n = images_t1n
        self.images_t2w = images_t2w
        self.segs = segs

    def stream(self):
        for i in range(self.start, self.end):
            t1c = nib.load(self.images_t1c[i]).get_fdata()
            t2f = nib.load(self.images_t2f[i]).get_fdata()
            t1n = nib.load(self.images_t1n[i]).get_fdata()
            t2w = nib.load(self.images_t2w[i]).get_fdata()
            seg = nib.load(self.segs[i]).get_fdata()
            for j in range(t1c.shape[2]):
                if np.sum(t1c[:,:,j]) != 0:
                    yield stack_slices(t1c[:,:,j], t2f[:,:,j], t1n[:,:,j], t2w[:,:,j]), convert_to_multichannel(seg[:,:,j])
                else:
                    continue

    def __iter__(self):
        worker_info = torch.utils.data.get_worker_info()
        if worker_info is None:
            self.start = 0
            self.end = len(self.images_t1c)
        else:
            per_worker = int(np.ceil(len(self.images_t1c) / float(worker_info.num_workers)))
            self.worker_id = worker_info.id
            self.start = self.worker_id * per_worker
            self.end = min(self.start + per_worker, len(self.images_t1c))
        return self.stream()

def get_MyIterableDataset(folder_name):
    
    # check if the folder exists
    if not os.path.exists(folder_name):
        raise FileNotFoundError(f"Folder {folder_name} not found,current working directory: {os.getcwd()}")

    images_t1c = sorted(glob(os.path.join(folder_name, "*/*-t1c.nii.gz")))
    images_t2f = sorted(glob(os.path.join(folder_name, "*/*-t2f.nii.gz")))
    images_t1n = sorted(glob(os.path.join(folder_name, "*/*-t1n.nii.gz")))
    images_t2w = sorted(glob(os.path.join(folder_name, "*/*-t2w.nii.gz")))

    segs = sorted(glob(os.path.join(folder_name, "*/*seg.nii.gz")))


    number_of_scans = len(images_t1c)
    print(f"Number of scans: {number_of_scans}")
    number_of_slices = nib.load(images_t1c[0]).get_fdata().shape[2]
    
    # do a train test split
    train_size = int(0.8 * number_of_scans)
    train_images_t1c = images_t1c[:train_size]
    train_images_t2f = images_t2f[:train_size]
    train_images_t1n = images_t1n[:train_size]
    train_images_t2w = images_t2w[:train_size]
    train_segs = segs[:train_size]

    test_images_t1c = images_t1c[train_size:]
    test_images_t2f = images_t2f[train_size:]
    test_images_t1n = images_t1n[train_size:]
    test_images_t2w = images_t2w[train_size:]
    test_segs = segs[train_size:]

    train_dataset = MyIterableDataset(train_images_t1c, train_images_t2f, train_images_t1n, train_images_t2w, train_segs)
    test_dataset = MyIterableDataset(test_images_t1c, test_images_t2f, test_images_t1n, test_images_t2w, test_segs)

    return train_dataset, test_dataset