import numpy as np

import os

from natsort import natsorted

import pandas as pd

from skimage.color import rgb2hsv, rgb2gray

from skimage.filters import gaussian, threshold_triangle

from skimage.exposure import rescale_intensity

from PyQt5.QtCore import QThread, pyqtSignal

from PIL import Image

class DabAnalysis(QThread):

    maxcuts = pyqtSignal(int)

    info = pyqtSignal(str)

    countChanged = pyqtSignal(int)

    figures = pyqtSignal()

    activate = pyqtSignal(bool)

    def __init__(self, path, save=False):

        super().__init__()

        self.inputpath = path

        self.save = save

        self.threshold = None

    def run(self, debug=False):

        self.activate.emit(False)

        analysis = []

        files = [f for f in natsorted(os.listdir(self.inputpath)) if not f.endswith("Overlay.png")]

        self.maxcuts.emit(len([f for f in files if f.endswith('.png')]))

        i = 0

        for file in files:

            if file.endswith('.png'):

                self.info.emit("Analysing "+file)

                print(file)

                info = []

                image = np.array(Image.open(self.inputpath+os.sep+file))[:, :, :3]

                self.current_image = image[::10, ::10]

                self.figures.emit()

                info.append(str(file))

                info.extend(self.QuantStain(image, filename=file, save=self.save))

                info.append(self.QuantCore(image, filename=file, save=self.save))

                analysis.append(info)

                print(info)

                self.countChanged.emit(int(i)+1)  # EMIT the loading bar

            self.info.emit(file + " analysed")

            i += 1

        # TODO can make this more lightweight by removing pandas and using csv

        df = pd.DataFrame(analysis, columns=('CoreName', 'AMTsignal', 'Mean_intensity', 'Standard_Dev_intensity',

                                             'AMTtissue'))

        df['AFperAMTT'] = df['AMTsignal']/df['AMTtissue']*100

        df['Mean_Intensity_perAMTT'] = df['Mean_intensity'] / df['AMTtissue'] * 100

        df['SD_Intensity_perAMTT'] = df['Standard_Dev_intensity'] / df['AMTtissue'] * 100

        df.to_excel(self.inputpath+os.sep+'CoreAnalysis_'+str(df['CoreName'][0])[:-6]+'.xlsx')

        self.info.emit("All Files Analysed - ready")

        self.activate.emit(True)

    def QuantStain(self, image, filename, save=False):

        img_hsv = rgb2hsv(image)

        img_hue = img_hsv[:, :, 0]

        image_sat = img_hsv[:, :, 1]

        hue = np.logical_and(img_hue > 0.02, img_hue < 0.10)  # BROWN PIXELS BETWEEN 0.02 and 0.10

        if self.threshold:

            stain = np.logical_and(hue, image_sat > self.threshold)

        else:

            print("normal threshold")

            stain = np.logical_and(hue, image_sat > 0.79)

        # TODO : fix this - sent bug report to Github

        self.current_image = stain[::10, ::10].astype(float)

        self.figures.emit()

        if save:

            self.info.emit("Saving - " + filename+'_stain.tiff')

            imagesave = Image.fromarray(stain)

            imagesave.save(self.inputpath+os.sep+filename+'_stain.tiff')

        stint = np.copy(image)

        stint = rgb2gray(stint)

        stint = rescale_intensity(stint, out_range=(0, 255))

        stint[stain == 0] = 0  # array with only the stained pixels

        stint = np.ravel(stint)

        stint = stint[stint != 0]

        stint_mean = stint.mean()

        stint_std = stint.std()

        stained = np.sum(stain)

        return stained, stint_mean, stint_std

    def QuantCore(self, image, filename, save=False):

        image = gaussian(rgb2gray(image), sigma=2)

        thresh = threshold_triangle(image[image > 0])

        binary = np.logical_and(image < thresh, image > 0)

        wholeCore = np.sum(binary)

        if save:

            self.info.emit("Saving - " + filename + '_core.tiff')

            imagesave = Image.fromarray(binary)

            imagesave.save(self.inputpath+os.sep+filename + '_core.tiff')

        return wholeCore