# 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/>.

"""contains utility functions and some visual component to restrict results of

a search

"""

__docformat__ = "restructuredtext en"

from copy import deepcopy

from datetime import date, datetime, timedelta

from logilab.mtconverter import xml_escape

from logilab.common.graph import has_path

from logilab.common.decorators import cached

from logilab.common.date import datetime2ticks

from logilab.common.compat import all

from rql import parse, nodes

from cubicweb import Unauthorized, typed_eid

from cubicweb.schema import display_name

from cubicweb.utils import make_uid

from cubicweb.selectors import match_context_prop, partial_relation_possible

from cubicweb.appobject import AppObject

from cubicweb.web.htmlwidgets import HTMLWidget

## rqlst manipulation functions used by facets ################################

def prepare_facets_rqlst(rqlst, args=None):

    """prepare a syntax tree to generate facet filters

    * remove ORDERBY clause

    * cleanup selection (remove everything)

    * undefine unnecessary variables

    * set DISTINCT

    * unset LIMIT/OFFSET

    """

    if len(rqlst.children) > 1:

        raise NotImplementedError('FIXME: union not yet supported')

    select = rqlst.children[0]

    mainvar = filtered_variable(select)

    select.set_limit(None)

    select.set_offset(None)

    baserql = select.as_string(kwargs=args)

    # cleanup sort terms

    select.remove_sort_terms()

    # selection: only vocabulary entity

    for term in select.selection[:]:

        select.remove_selected(term)

    # remove unbound variables which only have some type restriction

    for dvar in select.defined_vars.values():

        if not (dvar is mainvar or dvar.stinfo['relations']):

            select.undefine_variable(dvar)

    # global tree config: DISTINCT, LIMIT, OFFSET

    select.set_distinct(True)

    return mainvar, baserql

def filtered_variable(rqlst):

    vref = rqlst.selection[0].iget_nodes(nodes.VariableRef).next()

    return vref.variable

def get_facet(req, facetid, rqlst, mainvar):

    return req.vreg['facets'].object_by_id(facetid, req, rqlst=rqlst,

                                           filtered_variable=mainvar)

def filter_hiddens(w, **kwargs):

    for key, val in kwargs.items():

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

            key, xml_escape(val)))

def _may_be_removed(rel, schema, mainvar):

    """if the given relation may be removed from the tree, return the variable

    on the other side of `mainvar`, else return None

    Conditions:

    * the relation is an attribute selection of the main variable

    * the relation is optional relation linked to the main variable

    * the relation is a mandatory relation linked to the main variable

      without any restriction on the other variable

    """

    lhs, rhs = rel.get_variable_parts()

    rschema = schema.rschema(rel.r_type)

    if lhs.variable is mainvar:

        try:

            ovar = rhs.variable

        except AttributeError:

            # constant restriction

            # XXX: X title LOWER(T) if it makes sense?

            return None

        if rschema.final:

            if len(ovar.stinfo['relations']) == 1:

                # attribute selection

                return ovar

            return None

        opt = 'right'

        cardidx = 0

    elif getattr(rhs, 'variable', None) is mainvar:

        ovar = lhs.variable

        opt = 'left'

        cardidx = 1

    else:

        # not directly linked to the main variable

        return None

    if rel.optional in (opt, 'both'):

        # optional relation

        return ovar

    if all(rdef.cardinality[cardidx] in '1+'

           for rdef in rschema.rdefs.values()):

        # mandatory relation without any restriction on the other variable

        for orel in ovar.stinfo['relations']:

            if rel is orel:

                continue

            if _may_be_removed(orel, schema, ovar) is None:

                return None

        return ovar

    return None

def _add_rtype_relation(rqlst, mainvar, rtype, role):

    """add a relation relying `mainvar` to entities linked by the `rtype`

    relation (where `mainvar` has `role`)

    return the inserted variable for linked entities.

    """

    newvar = rqlst.make_variable()

    if role == 'object':

        rqlst.add_relation(newvar, rtype, mainvar)

    else:

        rqlst.add_relation(mainvar, rtype, newvar)

    return newvar

    """prepare a syntax tree to generate a filter vocabulary rql using the given

    relation:

    * create a variable to filter on this relation

    * add the relation

    * add the new variable to GROUPBY clause if necessary

    * add the new variable to the selection

    """

    newvar = _add_rtype_relation(rqlst, mainvar, rtype, role)

    # add is restriction if necessary

    if mainvar.stinfo['typerel'] is None:

        etypes = frozenset(sol[mainvar.name] for sol in rqlst.solutions)

        rqlst.add_type_restriction(mainvar, etypes)

    return newvar

def _remove_relation(rqlst, rel, var):

    """remove a constraint relation from the syntax tree"""

    # remove the relation

    rqlst.remove_node(rel)

    # remove relations where the filtered variable appears on the

    # lhs and rhs is a constant restriction

    extra = []

    for vrel in var.stinfo['relations']:

        if vrel is rel:

            continue

        if vrel.children[0].variable is var:

            if not vrel.children[1].get_nodes(nodes.Constant):

                extra.append(vrel)

            rqlst.remove_node(vrel)

    return extra

def _set_orderby(rqlst, newvar, sortasc, sortfuncname):

    if sortfuncname is None:

        rqlst.add_sort_var(newvar, sortasc)

    else:

        vref = nodes.variable_ref(newvar)

        vref.register_reference()

        sortfunc = nodes.Function(sortfuncname)

        sortfunc.append(vref)

        term = nodes.SortTerm(sortfunc, sortasc)

        rqlst.add_sort_term(term)

def insert_attr_select_relation(rqlst, mainvar, rtype, role, attrname,

    """modify a syntax tree to :

    * link a new variable to `mainvar` through `rtype` (where mainvar has `role`)

    * retrieve only the newly inserted variable and its `attrname`

    Sorting:

    * on `attrname` ascendant (`sortasc`=True) or descendant (`sortasc`=False)

    * on `sortfuncname`(`attrname`) if `sortfuncname` is specified

    * no sort if `sortasc` is None

    """

    _cleanup_rqlst(rqlst, mainvar)

    # not found, create one

    attrvar = rqlst.make_variable()

    rqlst.add_relation(var, attrname, attrvar)

    # if query is grouped, we have to add the attribute variable

    if rqlst.groupby:

        if not attrvar in rqlst.groupby:

            rqlst.add_group_var(attrvar)

    if sortasc is not None:

        _set_orderby(rqlst, attrvar, sortasc, sortfuncname)

    # add attribute variable to selection

    rqlst.add_selected(attrvar)

    return var

def _cleanup_rqlst(rqlst, mainvar):

    """cleanup tree from unnecessary restriction:

    * attribute selection

    * optional relations linked to the main variable

    * mandatory relations linked to the main variable

    """

    if rqlst.where is None:

        return

    schema = rqlst.root.schema

    toremove = set()

    vargraph = deepcopy(rqlst.vargraph) # graph representing links between variable

    for rel in rqlst.where.get_nodes(nodes.Relation):

        ovar = _may_be_removed(rel, schema, mainvar)

        if ovar is not None:

            toremove.add(ovar)

    removed = set()

    while toremove:

        trvar = toremove.pop()

        trvarname = trvar.name

        # remove paths using this variable from the graph

        linkedvars = vargraph.pop(trvarname)

        for ovarname in linkedvars:

            vargraph[ovarname].remove(trvarname)

        # remove relation using this variable

        for rel in trvar.stinfo['relations']:

            if rel in removed:

                # already removed

                continue

            rqlst.remove_node(rel)

            removed.add(rel)

        rel = trvar.stinfo['typerel']

        if rel is not None and not rel in removed:

            rqlst.remove_node(rel)

            removed.add(rel)

        # cleanup groupby clause

        if rqlst.groupby:

            for vref in rqlst.groupby[:]:

                if vref.name == trvarname:

                    rqlst.remove_group_var(vref)

        # we can also remove all variables which are linked to this variable

        # and have no path to the main variable

        for ovarname in linkedvars:

            if ovarname == mainvar.name:

                continue

            if not has_path(vargraph, ovarname, mainvar.name):

                toremove.add(rqlst.defined_vars[ovarname])

## base facet classes #########################################################

class AbstractFacet(AppObject):

    __abstract__ = True

    __registry__ = 'facets'

    cw_property_defs = {

        _('visible'): dict(type='Boolean', default=True,

                           help=_('display the facet or not')),

        _('order'):   dict(type='Int', default=99,

                           help=_('display order of the facet')),

        _('context'): dict(type='String', default='',

                           # None <-> both

                           vocabulary=(_('tablefilter'), _('facetbox'), ''),

                           help=_('context where this facet should be displayed, '

                                  'leave empty for both')),

        }

    visible = True

    context = ''

    needs_update = False

    start_unfolded = True

    cw_rset = None # ensure facets have a cw_rset attribute

    def __init__(self, req, rqlst=None, filtered_variable=None,

                 **kwargs):

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

        assert rqlst is not None

        assert filtered_variable

        # take care: facet may be retreived using `object_by_id` from an ajax call

        # or from `select` using the result set to filter

        self.rqlst = rqlst

        self.filtered_variable = filtered_variable

    @property

    def operator(self):

        # OR between selected values by default

        return self._cw.form.get(self.__regid__ + '_andor', 'OR')

    def get_widget(self):

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

        """

        raise NotImplementedError

    def add_rql_restrictions(self):

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

        raise NotImplementedError

class VocabularyFacet(AbstractFacet):

    needs_update = True

    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

        """

        vocab = self.vocabulary()

        if len(vocab) <= 1:

            return None

        wdg = FacetVocabularyWidget(self)

        selected = frozenset(typed_eid(eid) for eid in self._cw.list_form_param(self.__regid__))

        for label, value in vocab:

            if value is None:

                wdg.append(FacetSeparator(label))

            else:

                wdg.append(FacetItem(self._cw, label, value, value in selected))

        return wdg

    def vocabulary(self):

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

        """

        raise NotImplementedError

    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

        """

        raise NotImplementedError

    def support_and(self):

        return False

    def rqlexec(self, rql, args=None):

        try:

            return self._cw.execute(rql, args)

        except Unauthorized:

            return []

class RelationFacet(VocabularyFacet):

    __select__ = partial_relation_possible() & match_context_prop()

    # class attributes to configure the relation facet

    rtype = None

    role = 'subject'

    target_attr = 'eid'

    target_type = None

    # set this to a stored procedure name if you want to sort on the result of

    # this function's result instead of direct value

    sortfunc = None

    # ascendant/descendant sorting

    sortasc = True

    # if you want to call a view on the entity instead of using `target_attr`

    label_vid = None

    @property

    def title(self):