# copyright 2003-2011 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""This module contains table views, with the following features that may be

provided (depending on the used implementation):

* facets filtering

* pagination

* actions menu

* properly sortable content

* odd/row/hover line styles

The three main implementation are described below. Each implementation is

suitable for a particular case, but they each attempt to display tables that

looks similar.

.. autoclass:: cubicweb.web.views.tableview.RsetTableView

   :members:

.. autoclass:: cubicweb.web.views.tableview.EntityTableView

   :members:

.. autoclass:: cubicweb.web.views.pyview.PyValTableView

   :members:

All those classes are rendered using a *layout*:

.. autoclass:: cubicweb.web.views.pyview.TableLayout

   :members:

There is by default only on table layout, using the 'table_layout' identifier,

that is referenced by table views

:attr:`cubicweb.web.views.tableview.TableMixIn.layout_id`.  If you want to

customize the look and feel of your table, you can either replace the default

one by yours, having multiple variants with proper selectors, or change the

`layout_id` identifier of your table to use your table specific implementation.

Notice you can gives options to the layout using a `layout_args` dictionary on

your class.

If you can still find a view that suit your needs, you should take a look at the

class below that is the common abstract base class for the three views defined

above and implements you own class.

.. autoclass:: cubicweb.web.views.pyview.TableMixIn

   :members:

"""

__docformat__ = "restructuredtext en"

_ = unicode

from warnings import warn

from logilab.mtconverter import xml_escape

from logilab.common.decorators import cachedproperty

from logilab.common.deprecation import class_deprecated

from cubicweb import NoSelectableObject, tags

from cubicweb.selectors import yes, nonempty_rset, match_kwargs, objectify_selector

from cubicweb.utils import make_uid, js_dumps, JSString

from cubicweb.view import EntityView, AnyRsetView

from cubicweb.uilib import toggle_action, limitsize, htmlescape, sgml_attributes, domid

from cubicweb.web import jsonize, component

from cubicweb.web.htmlwidgets import (TableWidget, TableColumn, MenuWidget,

                                      PopupBoxMenu)

@objectify_selector

def unreloadable_table(cls, req, rset=None,

                       displaycols=None, headers=None, cellvids=None,

                       paginate=False, displayactions=False, displayfilter=False,

                       **kwargs):

    # one may wish to specify one of headers/displaycols/cellvids as long as he

    # doesn't want pagination nor actions nor facets

    if not kwargs and (displaycols or headers or cellvids) and not (

        displayfilter or displayactions or paginate):

        return 1

    return 0

class TableLayout(component.Component):

    """The default layout for table. When `render` is called, this will use

    the API described on :class:`TableMixIn` to feed the generated table.

    This layout behaviour may be customized using the following attributes /

    selection arguments:

    * `cssclass`, a string that should be used as HTML class attribute. Default

      to "listing".

    * `needs_css`, the CSS files that should be used together with this

      table. Default to ('cubicweb.tablesorter.css', 'cubicweb.tableview.css').

    * `needs_js`, the Javascript files that should be used together with this

      table. Default to ('jquery.tablesorter.js',)

    * `display_filter`, tells if the facets filter should be displayed when

      possible. Allowed values are:

      - `None`, don't display it

      - 'top', display it above the table

      - 'bottom', display it below the table

    * `display_actions`, tells if a menu for available actions should be

      displayed when possible (see two following options). Allowed values are:

      - `None`, don't display it

      - 'top', display it above the table

      - 'bottom', display it below the table

    * `hide_filter`, when true (the default), facets filter will be hidden by

      default, with an action in the actions menu allowing to show / hide it.

    * `add_view_actions`, when true, actions returned by view.table_actions()

      will be included in the actions menu.

    * `header_column_idx`, if not `None`, should be a colum index or a set of

      column index where <th> tags should be generated instead of <td>

    """

    __regid__ = 'table_layout'

    cssclass = "listing"

    needs_css = ('cubicweb.tableview.css',)

    needs_js = ()

    display_filter = None # None / 'top' / 'bottom'

    display_actions = 'top' # None / 'top' / 'bottom'

    hide_filter = True

    add_view_actions = False

    header_column_idx = None

    enable_sorting = True

    sortvalue_limit = 10

    tablesorter_settings = {

        'textExtraction': JSString('cw.sortValueExtraction'),

        'selectorHeaders': "thead tr:first th", # only plug on the first row

        }

    def _setup_tablesorter(self, divid):

        self._cw.add_css('cubicweb.tablesorter.css')

        self._cw.add_js('jquery.tablesorter.js')

        self._cw.add_onload('''$(document).ready(function() {

    $("#%s table").tablesorter(%s);

});''' % (divid, js_dumps(self.tablesorter_settings)))

    def __init__(self, req, view, **kwargs):

        super(TableLayout, self).__init__(req, **kwargs)

        for key, val in self.cw_extra_kwargs.items():

            if hasattr(self.__class__, key) and not key[0] == '_':

                setattr(self, key, val)

                self.cw_extra_kwargs.pop(key)

        self.view = view

        if self.header_column_idx is None:

            self.header_column_idx = frozenset()

        elif isinstance(self.header_column_idx, int):

            self.header_column_idx = frozenset( (self.header_column_idx,) )

    @cachedproperty

    def initial_load(self):

        """We detect a bit heuristically if we are built for the first time of

        from subsequent calls by the form filter or by the pagination hooks

        """

        form = self._cw.form

        return 'fromformfilter' not in form and '__start' not in form

    def render(self, w, **kwargs):

        assert self.display_filter in (None, 'top', 'bottom'), self.display_filter

        if self.needs_css:

            self._cw.add_css(self.needs_css)

        if self.needs_js:

            self._cw.add_js(self.needs_js)

        if self.enable_sorting:

            self._setup_tablesorter(self.view.domid)

        # Notice facets form must be rendered **outside** the main div as it

        # shouldn't be rendered on ajax call subsequent to facet restriction

        # (hence the 'fromformfilter' parameter added by the form

        generate_form = self.initial_load

        if self.display_filter and generate_form:

            facetsform = self.view.facets_form()

        else:

            facetsform = None

        if facetsform and self.display_filter == 'top':

            cssclass = u'hidden' if self.hide_filter else u''

            facetsform.render(w, vid=self.view.__regid__, cssclass=cssclass,

                              divid=self.view.domid)

        actions = []

        if self.add_view_actions:

            actions = self.view.table_actions()

        if self.display_filter and self.hide_filter and (facetsform or not generate_form):

            actions += self.show_hide_filter_actions(not generate_form)

        self.render_table(w, actions, self.view.paginable)

        if facetsform and self.display_filter == 'bottom':

            cssclass = u'hidden' if self.hide_filter else u''

            facetsform.render(w, vid=self.view.__regid__, cssclass=cssclass,

                              divid=self.view.domid)

    def render_table_headers(self, w, colrenderers):

        w(u'<thead><tr>')

        for colrenderer in colrenderers:

            w(u'<th>')

            colrenderer.render_header(w)

            w(u'</th>')

        w(u'</tr></thead>\n')

    def render_table_body(self, w, colrenderers):

        w(u'<tbody>')

        for rownum in xrange(self.view.table_size):

            self.render_row(w, rownum, colrenderers)

        w(u'</tbody>')

    def render_table(self, w, actions, paginate):

        view = self.view

        divid = view.domid

        if divid is not None:

            w(u'<div id="%s">' % divid)

        else:

            assert not (actions or paginate)

        if paginate:

            view.paginate(w=w, show_all_option=False)

        if actions and self.display_actions == 'top':

            self.render_actions(w, actions)

        colrenderers = view.build_column_renderers()

        attrs = self.table_attributes()

        w(u'<table %s>' % sgml_attributes(attrs))

        if self.view.has_headers:

            self.render_table_headers(w, colrenderers)

        self.render_table_body(w, colrenderers)

        w(u'</table>')

        if actions and self.display_actions == 'bottom':

            self.render_actions(w, actions)

        if divid is not None:

            w(u'</div>')

    def table_attributes(self):

        return {'class': self.cssclass}

    def render_row(self, w, rownum, renderers):

        attrs = self.row_attributes(rownum)

        w(u'<tr %s>' % sgml_attributes(attrs))

        for colnum, renderer in enumerate(renderers):

            self.render_cell(w, rownum, colnum, renderer)

        w(u'</tr>\n')

    def row_attributes(self, rownum):

        return {'class': 'odd' if (rownum%2==1) else 'even',

                'onmouseover': '$(this).addClass("highlighted");',

                'onmouseout': '$(this).removeClass("highlighted")'}

    def render_cell(self, w, rownum, colnum, renderer):

        attrs = self.cell_attributes(rownum, colnum, renderer)

        if colnum in self.header_column_idx:

            tag = u'th'

        else:

            tag = u'td'

        w(u'<%s %s>' % (tag, sgml_attributes(attrs)))

        renderer.render_cell(w, rownum)

        w(u'</%s>' % tag)

    def cell_attributes(self, rownum, _colnum, renderer):

        attrs = renderer.attributes.copy()

        if renderer.sortable:

            sortvalue = renderer.sortvalue(rownum)

            if isinstance(sortvalue, basestring):

                sortvalue = sortvalue[:self.sortvalue_limit]

            if sortvalue is not None:

                attrs[u'cubicweb:sortvalue'] = js_dumps(sortvalue)

        return attrs

    def render_actions(self, w, actions):

        box = MenuWidget('', 'tableActionsBox', _class='', islist=False)

        label = tags.img(src=self._cw.uiprops['PUCE_DOWN'],

                         alt=xml_escape(self._cw._('action(s) on this selection')))

        menu = PopupBoxMenu(label, isitem=False, link_class='actionsBox',

                            ident='%sActions' % self.view.domid)

        box.append(menu)

        for action in actions:

            menu.append(action)

        box.render(w=w)

        w(u'<div class="clear"></div>')

    def show_hide_filter_actions(self, currentlydisplayed=False):

        divid = self.view.domid

        showhide = u';'.join(toggle_action('%s%s' % (divid, what))[11:]

                             for what in ('Form', 'Show', 'Hide', 'Actions'))

        showhide = 'javascript:' + showhide

        showlabel = self._cw._('show filter form')

        hidelabel = self._cw._('hide filter form')

        if currentlydisplayed:

            c1, d1 = 'hidden', '%sShow' % divid

            c2, d2 = None, '%sHide' % divid

        else:

            c1, d1 = None, '%sShow' % divid

            c2, d2 = 'hidden', '%sHide' % divid

        return [component.Link(showhide, showlabel, klass=c1, id=d1),

                component.Link(showhide, hidelabel, klass=c2, id=d2)]

class AbstractColumnRenderer(object):

    """Abstract base class for column renderer. Interface of a column renderer follows:

    .. automethod:: bind

    .. automethod:: render_header

    .. automethod:: render_cell

    .. automethod:: sortvalue

    Attributes on this base class are:

    :attr: `header`, the column header. If None, default to `_(colid)`

    :attr: `addcount`, if True, add the table size in parenthezis beside the header

    :attr: `trheader`, should the header be translated

    :attr: `escapeheader`, should the header be xml_escape'd

    :attr: `sortable`, tell if the column is sortable

    :attr: `view`, the table view

    :attr: `_cw`, the request object

    :attr: `colid`, the column identifier

    :attr: `attributes`, dictionary of attributes to put on the HTML tag when

    the cell is rendered

    """

    attributes = {}

    empty_cell_content = u' '

    def __init__(self, header=None, addcount=False, trheader=True,

                 escapeheader=True, sortable=True):

        self.header = header

        self.trheader = trheader

        self.escapeheader = escapeheader

        self.addcount = addcount

        self.sortable = sortable

        self.view = None

        self._cw = None

        self.colid = None

    def __str__(self):

        return '<%s.%s (column %s)>' % (self.view.__class__.__name__,

                                        self.__class__.__name__,

                                        self.colid)

    def bind(self, view, colid):

        """Bind the column renderer to its view. This is where `_cw`, `view`,

        `colid` are set and the method to override if you want to add more

        view/request depending attributes on your column render.

        """

        self.view = view

        self._cw = view._cw

        self.colid = colid

    def default_header(self):

        """Return header for this column if one has not been specified."""

        return self._cw._(self.colid)

    def render_header(self, w):

        """Write label for the specified column by calling w()."""

        header = self.header

        if header is None:

            header = self.default_header()

        elif self.trheader and header:

           header = self._cw._(header)

        if self.addcount:

            header = '%s (%s)' % (header, self.view.table_size)

        if header:

            if self.escapeheader:

                header = xml_escape(header)

        else:

            header = self.empty_cell_content

        if self.sortable:

            header = tags.span(

                header, escapecontent=False,

                title=self._cw._('Click to sort on this column'))

        w(header)

    def render_cell(self, w, rownum):

        """Write value for the specified cell by calling w().

         :param `rownum`: the row number in the table