"""classes to define schemas for CubicWeb

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

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

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__docformat__ = "restructuredtext en"

_ = unicode

import re

from os.path import join

from logging import getLogger

from warnings import warn

from logilab.common.decorators import cached, clear_cache, monkeypatch

from logilab.common.deprecation import obsolete

from logilab.common.compat import any

from yams import BadSchemaDefinition, buildobjs as ybo

from yams.schema import Schema, ERSchema, EntitySchema, RelationSchema

from yams.constraints import BaseConstraint, StaticVocabularyConstraint

from yams.reader import (CONSTRAINTS, RelationFileReader, PyFileReader,

                         SchemaLoader)

from rql import parse, nodes, RQLSyntaxError, TypeResolverException

from cubicweb import ETYPE_NAME_MAP, ValidationError, Unauthorized

from cubicweb import set_log_methods

# XXX <3.2 bw compat

from yams import schema

schema.use_py_datetime()

nodes.use_py_datetime()

BASEGROUPS = ('managers', 'users', 'guests', 'owners')

_LOGGER = getLogger('cubicweb.schemaloader')

# schema entities created from serialized schema have an eid rproperty

ybo.ETYPE_PROPERTIES += ('eid',)

ybo.RTYPE_PROPERTIES += ('eid',)

ybo.RDEF_PROPERTIES += ('eid',)

def bw_normalize_etype(etype):

    if etype in ETYPE_NAME_MAP:

        msg = '%s has been renamed to %s, please update your code' % (

            etype, ETYPE_NAME_MAP[etype])

        warn(msg, DeprecationWarning, stacklevel=4)

        etype = ETYPE_NAME_MAP[etype]

    return etype

# monkey path yams.builder.RelationDefinition to support a new wildcard type '@'

# corresponding to system entity (ie meta but not schema)

def _actual_types(self, schema, etype):

    # two bits of error checking & reporting :

    if type(etype) not in (str, list, tuple):

        raise RuntimeError, ('Entity types must not be instances but strings or'

                             ' list/tuples thereof. Ex. (bad, good) : '

                             'SubjectRelation(Foo), SubjectRelation("Foo"). '

                             'Hence, %r is not acceptable.' % etype)

    # real work :

    if etype == '**':

        return self._pow_etypes(schema)

    if isinstance(etype, (tuple, list)):

        return etype

    if '*' in etype or '@' in etype:

        assert len(etype) in (1, 2)

        etypes = ()

        if '*' in etype:

            etypes += tuple(self._wildcard_etypes(schema))

        if '@' in etype:

            etypes += tuple(system_etypes(schema))

        return etypes

    return (etype,)

ybo.RelationDefinition._actual_types = _actual_types

## cubicweb provides a RichString class for convenience

class RichString(ybo.String):

    """Convenience RichString attribute type

    The following declaration::

      class Card(EntityType):

          content = RichString(fulltextindexed=True, default_format='text/rest')

    is equivalent to::

      class Card(EntityType):

          content_format = String(meta=True, internationalizable=True,

                                 default='text/rest', constraints=[format_constraint])

          content  = String(fulltextindexed=True)

    """

    def __init__(self, default_format='text/plain', format_constraints=None, **kwargs):

        self.default_format = default_format

        self.format_constraints = format_constraints or [format_constraint]

        super(RichString, self).__init__(**kwargs)

PyFileReader.context['RichString'] = RichString

## need to monkeypatch yams' _add_relation function to handle RichString

yams_add_relation = ybo._add_relation

@monkeypatch(ybo)

def _add_relation(relations, rdef, name=None, insertidx=None):

    if isinstance(rdef, RichString):

        format_attrdef = ybo.String(meta=True, internationalizable=True,

                                    default=rdef.default_format, maxsize=50,

                                    constraints=rdef.format_constraints)

        yams_add_relation(relations, format_attrdef, name+'_format', insertidx)

    yams_add_relation(relations, rdef, name, insertidx)

def display_name(req, key, form=''):

    """return a internationalized string for the key (schema entity or relation

    name) in a given form

    """

    assert form in ('', 'plural', 'subject', 'object')

    if form == 'subject':

        form = ''

    if form:

        key = key + '_' + form

    # ensure unicode

    # added .lower() in case no translation are available

    return unicode(req._(key)).lower()

__builtins__['display_name'] = obsolete('display_name should be imported from cubicweb.schema')(display_name)

def ERSchema_display_name(self, req, form=''):

    """return a internationalized string for the entity/relation type name in

    a given form

    """

    return display_name(req, self.type, form)

ERSchema.display_name = ERSchema_display_name

@cached

def ERSchema_get_groups(self, action):

    """return the groups authorized to perform <action> on entities of

    this type

    :type action: str

    :param action: the name of a permission

    :rtype: tuple

    :return: names of the groups with the given permission

    """

    assert action in self.ACTIONS, action

    #assert action in self._groups, '%s %s' % (self, action)

    try:

        return frozenset(g for g in self._groups[action] if isinstance(g, basestring))

    except KeyError:

        return ()

ERSchema.get_groups = ERSchema_get_groups

def ERSchema_set_groups(self, action, groups):

    """set the groups allowed to perform <action> on entities of this type. Don't

    change rql expressions for the same action.

    :type action: str

    :param action: the name of a permission

    :type groups: list or tuple

    :param groups: names of the groups granted to do the given action

    """

    assert action in self.ACTIONS, action

    clear_cache(self, 'ERSchema_get_groups')

    self._groups[action] = tuple(groups) + self.get_rqlexprs(action)

ERSchema.set_groups = ERSchema_set_groups

@cached

def ERSchema_get_rqlexprs(self, action):

    """return the rql expressions representing queries to check the user is allowed

    to perform <action> on entities of this type

    :type action: str

    :param action: the name of a permission

    :rtype: tuple

    :return: the rql expressions with the given permission

    """

    assert action in self.ACTIONS, action

    #assert action in self._rqlexprs, '%s %s' % (self, action)

    try:

        return tuple(g for g in self._groups[action] if not isinstance(g, basestring))

    except KeyError:

        return ()

ERSchema.get_rqlexprs = ERSchema_get_rqlexprs

def ERSchema_set_rqlexprs(self, action, rqlexprs):

    """set the rql expression allowing to perform <action> on entities of this type. Don't

    change groups for the same action.

    :type action: str

    :param action: the name of a permission

    :type rqlexprs: list or tuple

    :param rqlexprs: the rql expressions allowing the given action

    """

    assert action in self.ACTIONS, action

    clear_cache(self, 'ERSchema_get_rqlexprs')

    self._groups[action] = tuple(self.get_groups(action)) + tuple(rqlexprs)

ERSchema.set_rqlexprs = ERSchema_set_rqlexprs

def ERSchema_set_permissions(self, action, permissions):

    """set the groups and rql expressions allowing to perform <action> on

    entities of this type

    :type action: str

    :param action: the name of a permission

    :type permissions: tuple

    :param permissions: the groups and rql expressions allowing the given action

    """

    assert action in self.ACTIONS, action

    clear_cache(self, 'ERSchema_get_rqlexprs')

    clear_cache(self, 'ERSchema_get_groups')

    self._groups[action] = tuple(permissions)

ERSchema.set_permissions = ERSchema_set_permissions

def ERSchema_has_perm(self, session, action, *args, **kwargs):

    """return true if the action is granted globaly or localy"""

    try:

        self.check_perm(session, action, *args, **kwargs)

        return True

    except Unauthorized:

        return False

ERSchema.has_perm = ERSchema_has_perm

def ERSchema_has_local_role(self, action):

    """return true if the action *may* be granted localy (eg either rql

    expressions or the owners group are used in security definition)

    XXX this method is only there since we don't know well how to deal with

    'add' action checking. Also find a better name would be nice.

    """

    assert action in self.ACTIONS, action

    if self.get_rqlexprs(action):

        return True

    if action in ('update', 'delete'):

        return self.has_group(action, 'owners')

    return False

ERSchema.has_local_role = ERSchema_has_local_role

def system_etypes(schema):

    """return system entity types only: skip final, schema and application entities

    """

    for eschema in schema.entities():

        if eschema.is_final() or eschema.schema_entity() or not eschema.meta:

            continue

        yield eschema.type

# Schema objects definition ###################################################

class CubicWebEntitySchema(EntitySchema):

    """a entity has a type, a set of subject and or object relations

    the entity schema defines the possible relations for a given type and some

    constraints on those relations

    """

    def __init__(self, schema=None, edef=None, eid=None, **kwargs):

        super(CubicWebEntitySchema, self).__init__(schema, edef, **kwargs)

        if eid is None and edef is not None:

            eid = getattr(edef, 'eid', None)

        self.eid = eid

        # take care: no _groups attribute when deep-copying

        if getattr(self, '_groups', None):

            for groups in self._groups.itervalues():

                for group_or_rqlexpr in groups:

                    if isinstance(group_or_rqlexpr, RRQLExpression):

                        msg = "can't use RRQLExpression on an entity type, use an ERQLExpression (%s)"

                        raise BadSchemaDefinition(msg % self.type)

    def attribute_definitions(self):

        """return an iterator on attribute definitions

        attribute relations are a subset of subject relations where the

        object's type is a final entity

        an attribute definition is a 2-uple :

        * name of the relation

        * schema of the destination entity type

        """

        iter = super(CubicWebEntitySchema, self).attribute_definitions()

        for rschema, attrschema in iter:

            if rschema.type == 'has_text':

                continue

            yield rschema, attrschema

    def add_subject_relation(self, rschema):

        """register the relation schema as possible subject relation"""

        super(CubicWebEntitySchema, self).add_subject_relation(rschema)

        self._update_has_text()

    def del_subject_relation(self, rtype):

        super(CubicWebEntitySchema, self).del_subject_relation(rtype)

        self._update_has_text(False)

    def _update_has_text(self, need_has_text=None):

        may_need_has_text, has_has_text = False, False

        for rschema in self.subject_relations():

            if rschema.is_final():

                if rschema == 'has_text':

                    has_has_text = True

                elif self.rproperty(rschema, 'fulltextindexed'):

                    may_need_has_text = True

            elif rschema.fulltext_container:

                if rschema.fulltext_container == 'subject':

                    may_need_has_text = True

                else:

                    need_has_text = False

        for rschema in self.object_relations():

            if rschema.fulltext_container:

                if rschema.fulltext_container == 'object':

                    may_need_has_text = True

                else:

                    need_has_text = False

                    break

        if need_has_text is None:

            need_has_text = may_need_has_text

        if need_has_text and not has_has_text:

            rdef = ybo.RelationDefinition(self.type, 'has_text', 'String')

            self.schema.add_relation_def(rdef)

        elif not need_has_text and has_has_text:

            self.schema.del_relation_def(self.type, 'has_text', 'String')

    def schema_entity(self):

        """return True if this entity type is used to build the schema"""

        return self.type in self.schema.schema_entity_types()

    def check_perm(self, session, action, eid=None):

        # NB: session may be a server session or a request object

        user = session.user

        # check user is in an allowed group, if so that's enough

        # internal sessions should always stop there

        if user.matching_groups(self.get_groups(action)):

            return

        # if 'owners' in allowed groups, check if the user actually owns this

        # object, if so that's enough

        if eid is not None and 'owners' in self.get_groups(action) and \

               user.owns(eid):

            return

        # else if there is some rql expressions, check them

        if any(rqlexpr.check(session, eid)

               for rqlexpr in self.get_rqlexprs(action)):

            return

        raise Unauthorized(action, str(self))

    def rql_expression(self, expression, mainvars=None, eid=None):

        """rql expression factory"""

        return ERQLExpression(expression, mainvars, eid)

class CubicWebRelationSchema(RelationSchema):

    RelationSchema._RPROPERTIES['eid'] = None

    _perms_checked = False

    def __init__(self, schema=None, rdef=None, eid=None, **kwargs):

        if rdef is not None:

            # if this relation is inlined

            self.inlined = rdef.inlined

        super(CubicWebRelationSchema, self).__init__(schema, rdef, **kwargs)

        if eid is None and rdef is not None:

            eid = getattr(rdef, 'eid', None)

        self.eid = eid

    def update(self, subjschema, objschema, rdef):

        super(CubicWebRelationSchema, self).update(subjschema, objschema, rdef)

        if not self._perms_checked and self._groups:

            for action, groups in self._groups.iteritems():

                for group_or_rqlexpr in groups:

                    if action == 'read' and \

                           isinstance(group_or_rqlexpr, RQLExpression):

                        msg = "can't use rql expression for read permission of "\

                              "a relation type (%s)"

                        raise BadSchemaDefinition(msg % self.type)

                    elif self.final and isinstance(group_or_rqlexpr, RRQLExpression):

                        if self.schema.reading_from_database:

                            # we didn't have final relation earlier, so turn

                            # RRQLExpression into ERQLExpression now

                            rqlexpr = group_or_rqlexpr

                            newrqlexprs = [x for x in self.get_rqlexprs(action) if not x is rqlexpr]

                            newrqlexprs.append(ERQLExpression(rqlexpr.expression,

                                                              rqlexpr.mainvars,

                                                              rqlexpr.eid))

                            self.set_rqlexprs(action, newrqlexprs)

                        else:

                            msg = "can't use RRQLExpression on a final relation "\

                                  "type (eg attribute relation), use an ERQLExpression (%s)"

                            raise BadSchemaDefinition(msg % self.type)

                    elif not self.final and \

                             isinstance(group_or_rqlexpr, ERQLExpression):

                        msg = "can't use ERQLExpression on a relation type, use "\

                              "a RRQLExpression (%s)"

                        raise BadSchemaDefinition(msg % self.type)

            self._perms_checked = True

    def cardinality(self, subjtype, objtype, target):

        card = self.rproperty(subjtype, objtype, 'cardinality')

        return (target == 'subject' and card[0]) or \

               (target == 'object' and card[1])

    def schema_relation(self):