"""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.logging_ext import set_log_methods

from logilab.common.deprecation import deprecated

from logilab.common.graph import get_cycles

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,

                              FormatConstraint)

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

                         obsolete as yobsolete, cleanup_sys_modules)

from rql import parse, nodes, RQLSyntaxError, TypeResolverException

import cubicweb

from cubicweb import ETYPE_NAME_MAP, ValidationError, Unauthorized

# XXX <3.2 bw compat

from yams import schema

schema.use_py_datetime()

nodes.use_py_datetime()

PURE_VIRTUAL_RTYPES = set(('identity', 'has_text',))

VIRTUAL_RTYPES = set(('eid', 'identity', 'has_text',))

#  set of meta-relations available for every entity types

META_RTYPES = set((

    'owned_by', 'created_by', 'is', 'is_instance_of', 'identity',

    'eid', 'creation_date', 'modification_date', 'has_text', 'cwuri',

    ))

#  set of entity and relation types used to build the schema

SCHEMA_TYPES = set((

    'CWEType', 'CWRType', 'CWAttribute', 'CWRelation',

    'CWConstraint', 'CWConstraintType', 'RQLExpression',

    'relation_type', 'from_entity', 'to_entity',

    'constrained_by', 'cstrtype',

    ))

_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',)

# XXX same algorithm as in reorder_cubes and probably other place,

# may probably extract a generic function

def order_eschemas(eschemas):

    """return entity schemas ordered such that entity types which specializes an

    other one appears after that one

    """

    graph = {}

    for eschema in eschemas:

        if eschema.specializes():

            graph[eschema] = set((eschema.specializes(),))

        else:

            graph[eschema] = set()

    cycles = get_cycles(graph)

    if cycles:

        cycles = '\n'.join(' -> '.join(cycle) for cycle in cycles)

        raise Exception('cycles in entity schema specialization: %s'

                        % cycles)

    eschemas = []

    while graph:

        # sorted to get predictable results

        for eschema, deps in sorted(graph.items()):

            if not deps:

                eschemas.append(eschema)

                del graph[eschema]

                for deps in graph.itervalues():

                    try:

                        deps.remove(eschema)

                    except KeyError:

                        continue

    return eschemas

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

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

    """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

    else:

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

__builtins__['display_name'] = deprecated('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():

            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 main_attribute(self):

        """convenience method that returns the *main* (i.e. the first non meta)

        attribute defined in the entity schema

        """

        for rschema, _ in self.attribute_definitions():

            if not (rschema in META_RTYPES

                    or self.is_metadata(rschema)):

                return rschema

    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(True)

    def _update_has_text(self, deletion=False):

        may_need_has_text, has_has_text = False, False

        need_has_text = None

        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

        if need_has_text is None:

            need_has_text = may_need_has_text

        if need_has_text and not has_has_text and not deletion:

            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 SCHEMA_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

    @property

    def meta(self):

        return self.type in META_RTYPES

    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)