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

"""Base class for entity objects manipulated in clients"""

__docformat__ = "restructuredtext en"

from warnings import warn

from functools import partial

from logilab.common import interface

from logilab.common.decorators import cached

from logilab.common.deprecation import deprecated

from logilab.common.registry import yes

from logilab.mtconverter import TransformData, xml_escape

from rql.utils import rqlvar_maker

from rql.stmts import Select

from rql.nodes import (Not, VariableRef, Constant, make_relation,

                       Relation as RqlRelation)

from cubicweb import Unauthorized, neg_role

from cubicweb.utils import support_args

from cubicweb.rset import ResultSet

from cubicweb.appobject import AppObject

from cubicweb.schema import (RQLVocabularyConstraint, RQLConstraint,

                             GeneratedConstraint)

from cubicweb.rqlrewrite import RQLRewriter

from cubicweb.uilib import soup2xhtml

from cubicweb.mixins import MI_REL_TRIGGERS

from cubicweb.mttransforms import ENGINE

_marker = object()

def greater_card(rschema, subjtypes, objtypes, index):

    for subjtype in subjtypes:

        for objtype in objtypes:

            card = rschema.rdef(subjtype, objtype).cardinality[index]

            if card in '+*':

                return card

    return '1'

def can_use_rest_path(value):

    """return True if value can be used at the end of a Rest URL path"""

    if value is None:

        return False

    value = unicode(value)

    # the check for ?, /, & are to prevent problems when running

    # behind Apache mod_proxy

    if value == u'' or u'?' in value or u'/' in value or u'&' in value:

        return False

    return True

def rel_vars(rel):

    return ((isinstance(rel.children[0], VariableRef)

             and rel.children[0].variable or None),

            (isinstance(rel.children[1].children[0], VariableRef)

             and rel.children[1].children[0].variable or None)

            )

def rel_matches(rel, rtype, role, varname, operator='='):

    if rel.r_type == rtype and rel.children[1].operator == operator:

        same_role_var_idx = 0 if role == 'subject' else 1

        variables = rel_vars(rel)

        if variables[same_role_var_idx].name == varname:

            return variables[1 - same_role_var_idx]

def build_cstr_with_linkto_infos(cstr, args, searchedvar, evar,

                                 lt_infos, eidvars):

    """restrict vocabulary as much as possible in entity creation,

    based on infos provided by __linkto form param.

    Example based on following schema:

      class works_in(RelationDefinition):

          subject = 'CWUser'

          object = 'Lab'

          cardinality = '1*'

          constraints = [RQLConstraint('S in_group G, O welcomes G')]

      class welcomes(RelationDefinition):

          subject = 'Lab'

          object = 'CWGroup'

    If you create a CWUser in the "scientists" CWGroup you can show

    only the labs that welcome them using :

      lt_infos = {('in_group', 'subject'): 321}

    You get following restriction : 'O welcomes G, G eid 321'

    """

    st = cstr.snippet_rqlst.copy()

    # replace relations in ST by eid infos from linkto where possible

    for (info_rtype, info_role), eids in lt_infos.iteritems():

        eid = eids[0] # NOTE: we currently assume a pruned lt_info with only 1 eid

        for rel in st.iget_nodes(RqlRelation):

            targetvar = rel_matches(rel, info_rtype, info_role, evar.name)

            if targetvar is not None:

                if targetvar.name in eidvars:

                    rel.parent.remove(rel)

                else:

                    eidrel = make_relation(

                        targetvar, 'eid', (targetvar.name, 'Substitute'),

                        Constant)

                    rel.parent.replace(rel, eidrel)

                    args[targetvar.name] = eid

                    eidvars.add(targetvar.name)

    # if modified ST still contains evar references we must discard the

    # constraint, otherwise evar is unknown in the final rql query which can

    # lead to a SQL table cartesian product and multiple occurences of solutions

    evarname = evar.name

    for rel in st.iget_nodes(RqlRelation):

        for variable in rel_vars(rel):

            if variable and evarname == variable.name:

                return

    # else insert snippets into the global tree

    return GeneratedConstraint(st, cstr.mainvars - set(evarname))

def pruned_lt_info(eschema, lt_infos):

    pruned = {}

    for (lt_rtype, lt_role), eids in lt_infos.iteritems():

        # we can only use lt_infos describing relation with a cardinality

        # of value 1 towards the linked entity

        if not len(eids) == 1:

            continue

        lt_card = eschema.rdef(lt_rtype, lt_role).cardinality[

            0 if lt_role == 'subject' else 1]

        if lt_card not in '?1':

            continue

        pruned[(lt_rtype, lt_role)] = eids

    return pruned

class Entity(AppObject):

    """an entity instance has e_schema automagically set on

    the class and instances has access to their issuing cursor.

    A property is set for each attribute and relation on each entity's type

    class. Becare that among attributes, 'eid' is *NEITHER* stored in the

    dict containment (which acts as a cache for other attributes dynamically

    fetched)

    :type e_schema: `cubicweb.schema.EntitySchema`

    :ivar e_schema: the entity's schema

    :type rest_attr: str

    :cvar rest_attr: indicates which attribute should be used to build REST urls

       If `None` is specified (the default), the first unique attribute will

       be used ('eid' if none found)

    :type cw_skip_copy_for: list

    :cvar cw_skip_copy_for: a list of couples (rtype, role) for each relation

       that should be skipped when copying this kind of entity. Note that some

       relations such as composite relations or relations that have '?1' as

       object cardinality are always skipped.

    """

    __registry__ = 'etypes'

    __select__ = yes()

    # class attributes that must be set in class definition

    rest_attr = None

    fetch_attrs = None

    skip_copy_for = () # bw compat (< 3.14), use cw_skip_copy_for instead

    cw_skip_copy_for = [('in_state', 'subject')]

    # class attributes set automatically at registration time

    e_schema = None

    @classmethod

    def __initialize__(cls, schema):

        """initialize a specific entity class by adding descriptors to access

        entity type's attributes and relations

        """

        etype = cls.__regid__

        assert etype != 'Any', etype

        cls.e_schema = eschema = schema.eschema(etype)

        for rschema, _ in eschema.attribute_definitions():

            if rschema.type == 'eid':

                continue

            setattr(cls, rschema.type, Attribute(rschema.type))

        mixins = []

        for rschema, _, role in eschema.relation_definitions():

            if (rschema, role) in MI_REL_TRIGGERS:

                mixin = MI_REL_TRIGGERS[(rschema, role)]

                if not (issubclass(cls, mixin) or mixin in mixins): # already mixed ?

                    mixins.append(mixin)

                for iface in getattr(mixin, '__implements__', ()):

                    if not interface.implements(cls, iface):

                        interface.extend(cls, iface)

            if role == 'subject':

                attr = rschema.type

            else:

                attr = 'reverse_%s' % rschema.type

            setattr(cls, attr, Relation(rschema, role))

        if mixins:

            # see etype class instantation in cwvreg.ETypeRegistry.etype_class method:

            # due to class dumping, cls is the generated top level class with actual

            # user class as (only) parent. Since we want to be able to override mixins

            # method from this user class, we have to take care to insert mixins after that

            # class

            #

            # note that we don't plug mixins as user class parent since it causes pb

            # with some cases of entity classes inheritance.

            mixins.insert(0, cls.__bases__[0])

            mixins += cls.__bases__[1:]

            cls.__bases__ = tuple(mixins)

            cls.info('plugged %s mixins on %s', mixins, cls)

    fetch_attrs = ('modification_date',)

    @classmethod

    def cw_fetch_order(cls, select, attr, var):

        """This class method may be used to control sort order when multiple

        entities of this type are fetched through ORM methods. Its arguments

        are:

        * `select`, the RQL syntax tree

        * `attr`, the attribute being watched

        * `var`, the variable through which this attribute's value may be

          accessed in the query

        When you want to do some sorting on the given attribute, you should

        modify the syntax tree accordingly. For instance:

        .. sourcecode:: python

          from rql import nodes

          class Version(AnyEntity):

              __regid__ = 'Version'

              fetch_attrs = ('num', 'description', 'in_state')

              @classmethod

              def cw_fetch_order(cls, select, attr, var):

                  if attr == 'num':

                      func = nodes.Function('version_sort_value')

                      func.append(nodes.variable_ref(var))

                      sterm = nodes.SortTerm(func, asc=False)

                      select.add_sort_term(sterm)

        The default implementation call

        :meth:`~cubicweb.entity.Entity.cw_fetch_unrelated_order`

        """

        cls.cw_fetch_unrelated_order(select, attr, var)

    @classmethod

    def cw_fetch_unrelated_order(cls, select, attr, var):

        """This class method may be used to control sort order when multiple entities of

        this type are fetched to use in edition (e.g. propose them to create a

        new relation on an edited entity).

        See :meth:`~cubicweb.entity.Entity.cw_fetch_unrelated_order` for a

        description of its arguments and usage.

        By default entities will be listed on their modification date descending,

        i.e. you'll get entities recently modified first.

        """

        if attr == 'modification_date':

            select.add_sort_var(var, asc=False)

    @classmethod

    def fetch_rql(cls, user, restriction=None, fetchattrs=None, mainvar='X',

                  settype=True, ordermethod='fetch_order'):

        st = cls.fetch_rqlst(user, mainvar=mainvar, fetchattrs=fetchattrs,

                             settype=settype, ordermethod=ordermethod)

        rql = st.as_string()

        if restriction:

            # cannot use RQLRewriter API to insert 'X rtype %(x)s' restriction

            warn('[3.14] fetch_rql: use of `restriction` parameter is '

                 'deprecated, please use fetch_rqlst and supply a syntax'

                 'tree with your restriction instead', DeprecationWarning)

            insert = ' WHERE ' + ','.join(restriction)

            if ' WHERE ' in rql:

                select, where = rql.split(' WHERE ', 1)

                rql = select + insert + ',' + where

            else:

                rql += insert

        return rql

    @classmethod

    def fetch_rqlst(cls, user, select=None, mainvar='X', fetchattrs=None,

                    settype=True, ordermethod='fetch_order'):

        if select is None:

            select = Select()

            mainvar = select.get_variable(mainvar)

            select.add_selected(mainvar)

        elif isinstance(mainvar, basestring):

            assert mainvar in select.defined_vars

            mainvar = select.get_variable(mainvar)

        # eases string -> syntax tree test transition: please remove once stable

        select._varmaker = rqlvar_maker(defined=select.defined_vars,

                                        aliases=select.aliases, index=26)

        if settype:

            select.add_type_restriction(mainvar, cls.__regid__)

        if fetchattrs is None:

            fetchattrs = cls.fetch_attrs

        cls._fetch_restrictions(mainvar, select, fetchattrs, user, ordermethod)

        return select

    @classmethod

    def _fetch_ambiguous_rtypes(cls, select, var, fetchattrs, subjtypes, schema):

        """find rtypes in `fetchattrs` that relate different subject etypes

        taken from (`subjtypes`) to different target etypes; these so called

        "ambiguous" relations, are added directly to the `select` syntax tree

        selection but removed from `fetchattrs` to avoid the fetch recursion

        because we have to choose only one targettype for the recursion and

        adding its own fetch attrs to the selection -when we recurse- would

        filter out the other possible target types from the result set

        """

        for attr in fetchattrs.copy():

            rschema = schema.rschema(attr)

            if rschema.final:

                continue

            ttypes = None

            for subjtype in subjtypes:

                cur_ttypes = set(rschema.objects(subjtype))

                if ttypes is None:

                    ttypes = cur_ttypes

                elif cur_ttypes != ttypes:

                    # we found an ambiguous relation: remove it from fetchattrs

                    fetchattrs.remove(attr)

                    # ... and add it to the selection

                    targetvar = select.make_variable()

                    select.add_selected(targetvar)

                    rel = make_relation(var, attr, (targetvar,), VariableRef)

                    select.add_restriction(rel)

                    break

    @classmethod

    def _fetch_restrictions(cls, mainvar, select, fetchattrs,

                            user, ordermethod='fetch_order', visited=None):

        eschema = cls.e_schema

        if visited is None:

            visited = set((eschema.type,))

        elif eschema.type in visited:

            # avoid infinite recursion

            return

        else:

            visited.add(eschema.type)

        _fetchattrs = []

        for attr in fetchattrs:

            try:

                rschema = eschema.subjrels[attr]

            except KeyError:

                cls.warning('skipping fetch_attr %s defined in %s (not found in schema)',

                            attr, cls.__regid__)

                continue

            rdef = eschema.rdef(attr)

            if not user.matching_groups(rdef.get_groups('read')):

                continue

            if rschema.final or rdef.cardinality[0] in '?1':

                var = select.make_variable()

                select.add_selected(var)

                rel = make_relation(mainvar, attr, (var,), VariableRef)

                select.add_restriction(rel)

            else:

                cls.warning('bad relation %s specified in fetch attrs for %s',

                            attr, cls)

                continue

            if not rschema.final:

                # XXX we need outer join in case the relation is not mandatory

                # (card == '?')  *or if the entity is being added*, since in

                # that case the relation may still be missing. As we miss this

                # later information here, systematically add it.

                rel.change_optional('right')

                targettypes = rschema.objects(eschema.type)

                vreg = user._cw.vreg # XXX user._cw.vreg iiiirk

                etypecls = vreg['etypes'].etype_class(targettypes[0])

                if len(targettypes) > 1:

                    # find fetch_attrs common to all destination types

                    fetchattrs = vreg['etypes'].fetch_attrs(targettypes)

                    # ... and handle ambiguous relations

                    cls._fetch_ambiguous_rtypes(select, var, fetchattrs,

                                                targettypes, vreg.schema)

                else: