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

"""Predicate classes

"""

__docformat__ = "restructuredtext en"

import logging

from warnings import warn

from operator import eq

from logilab.common.deprecation import deprecated

from logilab.common.registry import Predicate, objectify_predicate, yes

from yams.schema import BASE_TYPES, role_name

from rql.nodes import Function

from cubicweb import (Unauthorized, NoSelectableObject, NotAnEntity,

                      CW_EVENT_MANAGER, role)

from cubicweb.uilib import eid_param

from cubicweb.schema import split_expression

yes = deprecated('[3.15] import yes() from use logilab.common.registry')(yes)

# abstract predicates / mixin helpers ###########################################

class PartialPredicateMixIn(object):

    """convenience mix-in for predicates that will look into the containing

    class to find missing information.

    cf. `cubicweb.web.action.LinkToEntityAction` for instance

    """

    def __call__(self, cls, *args, **kwargs):

        self.complete(cls)

        return super(PartialPredicateMixIn, self).__call__(cls, *args, **kwargs)

class EClassPredicate(Predicate):

    """abstract class for predicates working on *entity class(es)* specified

    explicitly or found of the result set.

    Here are entity lookup / scoring rules:

    * if `entity` is specified, return score for this entity's class

    * elif `rset`, `select` and `filtered_variable` are specified, return score

      for the possible classes for variable in the given rql :class:`Select`

      node

    * elif `rset` and `row` are specified, return score for the class of the

      entity found in the specified cell, using column specified by `col` or 0

    * elif `rset` is specified return score for each entity class found in the

      column specified specified by the `col` argument or in column 0 if not

      specified

    When there are several classes to be evaluated, return the sum of scores for

    each entity class unless:

      - `mode` == 'all' (the default) and some entity class is scored

        to 0, in which case 0 is returned

      - `mode` == 'any', in which case the first non-zero score is

        returned

      - `accept_none` is False and some cell in the column has a None value

        (this may occurs with outer join)

    """

    def __init__(self, once_is_enough=None, accept_none=True, mode='all'):

        if once_is_enough is not None:

            warn("[3.14] once_is_enough is deprecated, use mode='any'",

                 DeprecationWarning, stacklevel=2)

            if once_is_enough:

                mode = 'any'

        assert mode in ('any', 'all'), 'bad mode %s' % mode

        self.once_is_enough = mode == 'any'

        self.accept_none = accept_none

    def __call__(self, cls, req, rset=None, row=None, col=0, entity=None,

                 select=None, filtered_variable=None,

                 accept_none=None,

                 **kwargs):

        if entity is not None:

            return self.score_class(entity.__class__, req)

        if not rset:

            return 0

        if select is not None and filtered_variable is not None:

            etypes = set(sol[filtered_variable.name] for sol in select.solutions)

        elif row is None:

            if accept_none is None:

                accept_none = self.accept_none

            if not accept_none and \

                   any(row[col] is None for row in rset):

                return 0

            etypes = rset.column_types(col)

        else:

            etype = rset.description[row][col]

            # may have None in rset.description on outer join

            if etype is None or rset.rows[row][col] is None:

                return 0

            etypes = (etype,)

        score = 0

        for etype in etypes:

            escore = self.score(cls, req, etype)

            if not escore and not self.once_is_enough:

                return 0

            elif self.once_is_enough:

                return escore

            score += escore

        return score

    def score(self, cls, req, etype):

        if etype in BASE_TYPES:

            return 0

        return self.score_class(req.vreg['etypes'].etype_class(etype), req)

    def score_class(self, eclass, req):

        raise NotImplementedError()

class EntityPredicate(EClassPredicate):

    """abstract class for predicates working on *entity instance(s)* specified

    explicitly or found of the result set.

    Here are entity lookup / scoring rules:

    * if `entity` is specified, return score for this entity

    * elif `row` is specified, return score for the entity found in the

      specified cell, using column specified by `col` or 0

    * else return the sum of scores for each entity found in the column

      specified specified by the `col` argument or in column 0 if not specified,

      unless:

      - `mode` == 'all' (the default) and some entity class is scored

        to 0, in which case 0 is returned

      - `mode` == 'any', in which case the first non-zero score is

        returned

      - `accept_none` is False and some cell in the column has a None value

        (this may occurs with outer join)

    .. Note::

       using :class:`EntityPredicate` or :class:`EClassPredicate` as base predicate

       class impacts performance, since when no entity or row is specified the

       later works on every different *entity class* found in the result set,

       while the former works on each *entity* (eg each row of the result set),

       which may be much more costly.

    """

    def __call__(self, cls, req, rset=None, row=None, col=0, accept_none=None,

                 entity=None, **kwargs):

        if not rset and entity is None:

            return 0

        score = 0

        if entity is not None:

            score = self.score_entity(entity)

        elif row is None:

            col = col or 0

            if accept_none is None:

                accept_none = self.accept_none

            for row, rowvalue in enumerate(rset.rows):

                if rowvalue[col] is None: # outer join

                    if not accept_none:

                        return 0

                    continue

                escore = self.score(req, rset, row, col)

                if not escore and not self.once_is_enough:

                    return 0

                elif self.once_is_enough:

                    return escore

                score += escore

        else:

            col = col or 0

            etype = rset.description[row][col]

            if etype is not None: # outer join

                score = self.score(req, rset, row, col)

        return score

    def score(self, req, rset, row, col):

        try:

            return self.score_entity(rset.get_entity(row, col))

        except NotAnEntity:

            return 0

    def score_entity(self, entity):

        raise NotImplementedError()

class ExpectedValuePredicate(Predicate):

    """Take a list of expected values as initializer argument and store them

    into the :attr:`expected` set attribute. You may also give a set as single

    argument, which will then be referenced as set of expected values,

    allowing modifications to the given set to be considered.

    You should implement one of :meth:`_values_set(cls, req, **kwargs)` or

    :meth:`_get_value(cls, req, **kwargs)` method which should respectively

    return the set of values or the unique possible value for the given context.

    You may also specify a `mode` behaviour as argument, as explained below.

    Returned score is:

    - 0 if `mode` == 'all' (the default) and at least one expected

      values isn't found

    - 0 if `mode` == 'any' and no expected values isn't found at all

    - else the number of matching values

    Notice `mode` = 'any' with a single expected value has no effect at all.

    """

    def __init__(self, *expected, **kwargs):

        assert expected, self

        if len(expected) == 1 and isinstance(expected[0], (set, dict)):

            self.expected = expected[0]

        else:

            self.expected = frozenset(expected)

        mode = kwargs.pop('mode', 'all')

        assert mode in ('any', 'all'), 'bad mode %s' % mode

        self.once_is_enough = mode == 'any'

        assert not kwargs, 'unexpected arguments %s' % kwargs

    def __str__(self):

        return '%s(%s)' % (self.__class__.__name__,

                           ','.join(sorted(str(s) for s in self.expected)))

    def __call__(self, cls, req, **kwargs):

        values = self._values_set(cls, req, **kwargs)

        if isinstance(values, dict):

            if isinstance(self.expected, dict):

                matching = 0

                for key, expected_value in self.expected.items():

                    if key in values:

                        if (isinstance(expected_value, (list, tuple, frozenset, set))

                            and values[key] in expected_value):

                            matching += 1

                        elif values[key] == expected_value:

                            matching += 1

            if isinstance(self.expected, (set, frozenset)):

                values = frozenset(values)

                matching = len(values & self.expected)

        else:

            matching = len(values & self.expected)

        if self.once_is_enough:

            return matching

        if matching == len(self.expected):

            return matching

        return 0

    def _values_set(self, cls, req, **kwargs):

        return frozenset( (self._get_value(cls, req, **kwargs),) )

    def _get_value(self, cls, req, **kwargs):

        raise NotImplementedError()

# bare predicates ##############################################################

class match_kwargs(ExpectedValuePredicate):

    """Return non-zero score if parameter names specified as initializer

    arguments are specified in the input context.

    Return a score corresponding to the number of expected parameters.

    When multiple parameters are expected, all of them should be found in

    the input context unless `mode` keyword argument is given to 'any',

    in which case a single matching parameter is enough.

    """

    def _values_set(self, cls, req, **kwargs):

        return kwargs

class appobject_selectable(Predicate):

    """Return 1 if another appobject is selectable using the same input context.

    Initializer arguments:

    * `registry`, a registry name

    * `regids`, object identifiers in this registry, one of them should be

      selectable.

    """

    selectable_score = 1

    def __init__(self, registry, *regids):

        self.registry = registry

        self.regids = regids

    def __call__(self, cls, req, **kwargs):

        for regid in self.regids:

            if req.vreg[self.registry].select_or_none(regid, req, **kwargs) is not None:

                return self.selectable_score

        return 0

class adaptable(appobject_selectable):

    """Return 1 if another appobject is selectable using the same input context.

    Initializer arguments:

    * `regids`, adapter identifiers (e.g. interface names) to which the context

      (usually entities) should be adaptable. One of them should be selectable

      when multiple identifiers are given.

    """

    def __init__(self, *regids):

        super(adaptable, self).__init__('adapters', *regids)

    def __call__(self, cls, req, **kwargs):

        kwargs.setdefault('accept_none', False)

        score = super(adaptable, self).__call__(cls, req, **kwargs)

        if score == 0 and kwargs.get('rset') and len(kwargs['rset']) > 1 and not 'row' in kwargs:

            # on rset containing several entity types, each row may be

            # individually adaptable, while the whole rset won't be if the

            # same adapter can't be used for each type

                kwargs.setdefault('col', 0)

                _score = super(adaptable, self).__call__(cls, req, row=row, **kwargs)

                if not _score:

                    return 0

                # adjust score per row as expected by default adjust_score

                # implementation

                score += self.adjust_score(_score)

        else:

            score = self.adjust_score(score)

        return score

    @staticmethod

    def adjust_score(score):

        # being adaptable to an interface should takes precedence other

        # is_instance('Any'), but not other explicit

        # is_instance('SomeEntityType'), and, for **a single entity**:

        # * is_instance('Any') score is 1

        # * is_instance('SomeEntityType') score is at least 2

        if score >= 2:

            return score - 0.5

        if score == 1:

            return score + 0.5

        return score

class configuration_values(Predicate):

    """Return 1 if the instance has an option set to a given value(s) in its

    configuration file.

    """

    # XXX this predicate could be evaluated on startup

    def __init__(self, key, values):

        self._key = key

        if not isinstance(values, (tuple, list)):

            values = (values,)

        self._values = frozenset(values)

    def __call__(self, cls, req, **kwargs):

        try:

            return self._score

        except AttributeError:

            if req is None:

                config = kwargs['repo'].config

            else:

                config = req.vreg.config

            self._score = config[self._key] in self._values

        return self._score

# rset predicates ##############################################################

@objectify_predicate

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

    """Return 1 if the result set is None (eg usually not specified)."""

    if rset is None: