"""
open/dulcinea/lib/ui/table.qpy
"""
from csv import DictWriter
from dulcinea.util import StringIO
from math import ceil
from qp.fill.css import format_style_rule, TextStyle
from qp.fill.form import Form
from qp.fill.widget import OptionSelectWidget
from qp.fill.html import htmltag, href
from qp.lib.util import randbytes, integer
from qp.pub.common import get_request, redirect, get_session
from qpy import xml
import sys


class Table (object):

    def __init__(self, maximum_rows_for_client_side_sorting=10000):
        self.headings = []
        self.rows = []
        self.caption = ''
        self.footer = ''
        self.tbody_id = 'T' + randbytes(4).decode('latin1')
        self.sortable_headings = set()
        self.maximum_rows_for_client_side_sorting = \
            maximum_rows_for_client_side_sorting

    def column(self, sortable=True, **name_content):
        assert len(name_content) == 1
        assert self.rows == []
        self.headings += list(name_content.items())
        if sortable:
            self.sortable_headings.add(self.headings[-1][0])

    def get_title(self, column):
        for c, title in self.headings:
            if column == c:
                return title

    def set_title(self, **name_content):
        assert len(name_content) == 1
        name, title = name_content.items()[0]
        for j, item in enumerate(self.headings):
            if item[0] == name:
                self.headings[j] = (name, title)
                return

    def row(self, **args):
        self.rows.append(args)

    def get_rows(self):
        return self.rows

    def set_caption(self, arg):
        self.caption = arg

    def set_footer(self, arg):
        """
        The argument should be a rendered tbody element.
        """
        self.footer = arg

    def render:xml(self, **attrs):
        if len(self.rows) <= self.maximum_rows_for_client_side_sorting:
            self.render_for_client_side_sorting(**attrs)
        else:
            self.render_for_server_side_sorting(**attrs)

    def render_csv(self):
        s = StringIO()
        fieldnames = [key for key, value in self.headings]
        dict_writer = DictWriter(s, fieldnames=fieldnames)
        dict_writer.writerow(dict(self.headings))
        for row in self.rows:
            dict_writer.writerow(
                dict([(k, v) for k, v in row.items() if k in fieldnames]))
        return s.getvalue()

    def render_rows:xml(self):
        keys = [key for (key, value) in self.headings]
        for j, row in enumerate(self.rows):
            classes = row.get('classes') or []
            if j % 2 == 0:
                classes.append('even')
            else:
                classes.append('odd')
            attrs = dict((k, v) for k, v in row.items() if k not in keys and k != 'classes')
            htmltag('tr', classes=classes, **attrs)
            for key in keys:
                '<td class="%s">' % key
                row.get(key)
                '</td>'
            '</tr>'

    def render_tbody:xml(self):
        '<tbody id="%s">' % self.tbody_id
        self.render_rows()
        '</tbody>'

    def render_footer:xml(self):
        self.footer

    def render_for_server_side_sorting:xml(self, **attrs):
        htmltag('table', **attrs)
        if self.caption:
            '<caption>%s</caption>' % self.caption
        '<thead><tr>'
        query_prefix = get_request().get_query()
        query = ''
        for heading in self.sortable_headings:
            if query_prefix.endswith(heading):
                query_prefix = query_prefix[:-len(heading)]
                query = heading
            heading_plus_minus = heading + '-'
            if query_prefix.endswith(heading_plus_minus):
                query_prefix = query_prefix[:-len(heading_plus_minus)]
                query = heading_plus_minus
        reversed_rows = False
        if query.endswith('-'):
            query = query[:-1]
            reversed_rows = True
        if query in self.sortable_headings:
            self.rows = sorted(self.rows, key=lambda row: row.get(query))
            if reversed_rows:
                self.rows = reversed(self.rows)
        for name, content in self.headings:
            '<th class="%s">' % name
            if name in self.sortable_headings:
                if query_prefix:
                    new_query = '?' + query_prefix + '&' + name
                else:
                    new_query = '?' + name
                if query.endswith(name) and not reversed_rows:
                    new_query += '-'
                href(new_query, content, title="sort table using this column")
                if name == query:
                    if reversed_rows:
                        '<span>&uarr;</span>'
                    else:
                        '<span>&darr;</span>'
            else:
                content
            '</th>'
        '</tr></thead>'
        self.render_tbody()
        self.render_footer()
        '</table>'

    def render_for_client_side_sorting:xml(self, **attrs):
        tbody_id = repr(self.tbody_id).lstrip("u")
        htmltag('table', **attrs)
        if self.caption:
            '<caption>%s</caption>' % self.caption
        '<thead id="%sH"><tr>' % self.tbody_id
        for index, heading in enumerate(self.headings):
            if heading[0] in self.sortable_headings:
                '<th class="%s" onclick="tbody_sort(%s, %d)">' % (
                    heading[0], tbody_id, index)
                '<a title="sort table using this column">'
                heading[1]
                '<span class="uparrow">&uarr;</span>'
                '<span class="downarrow">&darr;</span>'
                '</a>'
                '</th>'
            else:
                '<th class="%s">' % heading[0]
                heading[1]
                '</th>'
        '</tr></thead>'
        self.render_tbody()
        self.render_footer()
        '</table>'
        if self.sortable_headings:
            '<script type="text/javascript"><!--\n%s\n//--></script>' % xml(
                self.javascript)


    javascript = '''
        function tbody_sort(id, col) {
            var tbody = document.getElementById(id)

            function get_string_data(node) {
                if (node.data) {
                    return node.data.toLowerCase()
                } else {
                    var parts = []
                    for (var child = node.firstChild; child; child = child.nextSibling)
                        parts = parts.concat(get_string_data(child))
                    return parts.join(" ").toLowerCase()
                }
            }

            function get_key(node) {
                if (node.childNodes.length == 0) {
                    return ""
                }
                data = get_string_data(node)
                if (!data) {
                    return ""
                }
                if (data.length == 0) {
                    return ""
                }
                if (data.charAt(0) == '$') {
                    var num = parseFloat(data.substring(1))
                    if (!isNaN(num)) {
                        return num
                    }
                }
                if (!data.match(/^\s*\d+[-\/]\d+[-\/]\d+/)) {
                    /* data does not appear to start with a date */
                    var num = parseFloat(data)
                    if (!isNaN(num)) {
                        return num
                    }
                }
                return data
            }
            var n = tbody.rows.length
            var sdata = new Array()
            for (var j=0;j<n;j++) {
                sdata.push([get_key(tbody.rows.item(j).cells.item(col)),
                            tbody.rows.item(j)])
            }
            var tmp, changed = 0
            var a, b;
            for (var j=0;j<n;j++) {
                for (var k=1;k<n-j;k++) {
                    a = sdata[k-1][0]
                    b = sdata[k][0]
                    if (typeof a != typeof b) {
                        a = a.toString()
                        b = b.toString()
                    }
                    if (a > b) {
                        changed = 1
                        tmp = sdata[k]
                        sdata[k] = sdata[k-1]
                        sdata[k-1] = tmp
                    }
                }
            }
            var headcells = document.getElementById(id+"H").firstChild.childNodes
            for (var j=0;j < headcells.length;j++) {
                child = headcells.item(j)
                child.className = ""
            }
            if (changed == 1) {
                headcells.item(col).className = "increasing"
            } else {
                headcells.item(col).className = "decreasing"
                sdata.reverse()
            }
            for (var j=0;j<n;j++) {
                tbody.appendChild(sdata[j][1])
            }
            for (var j=0;j<n;j++) {
                var row = tbody.rows.item(j)
                if (j % 2 == 0) {
                    row.className = row.className.replace("odd", "even")
                } else {
                    row.className = row.className.replace("even", "odd")
                }
            }
            tbody.normalize()
        }
        '''

def format_table_css:str(
    css_class=None,
    base='',
    table_text_style=TextStyle(
        #font_style='font-size: smaller',
        other_style='border-spacing: 0px'),
    header_text_style=TextStyle(
        background='#3575D4',
        color='#fff',
        other_style='padding: 2px 1em 2px 1em',
        anchor_style='color: white; text-decoration: none',
        hover_style='text-decoration: underline',
        visited_style='color: white'),
    cell_text_style=TextStyle(
        background='inherit',
        color='black',
        other_style='padding: 2px 1em 2px 1em',
        anchor_style='text-decoration: none',
        link_style='color: #36589E',
        hover_style='color: #36589E; text-decoration: underline',
        visited_style='color: #36589E'),
    even_row_text_style=TextStyle(
        background='#fff'),
    odd_row_text_style=TextStyle(
        background='#ebf3fc')
    ):
    base +=' table'
    if css_class:
        base += ".%s" % css_class
    format_style_rule(base, ['span.uparrow', 'span.downarrow'], 'display: none')
    format_style_rule(base,
        ['thead th.increasing span.downarrow',
        'thead th.decreasing span.uparrow'],
        'display: inline')
    format_style_rule(base,
        ['thead th.increasing span.uparrow',
        'thead th.decreasing span.downarrow'],
        'display: none')
    if css_class:
        #format_style_rule(base, [], 'width: 100%')
        table_text_style.format_rules(base, [])
        header_text_style.format_rules(base, ['th'])
        cell_text_style.format_rules(base, ['td'])
        even_row_text_style.format_rules(base, ['', 'tr.even'])
        odd_row_text_style.format_rules(base, ['tr.odd'])


class Pager (Table):

    def __init__(self):
        Table.__init__(self)
        form = Form(method='get', use_tokens=False, name='Pager')
        form.add_hidden('sort')
        form.add_hidden('page')
        form.add_hidden('start')
        page_sizes = [10, 20, 50, 100, 1000]
        page_size = self.get_default_page_size()
        if page_size not in page_sizes:
            page_sizes.append(page_size)
            page_sizes.sort()
        options = [(x, "%s per page" % x, x) for x in page_sizes]
        form.add(OptionSelectWidget, 'page_size', options=options,
            value=self.get_default_page_size())
        form.add_string('query', css_class="query_string")
        form.add_submit('click', 'Search', css_class="query_button")
        self.form = form
        self.form.has_errors() # Force parse.
        self.form.clear_errors()
        self.save_default_page_size(form.get('page_size', 10))
        self.page = integer(form.get('page'), 1)
        self.start = max(integer(form.get('start'), 1), 1)
        if form.get('click'): # button pressed.
            if self.page != 1 or self.start != 1:
                redirect(self.construct_form_query(page=1, start=1))
        self.pages = 1
        self.window = 5
        self.prompt = ""

    def get_default_page_size(self):
        session = get_session()
        if session:
            return session.get_items_per_page()

    def save_default_page_size(self, value):
        session = get_session()
        if session:
            session.set_items_per_page(value)

    def get_widget(self, name):
        return self.form.get_widget(name)

    def set_submit_button_label(self, name):
        self.form.get_widget('click').label = name

    def set_search_input_size(self, size):
        widget = self.form.get_widget('query')
        widget.attrs['size'] = size

    def set_prompt(self, prompt):
        self.prompt = prompt
        widget = self.form.get_widget('query')
        if not self.form.is_submitted():
            widget.value = prompt
            widget.attrs['onclick'] = "this.value=''"

    def get_sort_column_key(self):
        full_key = self.form.get('sort')
        if not full_key:
            return None
        elif full_key.startswith('-'):
            return full_key[1:]
        else:
            return full_key

    def get_sort_reversal(self):
        full_key = self.form.get('sort')
        return full_key and full_key.startswith('-')

    def get_search_query(self):
        raw = self.form.get('query') or ''
        if raw == self.prompt:
            return ''
        else:
            return raw

    def get_page(self):
        return self.page

    def get_page_size(self):
        return integer(self.form.get('page_size'), 10)

    def construct_form_query(self, **kwargs):
        """
        Produce a query string that matches the form values, except
        for overrides provided here as keyword arguments.
        """
        fields = {}
        for widget in self.form:
            fields[widget.get_name()] = widget.value
        for k, v in kwargs.items():
            name = self.form.get_widget(k).get_name()
            fields[name] = v
        fields[self.form.get_widget('click').get_name()] = ''
        parts = []
        for item in sorted(fields.items()):
            if item[1] not in (None, '', False):
                parts.append('%s=%s' % item)
        return '?' + '&'.join(parts)

    def render_controls:xml(self):
        '<tr>'
        '<td colspan="%s">' % len(self.headings)
        '<div class="pager_search">'
        self.form.render()
        '</div>'
        if self.pages > 1:
            '<div class="pager_links">'
            # todo: get the range right and add other links.
            page_name = self.form.get_widget('page').get_name()
            start_name = self.form.get_widget('start').get_name()
            end = min(self.start + self.window, self.pages + 1)
            if self.start > 1:
                href(self.construct_form_query(page=1, start=1), '1...')
            if self.start > self.window + 1:
                href(self.construct_form_query(
                    start=self.start-self.window, page=self.start - 1), '<<')
            for p in range(self.start, end):
                if p == self.page:
                    href("", p, css_class="selected")
                else:
                    query = self.construct_form_query(page=p)
                    href(query, p)
            if end < (self.pages - self.window):
                href(self.construct_form_query(start=end, page=end), '>>')
            if end < self.pages:
                href(self.construct_form_query(
                    start=self.pages - self.window + 1,
                    page=self.pages), '...%s' % self.pages)
            '</div>'
        '</td>'
        '</tr>'

    def set_pages(self, pages):
        self.pages = pages

    def set_window(self, window):
        self.window = window

    def render_thead:xml(self):
        '<thead>'
        self.render_controls()
        '<tr>'
        sort_name = self.form.get_widget('sort').get_name()
        for name, content in self.headings:
            '<th class="%s">' % name
            if name not in self.sortable_headings:
                content
            else:
                if self.form.get('sort') == name:
                    query = self.construct_form_query(**{sort_name:"-"+name})
                    href(query, content, title="reverse table row order")
                    '<span>&darr;</span>'
                else:
                    query = self.construct_form_query(**{sort_name:name})
                    href(query, content, title="sort table using this column")
                    if self.form.get('sort') == "-" + name:
                        '<span>&uarr;</span>'
            '</th>'
        '</tr></thead>'

    def render:xml(self, **attrs):
        if len(self.rows) == 0 and self.page != 1:
            redirect(self.construct_form_query(page=1, start=1))
        htmltag('table', **attrs)
        if self.caption:
            '<caption>%s</caption>' % self.caption
        self.render_thead()
        self.render_tbody()
        self.render_footer()
        '</table>'

class Searcher (object):
    """
    To use with Pager, implement a subclass of this that includes the
    perform_search() that you need for your items.
    Make an instance of this with an instance of your pager class.
    Call get_selection() on this instance to get the items
    that you will use to fill in the rows of the Pager.
    """
    def __init__(self, pager):
        self.sort_column_key = pager.get_sort_column_key()
        self.sort_reversal = pager.get_sort_reversal()
        self.page_size = pager.get_page_size()
        self.page = pager.get_page()
        self.query = pager.get_search_query()
        self.perform_search()
        pager.set_pages(int(ceil(self.get_number_of_matches() / float(self.page_size))))

    def get_page_start(self):
        return self.page_size * (self.page - 1)

    def get_page_end(self):
        return self.page_size * self.page

    def perform_search():
        """
        This sets self.number_of_matches and self.selection .
        Subclass must implement.
        """
        raise NotImplemented

    def get_number_of_matches(self):
        """Call perform_search() before this.
        """
        return self.number_of_matches

    def get_selection(self):
        """Call perform_search() before this.
        """
        return self.selection