import os
import warnings
import numpy as np
import pandas as pd
import matplotlib
from matplotlib.colors import hex2color
from matplotlib import font_manager
from scipy.stats import gaussian_kde
from cycler import cycler
from mpl_toolkits.axes_grid1 import make_axes_locatable

try:
    os.environ['DISPLAY']
except KeyError:
    matplotlib.use('Agg')
import matplotlib.pyplot as plt
with warnings.catch_warnings():
    warnings.simplefilter('ignore')  # catch warnings that system can't find fonts
    fm = font_manager.fontManager
    fm.findfont('Raleway')
    fm.findfont('Lato')

warnings.filterwarnings(action="ignore", module="matplotlib", message="^tight_layout")

dark_gray = '.15'

_colors = ['#4C72B0', '#55A868', '#C44E52',
           '#8172B2', '#CCB974', '#64B5CD']

style_dictionary = {
    'figure.figsize': (3, 3),
    'figure.facecolor': 'white',

    'figure.dpi': 200,
    'savefig.dpi': 200,

    'text.color': 'k',

    "legend.frameon": False,
    "legend.numpoints": 1,
    "legend.scatterpoints": 1,

    'font.family': ['sans-serif'],
    'font.serif': ['Computer Modern Roman', 'serif'],
    'font.monospace': ['Inconsolata', 'Computer Modern Typewriter', 'Monaco'],
    'font.sans-serif': ['Helvetica', 'Lato', 'sans-serif'],

    'patch.facecolor': _colors[0],
    'patch.edgecolor': 'none',

    'grid.linestyle': "-",

    'axes.labelcolor': dark_gray,
    'axes.facecolor': 'white',
    'axes.linewidth': 1.,
    'axes.grid': False,
    'axes.axisbelow': False,
    'axes.edgecolor': dark_gray,
    'axes.prop_cycle': cycler('color', _colors),

    'lines.solid_capstyle': 'round',
    'lines.color': _colors[0],
    'lines.markersize': 4,

    'image.cmap': 'viridis',
    'image.interpolation': 'none',

    'xtick.direction': 'in',
    'xtick.major.size': 4,
    'xtick.minor.size': 2,
    'xtick.color': dark_gray,

    'ytick.direction': 'in',
    'ytick.major.size': 4,
    'ytick.minor.size': 2,
    "ytick.color": dark_gray,
    
}

matplotlib.rcParams.update(style_dictionary)


def refresh_rc():
    matplotlib.rcParams.update(style_dictionary)
    print('rcParams updated')


class FigureGrid:
    """
    Generates a grid of axes for plotting

    axes can be iterated over or selected by number. e.g.:

    >>> # iterate over axes and plot some nonsense
    >>> fig = FigureGrid(4, max_cols=2)
    >>> for i, ax in enumerate(fig):
    >>>     plt.plot(np.arange(10) * i)

    >>> # select axis using indexing
    >>> ax3 = fig[3]
    >>> ax3.set_title("I'm axis 3")
    """

    def __init__(self, n: int, max_cols=3, scale=3):
        """
        :param n: number of axes to generate
        :param max_cols: maximum number of axes in a given row
        """

        self.n = n
        self.nrows = int(np.ceil(n / max_cols))
        self.ncols = int(min((max_cols, n)))
        figsize = self.ncols * scale, self.nrows * scale

        # create figure
        self.gs = plt.GridSpec(nrows=self.nrows, ncols=self.ncols)
        self.figure = plt.figure(figsize=figsize)

        # create axes
        self.axes = {}
        for i in range(n):
            row = int(i // self.ncols)
            col = int(i % self.ncols)
            self.axes[i] = plt.subplot(self.gs[row, col])

    def __getitem__(self, item):
        return self.axes[item]

    def __iter__(self):
        for i in range(self.n):
            yield self[i]

    def tight_layout(self, **kwargs):
        """wrapper for plt.tight_layout"""
        self.gs.tight_layout(self.figure, **kwargs)

    def despine(self, top=True, right=True, bottom=False, left=False):
        """removes axis spines (default=remove top and right)"""
        despine(ax=self, top=top, right=right, bottom=bottom, left=left)

    def detick(self, x=True, y=True):
        """
        removes tick labels

        :param x: bool, if True, remove tick labels from x-axis
        :param y: bool, if True, remove tick labels from y-axis
        """

        for ax in self:
            detick(ax, x=x, y=y)

    def savefig(self, filename, pad_inches=0.1, bbox_inches='tight', *args, **kwargs):
        """
        wrapper for savefig, including necessary paramters to avoid cut-off

        :param filename: str, name of output file
        :param pad_inches: float, number of inches to pad
        :param bbox_inches: str, method to use when considering bbox inches
        :param args: additional args for plt.savefig()
        :param kwargs: additional kwargs for plt.savefig()
        :return:
        """
        self.figure.savefig(
            filename, pad_inches=pad_inches, bbox_inches=bbox_inches, *args, **kwargs)


def detick(ax=None, x=True, y=True):
    """helper function for removing tick labels from an axis"""
    if not ax:
        ax = plt.gca()
    if x:
        ax.xaxis.set_major_locator(plt.NullLocator())
    if y:
        ax.yaxis.set_major_locator(plt.NullLocator())


def despine(ax=None, top=True, right=True, bottom=False, left=False) -> None:
    """helper function for removing axis spines"""
    if not ax:
        ax = plt.gca()

    # set spines
    if top:
        ax.spines['top'].set_visible(False)
    if right:
        ax.spines['right'].set_visible(False)
    if bottom:
        ax.spines['bottom'].set_visible(False)
    if left:
        ax.spines['left'].set_visible(False)

    # set ticks
    if top and bottom:
        ax.xaxis.set_ticks_position('none')
    elif top:
        ax.xaxis.set_ticks_position('bottom')
    elif bottom:
        ax.xaxis.set_ticks_position('top')
    if left and right:
        ax.yaxis.set_ticks_position('none')
    elif left:
        ax.yaxis.set_ticks_position('right')
    elif right:
        ax.yaxis.set_ticks_position('left')


def xtick_vertical(ax=None):
    """set xticklabels on ax to vertical instead of the horizontal default orientation"""
    if ax is None:
        ax = plt.gca()
    xt = ax.get_xticks()
    if np.all(xt.astype(int) == xt):  # ax.get_xticks() returns floats
        xt = xt.astype(int)
    ax.set_xticklabels(xt, rotation='vertical')


def equalize_numerical_tick_number(ax=None):
    if ax is None:
        ax = plt.gca()
    xticks = ax.get_xticks()
    yticks = ax.get_yticks()
    nticks = min(len(xticks), len(yticks))
    ax.set_xticks(np.round(np.linspace(min(xticks), max(xticks), nticks), 1))
    ax.set_yticks(np.round(np.linspace(min(yticks), max(yticks), nticks), 1))


def equalize_axis_size(ax=None):
    if ax is None:
        ax = plt.gca()
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    ax_min = min(xlim[0], ylim[0])
    ax_max = max(xlim[1], ylim[1])
    ax.set_xlim((ax_min, ax_max))
    ax.set_ylim((ax_min, ax_max))


def map_categorical_to_cmap(data: np.ndarray, cmap=plt.get_cmap()):
    """
    create a discrete colormap from cmap appropriate for data

    :param data: categorical vector to map to colormap
    :param cmap: cmap to discretize, or 'random'
    :return np.ndarray, dict: vector of colors matching input data, dictionary of labels
      to their respective colors
    """
    categories = np.unique(data)
    n = len(categories)
    if isinstance(cmap, str) and 'random' in cmap:
        colors = np.random.rand(n, 3)
    else:
        colors = cmap(np.linspace(0, 1, n))
    category_to_color = dict(zip(categories, colors))
    return np.array([category_to_color[i] for i in data]), category_to_color


def add_legend_to_categorical_vector(
        colors: np.ndarray, labels, ax, loc='best',  # bbox_to_anchor=(0.98, 0.5),
        markerscale=0.75, **kwargs):
    """
    Add a legend to a plot where the color scale was set by discretizing a colormap.

    :param colors: np.ndarray, output of map_categorical_vector_to_cmap()
    :param labels: np.ndarray, category labels
    :param ax: axis on which the legend should be plotted
    :param kwargs: additional kwargs for legend
    :return: None
    """
    artists = []
    for c in colors:
        artists.append(plt.Line2D((0, 1), (0, 0), color=c, marker='o', linestyle=''))
    ax.legend(
        artists, labels, loc=loc, markerscale=markerscale,  # bbox_to_anchor=bbox_to_anchor,
        **kwargs)


class scatter:

    @staticmethod
    def categorical(
            x, y, c, ax=None, cmap=plt.get_cmap(), legend=True, legend_kwargs=None,
            randomize=True, remove_ticks=False, *args, **kwargs):
        """
        wrapper for scatter wherein the output should be colored by a categorical vector
        c

        :param x, y: np.ndarray, coordinate data to be scattered
        :param c: categories for data
        :param ax: axis on which to scatter data
        :param cmap: color map
        :param legend: bool, if True, plot legend
        :param legend_kwargs: additional kwargs for legend
        :param randomize: if True, randomize order of plotting
        :param remove_ticks: if True, removes axes ticks and labels
        :param args: additional args for scatter
        :param kwargs: additional kwargs for scatter
        :return: ax
        """
        if not ax:  # todo replace with plt.gridspec() method
            ax = plt.gca()

        if legend_kwargs is None:
            legend_kwargs = dict()

        color_vector, category_to_color = map_categorical_to_cmap(c, cmap)

        if randomize:
            ind = np.random.permutation(len(x))
        else:
            ind = np.argsort(np.ravel(c))

        ax.scatter(np.ravel(x)[ind], np.ravel(y)[ind], c=color_vector[ind], *args,
                   **kwargs)
        if remove_ticks:
            ax.xaxis.set_major_locator(plt.NullLocator())
            ax.yaxis.set_major_locator(plt.NullLocator())

        labels, colors = zip(*sorted(category_to_color.items()))
        if legend:
            add_legend_to_categorical_vector(colors, labels, ax, markerscale=2,
                                             **legend_kwargs)
        return ax

    @staticmethod
    def continuous(x, y, c=None, ax=None, colorbar=True, randomize=True,
                   remove_ticks=False, **kwargs):
        """
        wrapper for scatter wherein the coordinates x and y are colored according to a
        continuous vector c
        :param x, y: np.ndarray, coordinate data
        :param c: np.ndarray, continuous vector by which to color data points
        :param remove_ticks: remove axis ticks and labels
        :param args: additional args for scatter
        :param kwargs: additional kwargs for scatter
        :return: ax
        """

        if ax is None:
            ax = plt.gca()

        if c is None:  # plot density if no color vector is provided
            x, y, c = scatter.density_2d(x, y)

        if randomize:
            ind = np.random.permutation(len(x))
        else:
            ind = np.argsort(c)

        sm = ax.scatter(x[ind], y[ind], c=c[ind], **kwargs)
        if remove_ticks:
            ax.xaxis.set_major_locator(plt.NullLocator())
            ax.yaxis.set_major_locator(plt.NullLocator())
        if colorbar:
            cb = plt.colorbar(sm)
            cb.ax.xaxis.set_major_locator(plt.NullLocator())
            cb.ax.yaxis.set_major_locator(plt.NullLocator())
        return ax

    @staticmethod
    def density_2d(x, y):
        """return x and y and their density z, sorted by their density (smallest to largest)

        :param x, y: np.ndarray: coordinate data
        :return: sorted x, y, and density
        """
        xy = np.vstack([np.ravel(x), np.ravel(y)])
        z = gaussian_kde(xy)(xy)
        return np.ravel(x), np.ravel(y), np.arcsinh(z)


def tatarize(n):
    """
    Return n-by-3 RGB color matrix using the "tatarize" color alphabet (n <= 269)
    :param n:
    :return:
    """

    with open(os.path.expanduser('~/.seqc/tools/tatarize_269.txt')) as f:
        s = f.read().split('","')
    s[0] = s[0].replace('{"', '')
    s[-1] = s[-1].replace('"}', '')
    s = [hex2color(s) for s in s]
    return s[:n]


class Diagnostics:

    @staticmethod
    def mitochondrial_fraction(data: pd.DataFrame, ax=None):
        """plot the fraction of mRNA that are of mitochondrial origin for each cell.

        :param data: DataFrame of cells x genes containing gene expression information
        :param ax: matplotlib axis
        :return: ax
        """

        mt_genes = data.molecules.columns[data.molecules.columns.str.contains('MT-')]
        mt_counts = data.molecules[mt_genes].sum(axis=1)
        library_size = data.molecules.sum(axis=1)

        if ax is None:
            ax = plt.gca()

        scatter.continuous(library_size, mt_counts / library_size)
        ax.set_title('Mitochondrial Fraction')
        ax.set_xlabel('Total Gene Expression')
        ax.set_ylabel('Mitochondrial Gene Expression')
        _, xmax = ax.get_xlim()
        ax.set_xlim((None, xmax))
        _, ymax = ax.get_ylim()
        ax.set_ylim((None, ymax))
        despine(ax)
        return ax
    
    @staticmethod
    def pca_components(fig_name, variance_ratio, pca_comps):
        '''
        :param fig_name:    name for the figure
        :param variance_ratio:    variance ratios of at least 20 pca components
        :param pca_comps:    pca components of cells
        '''

        fig = FigureGrid(4, max_cols=2)
        ax_pca, ax_pca12, ax_pca13, ax_pca23 = iter(fig)
        ax_pca.plot(variance_ratio[0:20]*100.0, c = '#1f77b4')
        ax_pca.set_xlabel('pca components')
        ax_pca.set_ylabel('explained variance')
        ax_pca.set_xlim([0,20.5])

        ax_pca12.scatter(pca_comps[:, 0], pca_comps[:, 1], s=3, c = '#1f77b4')
        ax_pca12.set_xlabel("pca 1")
        ax_pca12.set_ylabel("pca 2")
        xtick_vertical(ax=ax_pca12)

        ax_pca13.scatter(pca_comps[:, 0], pca_comps[:, 2], s=3, c = '#1f77b4')
        ax_pca13.set_xlabel("pca 1")
        ax_pca13.set_ylabel("pca 3")
        xtick_vertical(ax=ax_pca13)

        ax_pca23.scatter(pca_comps[:, 1], pca_comps[:, 2], s=3, c = '#1f77b4')
        ax_pca23.set_xlabel("pca 2")
        ax_pca23.set_ylabel("pca 3")
        xtick_vertical(ax=ax_pca23)

        fig.tight_layout()
        fig.savefig(fig_name, dpi=300, transparent=True)
    
    @staticmethod
    def phenograph_clustering(fig_name, cell_sizes, clust_info, tsne_comps):
        # sketching tSNE and Phenograph figure
        fig = FigureGrid(2, max_cols=2)
        ax_tsne, ax_phenograph = iter(fig)

        cl = np.log10(cell_sizes)
        splot = ax_tsne.scatter(tsne_comps[:, 0], tsne_comps[:, 1],
                                c=cl, s=3, cmap=plt.cm.coolwarm, vmin = np.min(cl),
                                vmax=np.percentile(cl, 98))

        ax_tsne.set_title("UMI Counts (log10)")
        ax_tsne.set_xticks([])
        ax_tsne.set_yticks([])
        divider = make_axes_locatable(ax_tsne)
        cax = divider.append_axes('right', size='3%', pad=0.04)
        fig.figure.colorbar(splot, cax=cax, orientation='vertical')

        # this is a list of contrast colors for clutering
        cmap=["#010067","#D5FF00","#FF0056","#9E008E","#0E4CA1","#FFE502","#005F39","#00FF00","#95003A",
              "#FF937E","#A42400","#001544","#91D0CB","#620E00","#6B6882","#0000FF","#007DB5","#6A826C",
              "#00AE7E","#C28C9F","#BE9970","#008F9C","#5FAD4E","#FF0000","#FF00F6","#FF029D","#683D3B",
              "#FF74A3","#968AE8","#98FF52","#A75740","#01FFFE","#FFEEE8","#FE8900","#BDC6FF","#01D0FF",
              "#BB8800","#7544B1","#A5FFD2","#FFA6FE","#774D00","#7A4782","#263400","#004754","#43002C",
              "#B500FF","#FFB167","#FFDB66","#90FB92","#7E2DD2","#BDD393","#E56FFE","#DEFF74","#00FF78",
              "#009BFF","#006401","#0076FF","#85A900","#00B917","#788231","#00FFC6","#FF6E41","#E85EBE"]

        colors = []
        for i in range(len(clust_info)):
            colors.append(cmap[clust_info[i]])

        for ci in range(np.min(clust_info),np.max(clust_info)+1):
            x1 = []
            y1 = []
            for i in range(len(clust_info)):
                if clust_info[i] == ci:
                    x1.append(tsne_comps[i, 0])
                    y1.append(tsne_comps[i, 1])
                    cl = colors[i]
            ax_phenograph.scatter(x1, y1, c=cl, s=3, label="C"+str(ci+1))
        ax_phenograph.set_title('Phenograph Clustering')
        ax_phenograph.set_xticks([])
        ax_phenograph.set_yticks([])
        ax_phenograph.legend(bbox_to_anchor=(1, 1), loc=2, borderaxespad=0., markerscale=2)

        fig.tight_layout()
        fig.savefig(fig_name, dpi=300, transparent=True)

    @staticmethod
    def cell_size_histogram(data, f=None, ax=None, save=None):
        if ax is None:
            f, ax = plt.subplots(figsize=(3.5, 3.5))
        if f is None:
            f = plt.gcf()

        cell_size = data.sum(axis=1)

        plt.hist(np.log10(cell_size), bins=25, log=True)
        ax.set_xlabel('log10(cell size)')
        ax.set_ylabel('frequency')
        despine(ax)
        xtick_vertical(ax)

        if save is not None:
            if not isinstance(save, str):
                raise TypeError('save must be the string filename of the '
                                'figure-to-be-saved')
            plt.tight_layout()
            f.savefig(save, dpi=300)
