"""This file contains some basic selectors required by application objects.

A selector is responsible to score how well an object may be used with a

given result set (publishing time selection)

If you have trouble with selectors, especially if the objet (typically

a view or a component) you want to use is not selected and you want to

know which one(s) of its selectors fail (e.g. returns 0), you can use

`traced_selection` or even direclty `TRACED_OIDS`.

`TRACED_OIDS` is a tuple of traced object ids. The special value

'all' may be used to log selectors for all objects.

For instance, say that the following code yields a `NoSelectableObject`

exception::

    self.view('calendar', myrset)

You can log the selectors involved for *calendar* by replacing the line

above by::

    # in Python2.5

    from cubicweb.common.selectors import traced_selection

    with traced_selection():

        self.view('calendar', myrset)

    # in Python2.4

    from cubicweb.common import selectors

    selectors.TRACED_OIDS = ('calendar',)

    self.view('calendar', myrset)

    selectors.TRACED_OIDS = ()

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

"""

__docformat__ = "restructuredtext en"

import logging

from warnings import warn

from logilab.common.compat import all

from logilab.common.deprecation import deprecated_function

from logilab.common.interface import implements as implements_iface

from yams import BASE_TYPES

from cubicweb import Unauthorized, NoSelectableObject, role

from cubicweb.vregistry import NoSelectableObject, Selector, chainall, chainfirst

from cubicweb.cwvreg import DummyCursorError

from cubicweb.cwconfig import CubicWebConfiguration

from cubicweb.schema import split_expression

# helpers for debugging selectors

SELECTOR_LOGGER = logging.getLogger('cubicweb.selectors')

TRACED_OIDS = ()

def lltrace(selector):

    # don't wrap selectors if not in development mode

    if CubicWebConfiguration.mode == 'installed':

        return selector

    def traced(cls, *args, **kwargs):

        if isinstance(cls, Selector):

            selname = cls.__class__.__name__

            oid = args[0].id

        else:

            selname = selector.__name__

            oid = cls.id

        ret = selector(cls, *args, **kwargs)

        if TRACED_OIDS == 'all' or oid in TRACED_OIDS:

            #SELECTOR_LOGGER.warning('selector %s returned %s for %s', selname, ret, cls)

            print 'selector %s returned %s for %s' % (selname, ret, cls)

        return ret

    traced.__name__ = selector.__name__

    return traced

class traced_selection(object):

    """selector debugging helper.

    Typical usage is :

    >>> with traced_selection():

    ...     # some code in which you want to debug selectors

    ...     # for all objects

    or

    >>> with traced_selection( ('oid1', 'oid2') ):

    ...     # some code in which you want to debug selectors

    ...     # for objects with id 'oid1' and 'oid2'

    """

    def __init__(self, traced='all'):

        self.traced = traced

    def __enter__(self):

        global TRACED_OIDS

        TRACED_OIDS = self.traced

    def __exit__(self, exctype, exc, traceback):

        global TRACED_OIDS

        TRACED_OIDS = ()

        return traceback is None

# very basic selectors ########################################################

def yes(cls, *args, **kwargs):

    """accept everything"""

    return 1

yes_selector = deprecated_function(yes)

@lltrace

def none_rset(cls, req, rset, *args, **kwargs):

    """accept no result set"""

    if rset is None:

        return 1

    return 0

norset_selector = deprecated_function(none_rset)

@lltrace

def any_rset(cls, req, rset, *args, **kwargs):

    """accept result set, whatever the number of result"""

    if rset is not None:

        return 1

    return 0

rset_selector = deprecated_function(any_rset)

@lltrace

def nonempty_rset(cls, req, rset, *args, **kwargs):

    """accept any non empty result set"""

    if rset is not None and rset.rowcount:

        return 1

    return 0

anyrset_selector = deprecated_function(nonempty_rset)

@lltrace

def empty_rset(cls, req, rset, *args, **kwargs):

    """accept empty result set"""

    if rset is not None and rset.rowcount == 0:

        return 1

    return 0

emptyrset_selector = deprecated_function(empty_rset)

@lltrace

def one_line_rset(cls, req, rset, row=None, *args, **kwargs):

    """accept result set with a single line of result"""

    if rset is not None and (row is not None or rset.rowcount == 1):

        return 1

    return 0

onelinerset_selector = deprecated_function(one_line_rset)

@lltrace

def two_lines_rset(cls, req, rset, *args, **kwargs):

    """accept result set with *at least* two lines of result"""

    if rset is not None and rset.rowcount > 1:

        return 1

    return 0

twolinerset_selector = deprecated_function(two_lines_rset)

@lltrace

def two_cols_rset(cls, req, rset, *args, **kwargs):

    """accept result set with at least one line and two columns of result"""

    if rset is not None and rset.rowcount > 0 and len(rset.rows[0]) > 1:

        return 1

    return 0

twocolrset_selector = deprecated_function(two_cols_rset)

@lltrace

def paginated_rset(cls, req, rset, *args, **kwargs):

    """accept result sets with more rows than the page size

    """

    page_size = kwargs.get('page_size')

    if page_size is None:

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

        if page_size is None:

            page_size = req.property_value('navigation.page-size')

        else:

            page_size = int(page_size)

    if rset is None or len(rset) <= page_size:

        return 0

    return 1

largerset_selector = deprecated_function(paginated_rset)

@lltrace

def sorted_rset(cls, req, rset, row=None, col=0, **kwargs):

    """accept sorted result set"""

    rqlst = rset.syntax_tree()

    if len(rqlst.children) > 1 or not rqlst.children[0].orderby:

        return 0

    return 2

sortedrset_selector = deprecated_function(sorted_rset)

@lltrace

def one_etype_rset(cls, req, rset, *args, **kwargs):

    """accept result set where entities in the first columns are all of the

    same type

    """

    if len(rset.column_types(0)) != 1:

        return 0

    return 1

oneetyperset_selector = deprecated_function(one_etype_rset)

@lltrace

def two_etypes_rset(cls, req, rset, **kwargs):

    """accepts resultsets containing several entity types"""

    if rset:

        etypes = rset.column_types(0)

        if len(etypes) > 1:

            return 1

    return 0

multitype_selector = deprecated_function(two_etypes_rset)

class match_search_state(Selector):

    def __init__(self, *expected):

        self.expected = expected

    @lltrace

    def __call__(self, cls, req, rset, row=None, col=0, **kwargs):

        """checks if the current request search state is in one of the expected states

        the wrapped class

        search state should be either 'normal' or 'linksearch' (eg searching for an

        object to create a relation with another)

        """

        try:

            if not req.search_state[0] in self.expected:

                return 0

        except AttributeError:

            return 1 # class doesn't care about search state, accept it

        return 1

class match_form_params(match_search_state):

    """check if parameters specified as initializer arguments are specified

    in request form parameters

    """

    @lltrace

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

        score = 0

        for param in self.expected:

            val = req.form.get(param)

            if not val:

                return 0

            score += 1

        return len(self.expected)

class match_kwargs(match_search_state):

    """check if parameters specified as initializer arguments are specified

    in named parameters

    """

    @lltrace

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

        for arg in self.expected:

            if not arg in kwargs:

                return 0

        return len(self.expected)

@lltrace

def anonymous_user(cls, req, *args, **kwargs):

    """accept if user is anonymous"""

    if req.cnx.anonymous_connection:

        return 1

    return 0

anonymous_selector = deprecated_function(anonymous_user)

@lltrace

def authenticated_user(cls, req, *args, **kwargs):

    """accept if user is authenticated"""

    return not anonymous_user(cls, req, *args, **kwargs)

not_anonymous_selector = deprecated_function(authenticated_user)

# abstract selectors ##########################################################

class EClassSelector(Selector):

    """abstract class for selectors working on the entity classes of the result

    set

    """

    once_is_enough = False

    @lltrace

    def __call__(self, cls, req, rset, row=None, col=0, **kwargs):

        if not rset:

            return 0

        score = 0

        if row is None:

            for etype in rset.column_types(col):

                if etype is None: # outer join

                    continue

                if etype in BASE_TYPES:

                    return 0

                escore = self.score_class(cls.vreg.etype_class(etype), req)

                if not escore:

                    return 0

                elif self.once_is_enough:

                    return escore

                score += escore

        else:

            etype = rset.description[row][col]

            if etype is not None and not etype in BASE_TYPES:

                score = self.score_class(cls.vreg.etype_class(etype), req)

        return score and (score + 1)

    def score_class(self, eclass, req):

        raise NotImplementedError()

class EntitySelector(Selector):

    """abstract class for selectors working on the entity instances of the

    result set

    """

    @lltrace

    def __call__(self, cls, req, rset, row=None, col=0, **kwargs):

        if not rset:

            return 0

        score = 0

        if row is None:

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

                if rowvalue[col] is None: # outer join

                    continue

                try:

                    escore = self.score_entity(rset.get_entity(row, col))

                except NotAnEntity:

                    return 0

                if not escore:

                    return 0

                score += escore

        else:

            etype = rset.description[row][col]

            if etype is not None: # outer join

                try:

                    score = self.score_entity(rset.get_entity(row, col))

                except NotAnEntity:

                    return 0

        return score and (score + 1)

    def score_entity(self, entity):

        raise NotImplementedError()

# not so basic selectors ######################################################

class implements(EClassSelector):

    """initializer takes a list of interfaces or entity types as argument

    * if row is None, return the number of implemented interfaces for each

      entity's class in the result set at the specified column (or column 0).

      If any class has no matching interface, return 0.

    * if row is specified, return number of implemented interfaces by the

      entity's class at this row (and column)

    if some interface is an entity class, the score will reflect class

    proximity so the most specific object'll be selected

    """

    def __init__(self, *expected_ifaces):

        self.expected_ifaces = expected_ifaces

    def score_class(self, eclass, req):

        score = 0

        for iface in self.expected_ifaces:

            if isinstance(iface, basestring):

                # entity type

                iface = eclass.vreg.etype_class(iface)

            if implements_iface(eclass, iface):

                score += 1

                if getattr(iface, '__registry__', None) == 'etypes':

                    score += 1

                    # adjust score if the interface is an entity class

                    if iface is eclass:

                        score += len(eclass.e_schema.ancestors())

                        print 'is majoration', len(eclass.e_schema.ancestors()) 

                    else:

                        parents = [e.type for e in eclass.e_schema.ancestors()]

                        for index, etype in enumerate(reversed(parents)):

                            basecls = eclass.vreg.etype_class(etype)

                            if iface is basecls:

                                score += index

                                print 'etype majoration', index

                                break

        return score

class specified_etype_implements(implements):

    """return the "interface score" for class associated to 'etype' (expected in

    request form or arguments)

    """

    @lltrace

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

        try:

            etype = req.form['etype']

        except KeyError:

            try:

                etype = kwargs['etype']

            except KeyError:

                return 0

        return self.score_class(cls.vreg.etype_class(etype), req)

class relation_possible(EClassSelector):

    """initializer takes relation name as argument and an optional role (default

      as subject) and target type (default to unspecified)

    * if row is None, return 1 if every entity's class in the result set at the

      specified column (or column 0) may have this relation (as role). If target

      type is specified, check the relation's end may be of this target type.

    * if row is specified, check relation is supported by the entity's class at

      this row (and column)

    """

    def __init__(self, rtype, role='subject', target_etype=None,

                 permission='read', once_is_enough=False):

        self.rtype = rtype