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

"""classes to define schemas for CubicWeb"""

from __future__ import print_function

from functools import wraps

import re

from os.path import join

from hashlib import md5

from logging import getLogger

from warnings import warn

from six import PY2, text_type, string_types, add_metaclass

from six.moves import range

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

from logilab.common.logging_ext import set_log_methods

from logilab.common.deprecation import deprecated

from logilab.common.textutils import splitstrip

from logilab.common.graph import get_cycles

import yams

from yams import BadSchemaDefinition, buildobjs as ybo

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

    RelationDefinitionSchema, PermissionMixIn, role_name

from yams.constraints import (BaseConstraint, FormatConstraint,

                              cstr_json_dumps, cstr_json_loads)

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

                         cleanup_sys_modules, fill_schema_from_namespace)

from yams.buildobjs import _add_relation as yams_add_relation

from rql import parse, nodes, stmts, RQLSyntaxError, TypeResolverException

from rql.analyze import ETypeResolver

import cubicweb

from cubicweb import server

from cubicweb import ETYPE_NAME_MAP, ValidationError, Unauthorized, _

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', 'cw_source', 'modification_date', 'has_text', 'cwuri',

))

WORKFLOW_RTYPES = set(('custom_workflow', 'in_state', 'wf_info_for'))

WORKFLOW_DEF_RTYPES = set(('workflow_of', 'state_of', 'transition_of',

                           'initial_state', 'default_workflow',

                           'allowed_transition', 'destination_state',

                           'from_state', 'to_state', 'condition',

                           'subworkflow', 'subworkflow_state', 'subworkflow_exit',

                           'by_transition',

                           ))

SYSTEM_RTYPES = set(('in_group', 'require_group',

                     # cwproperty

                     'for_user',

                     'cw_import_of',

                     'cw_host_config_of',

                     )) | WORKFLOW_RTYPES

NO_I18NCONTEXT = META_RTYPES | WORKFLOW_RTYPES

SKIP_COMPOSITE_RELS = [('cw_source', 'subject')]

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

SCHEMA_TYPES = set((

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

    'CWConstraint', 'CWConstraintType', 'CWUniqueTogetherConstraint',

    'RQLExpression',

    'specializes',

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

    'constrained_by', 'cstrtype',

    'constraint_of', 'relations',

    'read_permission', 'add_permission',

    'delete_permission', 'update_permission',

))

WORKFLOW_TYPES = set(('Transition', 'State', 'TrInfo', 'Workflow',

                      'WorkflowTransition', 'BaseTransition',

                      'SubWorkflowExitPoint'))

INTERNAL_TYPES = set(('CWProperty', 'CWCache', 'ExternalUri', 'CWDataImport',

                      'CWSource', 'CWSourceHostConfig', 'CWSession'))

UNIQUE_CONSTRAINTS = ('SizeConstraint', 'FormatConstraint',

                      'StaticVocabularyConstraint',

                      'RQLVocabularyConstraint')

_LOGGER = getLogger('cubicweb.schemaloader')

# entity and relation schema created from serialized schema have an eid

ybo.ETYPE_PROPERTIES += ('eid',)

ybo.RTYPE_PROPERTIES += ('eid',)

def build_schema_from_namespace(items):

    schema = CubicWebSchema('noname')

    fill_schema_from_namespace(schema, items, register_base_types=False)

    return schema

# Bases for manipulating RQL in schema #########################################

def guess_rrqlexpr_mainvars(expression):

    defined = set(split_expression(expression))

    mainvars = set()

    if 'S' in defined:

        mainvars.add('S')

    if 'O' in defined:

        mainvars.add('O')

    if 'U' in defined:

        mainvars.add('U')

    if not mainvars:

        raise BadSchemaDefinition('unable to guess selection variables in %r'

                                  % expression)

    return mainvars

def split_expression(rqlstring):

    for expr in rqlstring.split(','):

        for noparen1 in expr.split('('):

            for noparen2 in noparen1.split(')'):

                for word in noparen2.split():

                    yield word

def normalize_expression(rqlstring):

    """normalize an rql expression to ease schema synchronization (avoid

    suppressing and reinserting an expression if only a space has been

    added/removed for instance)

    """

    union = parse(u'Any 1 WHERE %s' % rqlstring).as_string()

    if PY2 and isinstance(union, str):

        union = union.decode('utf-8')

    return union.split(' WHERE ', 1)[1]

def _check_valid_formula(rdef, formula_rqlst):

    """Check the formula is a valid RQL query with some restriction (no union,

    single selected node, etc.), raise BadSchemaDefinition if not

    """

    if len(formula_rqlst.children) != 1:

        raise BadSchemaDefinition('computed attribute %(attr)s on %(etype)s: '

                                  'can not use UNION in formula %(form)r' %

                                  {'attr': rdef.rtype,

                                   'etype': rdef.subject.type,

                                   'form': rdef.formula})

    select = formula_rqlst.children[0]

    if len(select.selection) != 1:

        raise BadSchemaDefinition('computed attribute %(attr)s on %(etype)s: '

                                  'can only select one term in formula %(form)r' %

                                  {'attr': rdef.rtype,

                                   'etype': rdef.subject.type,

                                   'form': rdef.formula})

    term = select.selection[0]

    types = set(term.get_type(sol) for sol in select.solutions)

    if len(types) != 1:

        raise BadSchemaDefinition('computed attribute %(attr)s on %(etype)s: '

                                  'multiple possible types (%(types)s) for formula %(form)r' %

                                  {'attr': rdef.rtype,

                                   'etype': rdef.subject.type,

                                   'types': list(types),

                                   'form': rdef.formula})

    computed_type = types.pop()

    expected_type = rdef.object.type

    if computed_type != expected_type:

        raise BadSchemaDefinition('computed attribute %(attr)s on %(etype)s: '

                                  'computed attribute type (%(comp_type)s) mismatch with '

                                  'specified type (%(attr_type)s)' %

                                  {'attr': rdef.rtype,

                                   'etype': rdef.subject.type,

                                   'comp_type': computed_type,

                                   'attr_type': expected_type})

class RQLExpression(object):

    """Base class for RQL expression used in schema (constraints and

    permissions)

    """

    # these are overridden by set_log_methods below

    # only defining here to prevent pylint from complaining

    info = warning = error = critical = exception = debug = lambda msg, *a, **kw: None

    # to be defined in concrete classes

    predefined_variables = None

    # Internal cache for parsed expressions

    _rql_cache = {}

    @classmethod

    def _cached_parse(cls, rql):

        try:

            return cls._rql_cache[rql]

        except KeyError:

            cls._rql_cache[rql] = parse(rql, print_errors=False).children[0]

            return cls._rql_cache[rql]

    def __init__(self, expression, mainvars, eid):

        """

        :type mainvars: sequence of RQL variables' names. Can be provided as a

                        comma separated string.

        :param mainvars: names of the variables being selected.

        """

        self.eid = eid  # eid of the entity representing this rql expression

        assert mainvars, 'bad mainvars %s' % mainvars

        if isinstance(mainvars, string_types):

            mainvars = set(splitstrip(mainvars))

        elif not isinstance(mainvars, set):

            mainvars = set(mainvars)

        self.mainvars = mainvars

        self.expression = normalize_expression(expression)

        try:

            # syntax tree used by read security (inserted in queries when necessary)

            self.snippet_rqlst = self._cached_parse(self.minimal_rql)

        except RQLSyntaxError:

            raise RQLSyntaxError(expression)

        for mainvar in mainvars:

            if len(self.snippet_rqlst.defined_vars[mainvar].references()) < 2:

                _LOGGER.warn('You did not use the %s variable in your RQL '

                             'expression %s', mainvar, self)

        # graph of links between variables, used by rql rewriter

        self.vargraph = vargraph(self.snippet_rqlst)

        # useful for some instrumentation, e.g. localperms permcheck command

        self.package = ybo.PACKAGE

    def __str__(self):

        return self.rqlst.as_string()

    def __repr__(self):

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

    def __lt__(self, other):

        if hasattr(other, 'expression'):

            return self.expression < other.expression

        return True

    def __eq__(self, other):

        if hasattr(other, 'expression'):

            return self.expression == other.expression

        return False

    def __ne__(self, other):

        return not (self == other)

    def __hash__(self):

        return hash(self.expression)

    def __deepcopy__(self, memo):

        return self.__class__(self.expression, self.mainvars)

    def __getstate__(self):

        return (self.expression, self.mainvars)

    def __setstate__(self, state):

        self.__init__(*state)

    @cachedproperty

    def rqlst(self):

        # Don't use _cached_parse here because the rqlst is modified

        select = parse(self.minimal_rql, print_errors=False).children[0]

        defined = set(split_expression(self.expression))

        for varname in self.predefined_variables:

            if varname in defined:

                select.add_eid_restriction(select.get_variable(varname), varname.lower(),

                                           'Substitute')

        return select

    # permission rql expression specific stuff #################################

    @cached

    def transform_has_permission(self):

        found = None

        rqlst = self.rqlst

        for var in rqlst.defined_vars.values():

            for varref in var.references():

                rel = varref.relation()

                if rel is None:

                    continue

                try:

                    prefix, action, suffix = rel.r_type.split('_')

                except ValueError:

                    continue

                if (prefix != 'has' or suffix != 'permission'

                        or action not in ('add', 'delete', 'update', 'read')):

                    continue

                if found is None:

                    found = []

                    rqlst.save_state()

                assert rel.children[0].name == 'U'

                objvar = rel.children[1].children[0].variable

                rqlst.remove_node(rel)

                selected = [v.name for v in rqlst.get_selected_variables()]

                if objvar.name not in selected:

                    colindex = len(selected)

                    rqlst.add_selected(objvar)

                else:

                    colindex = selected.index(objvar.name)

                found.append((action, colindex))

                # remove U eid %(u)s if U is not used in any other relation

                uvrefs = rqlst.defined_vars['U'].references()

                if len(uvrefs) == 1:

                    rqlst.remove_node(uvrefs[0].relation())

        if found is not None:

            rql = rqlst.as_string()

            if len(rqlst.selection) == 1 and isinstance(rqlst.where, nodes.Relation):

                # only "Any X WHERE X eid %(x)s" remaining, no need to execute the rql

                keyarg = rqlst.selection[0].name.lower()

            else:

                keyarg = None

            rqlst.recover()

            return rql, found, keyarg

        rqlst.where = nodes.Exists(rqlst.where)

        return rqlst.as_string(), None, None

    def _check(self, _cw, **kwargs):

        """return True if the rql expression is matching the given relation

        between fromeid and toeid

        _cw may be a request or a server side transaction

        """

        creating = kwargs.get('creating')

        if not creating and self.eid is not None:

            key = (self.eid, tuple(sorted(kwargs.items())))

            try:

                return _cw.local_perm_cache[key]

            except KeyError:

                pass

        rql, has_perm_defs, keyarg = self.transform_has_permission()

        # when creating an entity, expression related to X satisfied

        if creating and 'X' in self.snippet_rqlst.defined_vars:

            return True

        if keyarg is None:

            kwargs.setdefault('u', _cw.user.eid)

            try:

                # ensure security is disabled

                with getattr(_cw, 'cnx', _cw).security_enabled(read=False):

                    rset = _cw.execute(rql, kwargs, build_descr=True)

            except NotImplementedError:

                self.critical('cant check rql expression, unsupported rql %s', rql)

                if self.eid is not None:

                    _cw.local_perm_cache[key] = False

                return False

            except TypeResolverException as ex:

                # some expression may not be resolvable with current kwargs

                # (type conflict)

                self.warning('%s: %s', rql, str(ex))

                if self.eid is not None:

                    _cw.local_perm_cache[key] = False

                return False

            except Unauthorized as ex:

                self.debug('unauthorized %s: %s', rql, str(ex))

                if self.eid is not None:

                    _cw.local_perm_cache[key] = False

                return False

        else: