from sklearn.decomposition import PCA

from colour import Color

import numpy as np

import matplotlib

matplotlib.use('Agg')

import seaborn as sns

import pylab as plt

import mpld3

sns.set(color_codes=True)

CSS = """

table

{

  border-collapse: collapse;

}

th

{

  color: #ffffff;

  background-color: #000000;

}

td

{

  background-color: #cccccc;

}

table, th, td

{

  font-family:Arial, Helvetica, sans-serif;

  border: 1px solid black;

  text-align: right;

}

"""

class SampleHTML():

    def __init__(self, name, label, proba, survival):

        """

        """

        try:

            nbdays, isdead = survival

        except Exception:

            nbdays, isdead = 'NaN', 'NaN'

        self.html =  """

<table border="1" class="dataframe">

  <thead>

    <tr style="text-align: right;">

      <th></th>

      <th>{0}</th>

    </tr>

  </thead>

  <tbody>

    <tr>

      <th>Assigned class</th>

      <td>{1}</td>

    </tr>

    <tr>

      <th>class probability</th>

      <td>{2}</td>

    </tr>

    <tr>

      <th>nb days followed</th>

      <td>{3}</td>

    </tr>

    <tr>

      <th>Event</th>

      <td>{4}</td>

    </tr>

  </tbody>

</table>

                """.format(name, label, proba, nbdays, isdead)

def make_color_dict_from_r(labels):

    """ """

    labels_set = set(labels)

    cin = Color('red')

    cout = Color('#56f442')

    gradient = list(map(lambda x:x.get_rgb(),

                   cin.range_to(cout, len(labels_set))))

    len_color = len(gradient)

    if len_color > 2:

        gradient[1] = Color('green').get_rgb()

        gradient[2] = Color('blue').get_rgb()

    if len_color > 3:

        gradient[3] = Color('cyan').get_rgb()

    if len_color > 4:

        gradient[4] = Color('magenta').get_rgb()

    if len_color > 5:

        gradient[5] = Color('yellow').get_rgb()

    return dict(zip(labels_set, gradient))

def make_color_list(id_list):

    """

    According to an id_list define a color gradient

    return {id:color}

    """

    try:

        assert([Color(idc) for idc in id_list])

    except Exception:

        pass

    else:

        return id_list

    color_dict = make_color_dict(id_list)

    return np.array([color_dict[label] for label in id_list])

def make_color_dict(id_list):

    """

    According to an id_list define a color gradient

    return {id:color}

    """

    id_list = list(set(id_list))

    first_c = Color("red")

    middle_c = Color("green")

    m_length1 = len(id_list)

    gradient = list(first_c.range_to(middle_c, m_length1))

    color_dict =  {id_list[i]: gradient[i].get_hex_l()

                   for i in range(len(id_list))}

    return color_dict

def plot_kernel_plots(

        test_labels,

        test_labels_proba,

        labels,

        activities,

        activities_test,

        dataset,

        path_html,

        metadata_frame=None):

    """

    perform a html kernel plot

    """

    fig, ax = plt.subplots(figsize=(7, 7))

    color_dict = make_color_dict_from_r(labels)

    labels_c_test = np.array([color_dict[label] for label in test_labels])

    decomp = PCA(n_components=2)

    X, Y = decomp.fit_transform(activities).T

    X_test, Y_test = decomp.transform(activities_test).T

    for label in set(labels):

        ax.scatter(

            X_test[test_labels == label],

            Y_test[test_labels == label],

            s=40,

            # linewidths=2.0,

            alpha=1.0,

           # marker='square_cross',

            edgecolors='k',

            zorder=2,

           color=labels_c_test[test_labels == label],

           label='test cluster nb {0}'.format(label))

        sns.kdeplot(

            X[labels == label],

            Y[labels == label],

            shade=True,

            cmap=sns.dark_palette(color_dict[label], as_cmap=True),

            color=color_dict[label],

            ax=ax,

            label='cluster nb {0}'.format(label),

            zorder=1,

            thresh=False,

            alpha=0.7

        )

    survival_test = np.nan_to_num(dataset.survival_test)

    labels = [SampleHTML(

        name=dataset.sample_ids_test[i],

        label=test_labels[i],

        survival=np.asarray(survival_test[i])[0],

        proba=test_labels_proba[i][test_labels[i]]).html

              for i in range(len(test_labels))]

    scatter = ax.plot(X_test, Y_test, 'o', color='b', mec='k',

                      ms=15, mew=1, alpha=0.0, zorder=3,)[0]

    tooltip = mpld3.plugins.PointHTMLTooltip(

        scatter, labels, voffset=10, hoffset=10, css=CSS)

    mpld3.plugins.connect(fig, tooltip)

    mpld3.save_html(fig, path_html)

    print('kde plot saved at:{0}'.format(path_html))