import tensorflow as tf
import numpy as np
import os
# from matplotlib import pyplot as plt
from tensorflow.python.framework import dtypes
from tensorflow.python.framework.ops import convert_to_tensor
import skimage as sk
from skimage import transform
import SimpleITK as sitk

IMAGENET_MEAN = tf.constant([123.68, 116.779, 103.939], dtype=tf.float32)


class ImageDataGenerator(object):

    def __init__(self, txt_file, mode, batch_size, num_classes, shuffle=True, buffer_size=5):

        """Create a new ImageDataGenerator.
        Receives a path string to a text file, where each line has a path string to an image and
        separated by a space, then with an integer referring to the class number.

        Args:
            txt_file: path to the text file.
            mode: either 'training' or 'validation'. Depending on this value, different parsing functions will be used.
            batch_size: number of images per batch.
            num_classes: number of classes in the dataset.
            shuffle: wether or not to shuffle the data in the dataset and the initial file list.
            buffer_size: number of images used as buffer for TensorFlows shuffling of the dataset.

        Raises:
            ValueError: If an invalid mode is passed.
        """

        self.txt_file = txt_file
        self.num_classes = num_classes

        # retrieve the data from the text file
        self._read_txt_file()

        # number of samples in the dataset
        self.data_size = len(self.img_paths)

        # initial shuffling of the file and label lists together
        if shuffle:
            self._shuffle_lists()

        # convert lists to TF tensor
        self.img_paths = convert_to_tensor(self.img_paths, dtype=dtypes.string)

        # create dataset
        data = tf.data.Dataset.from_tensor_slices((self.img_paths))

        # repeat indefinitely (train.py will count the epochs)
        data = data.repeat()

        # distinguish between train/infer. when calling the parsing functions
        self.get_patches_fn = lambda filename: tf.py_func(self.extract_patch, [filename, [384,384,3], 2], [tf.float32, tf.float32])

        if mode == 'training':
            data = data.map(self.get_patches_fn, num_parallel_calls=8)

        elif mode == 'inference':
            data = data.map(self._parse_function_inference, num_parallel_calls=8)

        else:
            raise ValueError("Invalid mode '%s'." % (mode))

        # shuffle the first `buffer_size` elements of the dataset
        if shuffle:
            data = data.shuffle(buffer_size=buffer_size)

        # create a new dataset with batches of images
        data = data.batch(batch_size)

        self.data = data

    def _read_txt_file(self):
        """Read the content of the text file and store it into lists."""
        with open(self.txt_file, 'r') as f:
            rows = f.readlines()
            self.img_paths = [row[:-1] for row in rows]

    def _shuffle_lists(self):
        """Conjoined shuffling of the list of paths and labels."""
        path = self.img_paths
        permutation = np.random.permutation(self.data_size)
        self.img_paths = []
        for i in permutation:
            self.img_paths.append(path[i])

    def extract_patch(self, filename, patch_size, num_class, num_patches=1):
        """Input parser for samples of the training set."""
        # convert label number into one-hot-encoding

        image, mask = self.parse_fn(filename) # get the image and its mask
        image_patches = []
        mask_patches = []
        num_patches_now = 0

        while num_patches_now < num_patches:
            # z = np.random.randint(1, mask.shape[2]-1)
            z = self.random_patch_center_z(mask, patch_size=patch_size) # define the centre of current patch
            image_patch = image[:, :, z-1:z+2]
            mask_patch  =  mask[:, :, z]
            
            image_patches.append(image_patch)
            mask_patches.append(mask_patch)
            num_patches_now += 1
        image_patches = np.stack(image_patches) # make into 4D (batch_size, patch_size[0], patch_size[1], patch_size[2])
        mask_patches = np.stack(mask_patches) # make into 4D (batch_size, patch_size[0], patch_size[1], patch_size[2])

        mask_patches = self._label_decomp(mask_patches, num_cls=num_class) # make into 5D (batch_size, patch_size[0], patch_size[1], patch_size[2], num_classes)
        #print image_patches.shape
        return image_patches[0,...].astype(np.float32), mask_patches[0,...].astype(np.float32)

    def random_patch_center_z(self, mask, patch_size):
        # bounded within the brain mask region
        limX, limY, limZ = np.where(mask>0)
        if (np.min(limZ) + patch_size[2] // 2 + 1) < (np.max(limZ) - patch_size[2] // 2):
            z = np.random.randint(low = np.min(limZ) + patch_size[2] // 2 + 1, high = np.max(limZ) - patch_size[2] // 2)
        else:
            z = np.random.randint(low = patchsize[2]//2, high = mask.shape[2] - patchsize[2]//2)

        limX, limY, limZ = np.where(mask>0)

        z = np.random.randint(low = max(1, np.min(limZ)), high = min(np.max(limZ), mask.shape[2] - 2))
        # z = np.random.randint(low = max(1, np.min(limZ)), high = min(np.max(limZ), mask.shape[2] - 2))

        return z

    def parse_fn(self, data_path):
        '''
        :param image_path: path to a folder of a patient
        :return: normalized entire image with its corresponding label
        In an image, the air region is 0, so we only calculate the mean and std within the brain area
        For any image-level normalization, do it here
        '''
        path = data_path.split(",")
        image_path = path[0]
        label_path = path[1]
        #itk_image = zoom2shape(image_path, [512,512])#os.path.join(image_path, 'T1_unbiased_brain_rigid_to_mni.nii.gz'))
        #itk_mask = zoom2shape(label_path, [512,512], label=True)#os.path.join(image_path, 'T1_brain_seg_rigid_to_mni.nii.gz'))
        itk_image = sitk.ReadImage(image_path)#os.path.join(image_path, 'T1_unbiased_brain_rigid_to_mni.nii.gz'))
        itk_mask = sitk.ReadImage(label_path)#os.path.join(image_path, 'T1_brain_seg_rigid_to_mni.nii.gz'))
        # itk_image = sitk.ReadImage(os.path.join(image_path, 'T2_FLAIR_unbiased_brain_rigid_to_mni.nii.gz'))

        image = sitk.GetArrayFromImage(itk_image)
        mask = sitk.GetArrayFromImage(itk_mask)
        #image[image >= 1000] = 1000
        binary_mask = np.ones(mask.shape)
        mean = np.sum(image * binary_mask) / np.sum(binary_mask)
        std = np.sqrt(np.sum(np.square(image - mean) * binary_mask) / np.sum(binary_mask))
        image = (image - mean) / std  # normalize per image, using statistics within the brain, but apply to whole image

        mask[mask==2] = 1

        return image.transpose([1,2,0]), mask.transpose([1,2,0]) # transpose the orientation of the


    def _label_decomp(self, label_vol, num_cls):
        """
        decompose label for softmax classifier
        original labels are batchsize * W * H * 1, with label values 0,1,2,3...
        this function decompse it to one hot, e.g.: 0,0,0,1,0,0 in channel dimension
        numpy version of tf.one_hot
        """
        one_hot = []
        for i in xrange(num_cls):
            _vol = np.zeros(label_vol.shape)
            _vol[label_vol == i] = 1
            one_hot.append(_vol)

        return np.stack(one_hot, axis=-1)
    # def augment(self, x):
    #     # add more types of augmentations here
    #     augmentations = [self.flip]
    #     for f in augmentations:
    #         x = tf.cond(tf.random_uniform([], 0, 1) < 0.25, lambda: f(x), lambda: x)
            
    #     return x

    # def flip(self, x):
    #     """Flip augmentation
    #     Args:
    #         x: Image to flip
    #     Returns:
    #         Augmented image
    #     """
    #     x = tf.image.random_flip_left_right(x)
    #     # x = tf.image.random_flip_up_down(x)

    #     return x