# copyright 2003-2010 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/>.

"""the facets box and some basic facets"""

__docformat__ = "restructuredtext en"

_ = unicode

from logilab.mtconverter import xml_escape

from cubicweb.appobject import objectify_selector

from cubicweb.selectors import (non_final_entity, multi_lines_rset,

                                match_context_prop, yes, relation_possible)

from cubicweb.utils import json_dumps

from cubicweb.web import component

from cubicweb.web.facet import (AbstractFacet, FacetStringWidget, RelationFacet,

                                prepare_facets_rqlst, filter_hiddens, _cleanup_rqlst,

                                _prepare_vocabulary_rqlst)

@objectify_selector

def contextview_selector(cls, req, rset=None, row=None, col=None, view=None,

                         **kwargs):

    if view and getattr(view, 'filter_box_context_info', lambda: None)():

        return 1

    return 0

class FilterBox(component.CtxComponent):

    """filter results of a query"""

    __regid__ = 'facet.filters'

    __select__ = ((non_final_entity() & multi_lines_rset())

                  | contextview_selector())

    context = 'left' # XXX doesn't support 'incontext', only 'left' or 'right'

    title = _('facet.filters')

    visible = True # functionality provided by the search box by default

    order = 1

    roundcorners = True

    needs_css = 'cubicweb.facets.css'

    needs_js = ('cubicweb.ajax.js', 'cubicweb.facets.js')

    bk_linkbox_template = u'<div class="facetTitle">%s</div>'

    def facetargs(self):

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

        be used by the facet

        """

        return {}

    def _get_context(self):

        view = self.cw_extra_kwargs.get('view')

        context = getattr(view, 'filter_box_context_info', lambda: None)()

        if context:

            rset, vid, divid, paginate = context

        else:

            rset = self.cw_rset

            vid, divid = None, 'pageContent'

            paginate = view and view.paginable

        return rset, vid, divid, paginate

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

        req = self._cw

        req.add_js( self.needs_js )

        req.add_css( self.needs_css)

        if self.roundcorners:

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

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

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

        if rset.rowcount < 2:

            return

        rqlst = rset.syntax_tree()

        # union not yet supported

        if len(rqlst.children) != 1:

            return ()

        rqlst = rqlst.copy()

        req.vreg.rqlhelper.annotate(rqlst)

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

        widgets = []

        for facet in self.get_facets(rset, rqlst.children[0], mainvar):

            if facet.cw_propval('visible'):

                wdg = facet.get_widget()

                if wdg is not None:

                    widgets.append(wdg)

        if not widgets:

            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))

        w(u'<form method="post" id="%sForm" cubicweb:facetargs="%s" action="">'  % (

            divid, xml_escape(json_dumps([divid, vid, paginate, self.facetargs()]))))

        w(u'<fieldset>')

        hiddens = {'facets': ','.join(wdg.facet.__regid__ for wdg in widgets),

                   'baserql': baserql}

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

            if param in req.form:

                hiddens[param] = req.form[param]

        filter_hiddens(w, **hiddens)

        for wdg in widgets:

            wdg.render(w=w)

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

    def bookmark_link(self, rset):

        req = self._cw

        bk_path = u'rql=%s' % req.url_quote(rset.printable_rql())

        if req.form.get('vid'):

            bk_path += u'&vid=%s' % req.url_quote(req.form['vid'])

        bk_path = u'view?' + bk_path

        bk_title = req._('my custom search')

        linkto = u'bookmarked_by:%s:subject' % req.user.eid

        bkcls = req.vreg['etypes'].etype_class('Bookmark')

        bk_add_url = bkcls.cw_create_url(req, path=bk_path, title=bk_title,

                                         __linkto=linkto)

        bk_base_url = bkcls.cw_create_url(req, title=bk_title, __linkto=linkto)

        bk_link = u'<a cubicweb:target="%s" id="facetBkLink" href="%s">%s</a>' % (

                xml_escape(bk_base_url), xml_escape(bk_add_url),

                req._('bookmark this search'))

        return self.bk_linkbox_template % bk_link

    def get_facets(self, rset, rqlst, mainvar):

        return self._cw.vreg['facets'].poss_visible_objects(

            self._cw, rset=rset, rqlst=rqlst,

            context='facetbox', filtered_variable=mainvar)

# facets ######################################################################

class CWSourceFacet(RelationFacet):

    __regid__ = 'cw_source-facet'

    rtype = 'cw_source'

    target_attr = 'name'

class CreatedByFacet(RelationFacet):

    __regid__ = 'created_by-facet'

    rtype = 'created_by'

    target_attr = 'login'

class InGroupFacet(RelationFacet):

    __regid__ = 'in_group-facet'

    rtype = 'in_group'

    target_attr = 'name'

class InStateFacet(RelationFacet):

    __regid__ = 'in_state-facet'

    rtype = 'in_state'

    target_attr = 'name'

# inherit from RelationFacet to benefit from its possible_values implementation

class ETypeFacet(RelationFacet):

    __regid__ = 'etype-facet'

    __select__ = yes()

    order = 1

    rtype = 'is'

    target_attr = 'name'

    @property

    def title(self):

        return self._cw._('entity type')

    def vocabulary(self):

        """return vocabulary for this facet, eg a list of 2-uple (label, value)

        """

        etypes = self.cw_rset.column_types(0)

        return sorted((self._cw._(etype), etype) for etype in etypes)

    def add_rql_restrictions(self):

        """add restriction for this facet into the rql syntax tree"""

        value = self._cw.form.get(self.__regid__)

        if not value:

            return

        self.rqlst.add_type_restriction(self.filtered_variable, value)

    def possible_values(self):

        """return a list of possible values (as string since it's used to

        compare to a form value in javascript) for this facet

        """

        rqlst = self.rqlst

        rqlst.save_state()

        try:

            _cleanup_rqlst(rqlst, self.filtered_variable)

            etype_var = _prepare_vocabulary_rqlst(rqlst, self.filtered_variable, self.rtype, self.role)

            attrvar = rqlst.make_variable()

            rqlst.add_selected(attrvar)

            rqlst.add_relation(etype_var, 'name', attrvar)

            return [etype for _, etype in self.rqlexec(rqlst.as_string())]

        finally:

            rqlst.recover()

class HasTextFacet(AbstractFacet):

    __select__ = relation_possible('has_text', 'subject') & match_context_prop()

    __regid__ = 'has_text-facet'

    rtype = 'has_text'

    role = 'subject'

    order = 0

    @property

    def title(self):

        return self._cw._('has_text')

    def get_widget(self):

        """return the widget instance to use to display this facet

        default implentation expects a .vocabulary method on the facet and

        return a combobox displaying this vocabulary

        """

        return FacetStringWidget(self)

    def add_rql_restrictions(self):

        """add restriction for this facet into the rql syntax tree"""

        value = self._cw.form.get(self.__regid__)

        if not value:

            return

        self.rqlst.add_constant_restriction(self.filtered_variable, 'has_text', value, 'String')