from matplotlib.colors import rgb2hex
import pandas.core.common as com

def monkeypatch_method(cls):
    def decorator(func):
        setattr(cls, func.__name__, func)
        return func
    return decorator

@monkeypatch_method(pd.DataFrame)
def style(self, rows=None, columns=None, frame=None):
    styles = self._build_styles(
        rows=rows, columns=columns, frame=frame
    )
    self.to_html(styles)

@monkeypatch_method(pd.DataFrame)
def _format_sytle_args(self, rows=None, columns=None, frame=None):
    if rows is not None:
        # a signle function, apply to each row
        if callable(rows):
            rows = {row: [rows] for row in self.index}
        else:
            rows = {row: [x] if not com.is_list_like(x) else x
                    for row, x in rows.items()}
    if columns is not None:
        if callable(columns):
            columns = {col: [columns] for col in self.columns}
        else:
            columns = {col: [x] if not com.is_list_like(x) else x
                       for col, x in columns.items()}
    if frame is not None:
        frame = [frame] if not com.is_list_like(frame) else frame
    return rows, columns, frame

@monkeypatch_method(pd.DataFrame)
def _build_styles(self, rows=None, columns=None, frame=None):
    final = []  # (row, col, prop, value)

    rows, columns, frame = self._format_sytle_args(rows, columns, frame)

    if rows is not None:
        for row in rows:
            for func in rows[row]:
                props, values  = zip(*func(self.loc[row]))
                final.append(pd.DataFrame({'row': row, 'col': self.columns,
                                           'prop': props, 'value': values}))
    if columns is not None:
        for col in columns:
            for func in columns[col]:
                props, values  = zip(*func(self[col]))
                final.append(pd.DataFrame({'row': self.index, 'col': col,
                                           'prop': props, 'value': values}))

    if frame is not None:
        for func in frame:
            r = func(self)
            for col in r:
                try:
                    prop, values = zip(*r[col])
                except ValueError:
                    prop, values = '', ''
                    final.append(pd.DataFrame({'row': r.index, 'col': col,
                                           'prop': props, 'value': values}))

    r = pd.concat(final)[['row', 'col', 'prop', 'value']]
    r = (r['prop'] + ':' + r['value']).groupby([r['row'], r['col']]).agg(
         lambda x: '; '.join(x))

    return r.unstack()

def color_bg_range(s, cmap='PuBu'):
    """Color background in a range."""
    colors = [rgb2hex(x) for x in plt.cm.get_cmap(cmap)(s)]
    return pd.Series([('backgroud-color', color) for color in colors])

def color_font_even(s):
    colors = ['black' if x % 2 else 'red' for x in s]
    return pd.Series([('font-color', color) for color in colors])

def color_gradient(s, cmap='RdBu'):
    colors = [rgb2hex(x) for x in plt.cm.get_cmap(cmap)(range(len(s)))]
    return pd.Series([('background-color', color) for color in colors])

def striped(s):
    colors = ["B5DEFF" if i % 2 else "" for i in range(len(s))]
    return pd.Series([('background-color', color) for color in colors])

def is_positive_bg(s):
    colors = {True: ('backgroud-color', 'teal'),
              False: ('background-color', 'blue')}
    if isinstance(s, pd.Series):
        return (s > 0).map(colors)
    else:
        return (s > 0).applymap(lambda x: colors[x])

def is_even_font(s):
    colors = {True: ('font-color', 'red'),
              False: ('font-color', 'yellow')}
    if isinstance(s, pd.Series):
        return (s % 2).map(colors)
    else:
        return(s % 0).applymap(lambda x: colors[x])

from jinja2 import Template
from pandas.util.testing import makeCustomDataframe as mkdf

# The baseline jinja2 template for HTML output.
t=Template("""
<style  type="text/css" >
#T_{{uuid}} tr {
border: none;
}
#T_{{uuid}} {
border: none;
}
#T_{{uuid}} th.blank {
border: none;
}


{% for s in style %}
#T_{{uuid}} {{s.selector}} {  
{% for p,val in s.props %}
    {{p}}: {{val}};
{% endfor %}
  }
{% endfor %}
</style>
<table id="T_{{uuid}}">
{% if caption %}
<caption>
{{caption}}
</caption>
{% endif %}

  <thead>
{% for r in head %}
    <tr>
  {% for c in r %}    
      <{{c.type}} class="{{c.class}}">{{c.value}}</th>
  {% endfor %}
    </tr>
{% endfor %}
  </thead>
  <tbody>
 {% for r in body %}
    <tr>
  {% for c in r %}    
      <{{c.type}} class="{{c.class}}">{{c.value}}</th>
  {% endfor %}
    </tr>
{% endfor %}
  </tbody>

</table>

""")

ROW_HEADING_CLASS="row_heading"
COL_HEADING_CLASS="col_heading"
DATA_CLASS="data"
BLANK_CLASS="blank"
BLANK_VALUE=""

def translate(df,cell_context=None):
    import uuid
    cell_context = cell_context or dict()

    n_rlvls =df.index.nlevels
    n_clvls =df.columns.nlevels
    rlabels=df.index.tolist()
    clabels=df.columns.tolist()
    if n_rlvls == 1:
        rlabels = [[x] for x in rlabels]
    if n_clvls == 1:
        clabels = [[x] for x in clabels]
    clabels=list(zip(*clabels))
    head=[]
    for r in range(n_clvls):    
        row_es = [{"type":"th","value":BLANK_VALUE ,"class": " ".join([BLANK_CLASS])}]*n_rlvls
        for c in range(len(clabels[0])):
            cs = [COL_HEADING_CLASS,"level%s" % r,"col%s" %c]
            cs.extend(cell_context.get("col_headings",{}).get(r,{}).get(c,[]))
            row_es.append({"type":"th","value": clabels[r][c],"class": " ".join(cs)})
        head.append(row_es)
    body=[]
    for r in range(len(df)):    
        cs = [ROW_HEADING_CLASS,"level%s" % c,"row%s" % r]
        cs.extend(cell_context.get("row_headings",{}).get(r,{}).get(c,[]))
        row_es = [{"type":"th","value": rlabels[r][c],"class": " ".join(cs)} 
                  for c in range(len(rlabels[r]))]
        for c in range(len(df.columns)):
            cs = [DATA_CLASS,"row%s" % r,"col%s" %c]
            cs.extend(cell_context.get("data",{}).get(r,{}).get(c,[]))
            row_es.append({"type":"td","value": df.iloc[r][c],"class": " ".join(cs)})
        body.append(row_es)

    # uuid required to isolate table styling from others 
    # in same notebook in ipnb
    u = str(uuid.uuid1()).replace("-","_")
    return dict(head=head, body=body,uuid=u)