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

"""schema hooks:

- synchronize the living schema object with the persistent schema

- perform physical update on the source when necessary

checking for schema consistency is done in hooks.py

"""

import json

from copy import copy

from yams.schema import BASE_TYPES, BadSchemaDefinition, RelationDefinitionSchema

from yams.constraints import UniqueConstraint

from yams import buildobjs as ybo, convert_default_value

from logilab.common.decorators import clear_cache

from cubicweb import _

from cubicweb import validation_error

from cubicweb.predicates import is_instance

from cubicweb.schema import (SCHEMA_TYPES, META_RTYPES, VIRTUAL_RTYPES,

                             CONSTRAINTS, UNIQUE_CONSTRAINTS, ETYPE_NAME_MAP)

from cubicweb.server import hook, schemaserial as ss, schema2sql as y2sql

from cubicweb.server.sqlutils import SQL_PREFIX

from cubicweb.hooks.synccomputed import RecomputeAttributeOperation

# core entity and relation types which can't be removed

CORE_TYPES = BASE_TYPES | SCHEMA_TYPES | META_RTYPES | set(

    ('CWUser', 'CWGroup', 'login', 'upassword', 'name', 'in_group'))

def get_constraints(cnx, entity):

    constraints = []

    for cstreid in cnx.transaction_data.get(entity.eid, ()):

        cstrent = cnx.entity_from_eid(cstreid)

        cstr = CONSTRAINTS[cstrent.type].deserialize(cstrent.value)

        cstr.eid = cstreid

        constraints.append(cstr)

    return constraints

def group_mapping(cw):

    try:

        return cw.transaction_data['groupmap']

    except KeyError:

        cw.transaction_data['groupmap'] = gmap = ss.group_mapping(cw)

        return gmap

def add_inline_relation_column(cnx, etype, rtype):

    """add necessary column and index for an inlined relation"""

    attrkey = '%s.%s' % (etype, rtype)

    createdattrs = cnx.transaction_data.setdefault('createdattrs', set())

    if attrkey in createdattrs:

        return

    createdattrs.add(attrkey)

    table = SQL_PREFIX + etype

    column = SQL_PREFIX + rtype

    try:

        cnx.system_sql(str('ALTER TABLE %s ADD %s integer REFERENCES entities (eid)'

                           % (table, column)),

                       rollback_on_failure=False)

        cnx.info('added column %s to table %s', column, table)

    except Exception:

        # silent exception here, if this error has not been raised because the

        # column already exists, index creation will fail anyway

        cnx.exception('error while adding column %s to table %s',

                      table, column)

    # create index before alter table which may expectingly fail during test

    # (sqlite) while index creation should never fail (test for index existence

    # is done by the dbhelper)

    cnx.repo.system_source.create_index(cnx, table, column)

    cnx.info('added index on %s(%s)', table, column)

def insert_rdef_on_subclasses(cnx, eschema, rschema, rdefdef, props):

    # XXX 'infered': True/False, not clear actually

    props.update({'constraints': rdefdef.constraints,

                  'description': rdefdef.description,

                  'cardinality': rdefdef.cardinality,

                  'permissions': rdefdef.get_permissions(),

                  'order': rdefdef.order,

                  'infered': False, 'eid': None

                  })

    cstrtypemap = ss.cstrtype_mapping(cnx)

    groupmap = group_mapping(cnx)

    object = rschema.schema.eschema(rdefdef.object)

    for specialization in eschema.specialized_by(False):

        if (specialization, rdefdef.object) in rschema.rdefs:

            continue

        sperdef = RelationDefinitionSchema(specialization, rschema,

                                           object, None, values=props)

        ss.execschemarql(cnx.execute, sperdef,

                         ss.rdef2rql(sperdef, cstrtypemap, groupmap))

def check_valid_changes(cnx, entity, ro_attrs=('name', 'final')):

    errors = {}

    # don't use getattr(entity, attr), we would get the modified value if any

    for attr in entity.cw_edited:

        if attr in ro_attrs:

            origval, newval = entity.cw_edited.oldnewvalue(attr)

            if newval != origval:

                errors[attr] = _("can't change this attribute")

    if errors:

        raise validation_error(entity, errors)

class _MockEntity(object):  # XXX use a named tuple with python 2.6

    def __init__(self, eid):

        self.eid = eid

class SyncSchemaHook(hook.Hook):

    """abstract class for schema synchronization hooks (in the `syncschema`

    category)

    """

    __abstract__ = True

    category = 'syncschema'

# operations for low-level database alteration  ################################

class DropTable(hook.Operation):

    """actually remove a database from the instance's schema"""

    table = None  # make pylint happy

    def precommit_event(self):

        dropped = self.cnx.transaction_data.setdefault('droppedtables', set())

        if self.table in dropped:

            return  # already processed

        dropped.add(self.table)

        self.cnx.system_sql('DROP TABLE %s' % self.table)

        self.info('dropped table %s', self.table)

    # XXX revertprecommit_event

class DropRelationTable(DropTable):

    def __init__(self, cnx, rtype):

        super(DropRelationTable, self).__init__(

            cnx, table='%s_relation' % rtype)

        cnx.transaction_data.setdefault('pendingrtypes', set()).add(rtype)

class DropColumn(hook.DataOperationMixIn, hook.Operation):

    """actually remove the attribut's column from entity table in the system

    database

    """

    def precommit_event(self):

        cnx = self.cnx

        for etype, attr in self.get_data():

            table = SQL_PREFIX + etype

            column = SQL_PREFIX + attr

            source = cnx.repo.system_source

            # drop index if any

            source.drop_index(cnx, table, column)

            if source.dbhelper.alter_column_support:

                cnx.system_sql('ALTER TABLE %s DROP COLUMN %s' % (table, column),

                               rollback_on_failure=False)

                self.info('dropped column %s from table %s', column, table)

            else:

                # not supported by sqlite for instance

                self.error('dropping column not supported by the backend, handle '

                           'it yourself (%s.%s)', table, column)

    # XXX revertprecommit_event

# base operations for in-memory schema synchronization  ########################

class MemSchemaNotifyChanges(hook.SingleLastOperation):

    """the update schema operation:

    special operation which should be called once and after all other schema

    operations. It will trigger internal structures rebuilding to consider

    schema changes.

    """

    def __init__(self, cnx):

        hook.SingleLastOperation.__init__(self, cnx)

    def precommit_event(self):

        for eschema in self.cnx.repo.schema.entities():

            if not eschema.final:

                clear_cache(eschema, 'ordered_relations')

                # clear additional cached properties

                try:

                    # is_composite use composite_rdef_roles, hence one try except should be enough

                    del eschema.composite_rdef_roles

                    del eschema.is_composite

                except AttributeError:

                    pass

    def postcommit_event(self):

        repo = self.cnx.repo

        # commit event should not raise error, while set_schema has chances to

        # do so because it triggers full vreg reloading

        try:

            repo.schema.rebuild_infered_relations()

            # trigger vreg reload

            repo.set_schema(repo.schema)

        except Exception:

            self.critical('error while setting schema', exc_info=True)

    def rollback_event(self):

        self.precommit_event()

class MemSchemaOperation(hook.Operation):

    """base class for schema operations"""

    def __init__(self, cnx, **kwargs):

        hook.Operation.__init__(self, cnx, **kwargs)

        # every schema operation is triggering a schema update

        MemSchemaNotifyChanges(cnx)

# operations for high-level source database alteration  ########################

class CWETypeAddOp(MemSchemaOperation):

    """after adding a CWEType entity:

    * add it to the instance's schema

    * create the necessary table

    * set creation_date and modification_date by creating the necessary

      CWAttribute entities

    * add <meta rtype> relation by creating the necessary CWRelation entity

    """

    entity = None  # make pylint happy

    def precommit_event(self):

        cnx = self.cnx

        entity = self.entity

        schema = cnx.vreg.schema

        etype = ybo.EntityType(eid=entity.eid, name=entity.name,

                               description=entity.description)

        eschema = schema.add_entity_type(etype)

        # create the necessary table

        for sql in y2sql.eschema2sql(cnx.repo.system_source.dbhelper,

                                     eschema, prefix=SQL_PREFIX):

            cnx.system_sql(sql)

        # add meta relations

        gmap = group_mapping(cnx)

        cmap = ss.cstrtype_mapping(cnx)

        for rtype in (META_RTYPES - VIRTUAL_RTYPES):

            try:

                rschema = schema[rtype]

            except KeyError:

                self.critical('rtype %s was not handled at cwetype creation time', rtype)

                continue

            if not rschema.rdefs:

                self.warning('rtype %s has no relation definition yet', rtype)

                continue

            sampletype = rschema.subjects()[0]

            desttype = rschema.objects()[0]

            try:

                rdef = copy(rschema.rdef(sampletype, desttype))

            except KeyError:

                # this combo does not exist because this is not a universal META_RTYPE

                continue

            rdef.subject = _MockEntity(eid=entity.eid)

            mock = _MockEntity(eid=None)

            ss.execschemarql(cnx.execute, mock, ss.rdef2rql(rdef, cmap, gmap))

    def revertprecommit_event(self):

        # revert changes on in memory schema

        self.cnx.vreg.schema.del_entity_type(self.entity.name)

        # revert changes on database

        self.cnx.system_sql('DROP TABLE %s%s' % (SQL_PREFIX, self.entity.name))

class CWETypeRenameOp(MemSchemaOperation):

    """this operation updates physical storage accordingly"""

    oldname = newname = None  # make pylint happy

    def rename(self, oldname, newname):

        cnx = self.cnx

        source = cnx.repo.system_source

        dbhelper = source.dbhelper

        # we need sql to operate physical changes on the system database

        sqlexec = cnx.system_sql

        cnx.vreg.schema.rename_entity_type(oldname, newname)

        old_table = SQL_PREFIX + oldname

        new_table = SQL_PREFIX + newname

        eschema = cnx.vreg.schema.eschema(newname)

        # drop old indexes before the renaming

        for rschema in eschema.subject_relations():

            if rschema.inlined or (rschema.final and eschema.rdef(rschema.type).indexed):

                source.drop_index(cnx, old_table, SQL_PREFIX + rschema.type)

            if rschema.final and any(isinstance(cstr, UniqueConstraint)

                                     for cstr in eschema.rdef(rschema.type).constraints):

                source.drop_index(cnx, old_table, SQL_PREFIX + rschema.type, unique=True)

        sql = dbhelper.sql_rename_table(old_table, new_table)

        sqlexec(sql)

        self.info('renamed table %s to %s', oldname, newname)

        sqlexec('UPDATE entities SET type=%(newname)s WHERE type=%(oldname)s',

                {'newname': newname, 'oldname': oldname})

        for eid, etype in cnx.repo._type_cache.items():

            if etype == oldname:

                cnx.repo._type_cache[eid] = newname

        # recreate the indexes

        for rschema in eschema.subject_relations():

            if rschema.inlined or (rschema.final and eschema.rdef(rschema.type).indexed):

                source.create_index(cnx, new_table, SQL_PREFIX + rschema.type)

            if rschema.final and any(isinstance(cstr, UniqueConstraint)

                                     for cstr in eschema.rdef(rschema.type).constraints):

                source.create_index(cnx, new_table, SQL_PREFIX + rschema.type, unique=True)

        for attrs in eschema._unique_together or ():

            columns = ['%s%s' % (SQL_PREFIX, attr) for attr in attrs]

            old_index_name = y2sql.unique_index_name(oldname, columns)

            for sql in dbhelper.sqls_drop_multicol_unique_index(

                    new_table, columns, old_index_name):

                sqlexec(sql)

            new_index_name = y2sql.unique_index_name(newname, columns)

            for sql in dbhelper.sqls_create_multicol_unique_index(

                    new_table, columns, new_index_name):

                sqlexec(sql)

        # XXX transaction records

    def precommit_event(self):

        self.rename(self.oldname, self.newname)

    def revertprecommit_event(self):

        self.rename(self.newname, self.oldname)

class CWRTypeUpdateOp(MemSchemaOperation):

    """actually update some properties of a relation definition"""

    rschema = entity = values = None  # make pylint happy

    oldvalues = None

    def precommit_event(self):

        rschema = self.rschema

        if rschema.final:

            return  # watched changes to final relation type are unexpected

        cnx = self.cnx

        if 'fulltext_container' in self.values:

            op = UpdateFTIndexOp.get_instance(cnx)

            for subjtype, objtype in rschema.rdefs:

                if self.values['fulltext_container'] == 'subject':

                    op.add_data(subjtype)

                    op.add_data(objtype)

                else:

                    op.add_data(objtype)

                    op.add_data(subjtype)

        # update the in-memory schema first

        self.oldvalues = dict((attr, getattr(rschema, attr)) for attr in self.values)

        self.rschema.__dict__.update(self.values)

        # then make necessary changes to the system source database

        if 'inlined' not in self.values: