from cubicweb.web import component, facet as facetbase

def facets(req, rset, context):

    """return the base rql and a list of widgets for facets applying to the

    given rset/context (cached version)

    """

    try:

        cache = req.__rset_facets

    except AttributeError:

        cache = req.__rset_facets = {}

    try:

        return cache[(rset, context)]

    except KeyError:

        facets = cache[(rset, context)] = _facets(req, rset, context)

        return facets

def _facets(req, rset, context):

    """return the base rql and a list of widgets for facets applying to the

    given rset/context

    """

    # XXX done by selectors, though maybe necessary when rset has been hijacked

    # (e.g. contextview_selector matched)

    rqlst = rset.syntax_tree()

    # union not yet supported

    if len(rqlst.children) != 1:

        return None, ()

    rqlst = rqlst.copy()

    vreg = req.vreg

    vreg.rqlhelper.annotate(rqlst)

    mainvar, baserql = facetbase.prepare_facets_rqlst(rqlst, rset.args)

    wdgs = [facet.get_widget() for facet in vreg['facets'].poss_visible_objects(

        req, rset=rset, rqlst=rqlst.children[0], context=context,

        filtered_variable=mainvar)]

    return baserql, [wdg for wdg in wdgs if wdg is not None]

@objectify_selector

def has_facets(cls, req, rset=None, **kwargs):

    if rset is None:

        return 0

    return len(facets(req, rset, cls.__regid__)[1])

def filter_hiddens(w, baserql, wdgs, **kwargs):

    kwargs['facets'] = ','.join(wdg.facet.__regid__ for wdg in wdgs)

    kwargs['baserql'] = baserql

    for key, val in kwargs.items():

        w(u'<input type="hidden" name="%s" value="%s" />' % (

            key, xml_escape(val)))

class FacetFilterMixIn(object):

    needs_js = ['cubicweb.ajax.js', 'cubicweb.facets.js']

    needs_css = ['cubicweb.facets.css']

    roundcorners = True

    def generate_form(self, w, rset, divid, vid, vidargs,

                      paginate=False, cssclass='', **hiddens):

        """display a form to filter some view's content"""

        baserql, wdgs = facets(self._cw, rset, self.__regid__)

        if not wdgs: # may happen in contextview_selector matched

            return

        self._cw.add_js(self.needs_js)

        self._cw.add_css(self.needs_css)

        self._cw.html_headers.define_var('facetLoadingMsg',

                                         self._cw._('facet-loading-msg'))

        if self.roundcorners:

            self._cw.html_headers.add_onload(

                'jQuery(".facet").corner("tl br 10px");')

        # drop False / None values from vidargs

        vidargs = dict((k, v) for k, v in vidargs.iteritems() if v)

        facetargs = xml_escape(json_dumps([divid, vid, paginate, vidargs]))

        w(u'<form id="%sForm" class="%s" method="post" action="" '

          'cubicweb:facetargs="%s" >' % (divid, cssclass, facetargs))

        w(u'<fieldset>')

        filter_hiddens(w, baserql, wdgs, **hiddens)

        self.layout_widgets(w, self.sorted_widgets(wdgs))

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

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

    def sorted_widgets(self, wdgs):

        """sort widgets: by default sort by widget height, then according to

        widget.order (the original widgets order)

        """

        return sorted(wdgs, key=lambda x: x.height())

    def layout_widgets(self, w, wdgs):

        """layout widgets: by default simply render each of them

        (i.e. succession of <div>)

        """

        for wdg in wdgs:

            wdg.render(w=w)

class FilterBox(FacetFilterMixIn, component.CtxComponent):

    __regid__ = 'facet.filterbox'

    __select__ = ((non_final_entity() & has_facets())

                  | contextview_selector()) # can't use has_facets because of

                                            # contextview mecanism

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

        req = self._cw

        rset, vid, divid, paginate = self._get_context()

        if len(rset) < 2:

            return

        if vid is None:

            vid = req.form.get('vid')

        if self.bk_linkbox_template and req.vreg.schema['Bookmark'].has_perm(req, 'add'):

            w(self.bookmark_link(rset))

        hiddens = {}

        for param in ('subvid', 'vtitle'):

            if param in req.form:

                hiddens[param] = req.form[param]

        self.generate_form(w, rset, divid, vid, self.vidargs(),

                           paginate=paginate, **hiddens)

    def vidargs(self):

        """this method returns the list of extra arguments that should be used

        by the filter or the view using it

        """

        return {}

from cubicweb.view import AnyRsetView

class FilterTable(FacetFilterMixIn, AnyRsetView):

    __regid__ = 'facet.filtertable'

    __select__ = non_final_entity() & has_facets()

    wdg_stack_size = 8

    def call(self, vid, divid, vidargs, cssclass=''):

        self.generate_form(self.w, self.cw_rset, divid, vid, vidargs,

                           cssclass=cssclass, fromformfilter='1',

                           # divid=divid XXX

                           )

    def layout_widgets(self, w, wdgs):

        """layout widgets: put them in a table where each column should have

        sum(wdg.height()) < wdg_stack_size.

        """

        w(u'<table class="filter">\n')

        widget_queue = []

        queue_height = 0

        w(u'<tr>\n')

        for wdg in wdgs:

            height = wdg.height()

            if queue_height + height <= self.wdg_stack_size:

                widget_queue.append(wdg)

                queue_height += height

                continue

            w(u'<td>')

            for queued in widget_queue:

                queued.render(w=w)

            w(u'</td>')

            widget_queue = [wdg]

            queue_height = height

        if widget_queue:

            w(u'<td>')

            for queued in widget_queue:

                queued.render(w=w)

            w(u'</td>')

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

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

class CWSourceFacet(facetbase.RelationFacet):

class CreatedByFacet(facetbase.RelationFacet):

class InGroupFacet(facetbase.RelationFacet):

class InStateFacet(facetbase.RelationAttributeFacet):

class ETypeFacet(facetbase.RelationFacet):

            facetbase.cleanup_rqlst(rqlst, self.filtered_variable)

            etype_var = facetbase.prepare_vocabulary_rqlst(

class HasTextFacet(facetbase.AbstractFacet):

        return facetbase.FacetStringWidget