# copyright 2003-2014 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

"""

__docformat__ = "restructuredtext en"

_ = unicode

from copy import copy

from yams.schema import (BASE_TYPES, BadSchemaDefinition,

                         RelationSchema, RelationDefinitionSchema)

from yams import buildobjs as ybo, convert_default_value

from logilab.common.decorators import clear_cache

from cubicweb import validation_error

from cubicweb.predicates import is_instance

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

                             CONSTRAINTS, ETYPE_NAME_MAP, display_name)

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.Operation):

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

    database

    """

    table = column = None # make pylint happy

    def precommit_event(self):

        cnx, table, column = self.cnx, self.table, self.column

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

    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)

            # CWUser class might have changed, update current session users

            cwuser_cls = self.cnx.vreg['etypes'].etype_class('CWUser')

            for session in repo._sessions.itervalues():

                session.user.__class__ = cwuser_cls

        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

        tablesql = y2sql.eschema2sql(cnx.repo.system_source.dbhelper,

                                     eschema, prefix=SQL_PREFIX)

        for sql in tablesql.split(';'):

            if sql.strip():

                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):

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

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

        sqlexec = self.cnx.system_sql

        dbhelper = self.cnx.repo.system_source.dbhelper

        sql = dbhelper.sql_rename_table(SQL_PREFIX+oldname,

                                        SQL_PREFIX+newname)

        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, extid, auri) in self.cnx.repo._type_source_cache.items():

            if etype == oldname:

                self.cnx.repo._type_source_cache[eid] = (newname, extid, auri)

        # 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:

                op.add_data(subjtype)

                op.add_data(objtype)

        # 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 not 'inlined' in self.values:

            return # nothing to do

        inlined = self.values['inlined']

        # check in-lining is possible when inlined

        if inlined:

            self.entity.check_inlined_allowed()

        # inlined changed, make necessary physical changes!

        sqlexec = self.cnx.system_sql

        rtype = rschema.type

        eidcolumn = SQL_PREFIX + 'eid'

        if not inlined:

            # need to create the relation if it has not been already done by

            # another event of the same transaction

            if not rschema.type in cnx.transaction_data.get('createdtables', ()):

                tablesql = y2sql.rschema2sql(rschema)

                # create the necessary table

                for sql in tablesql.split(';'):

                    if sql.strip():

                        sqlexec(sql)

                cnx.transaction_data.setdefault('createdtables', []).append(

                    rschema.type)

            # copy existant data

            column = SQL_PREFIX + rtype

            for etype in rschema.subjects():

                table = SQL_PREFIX + str(etype)

                sqlexec('INSERT INTO %s_relation SELECT %s, %s FROM %s WHERE NOT %s IS NULL'

                        % (rtype, eidcolumn, column, table, column))

            # drop existant columns

            #if cnx.repo.system_source.dbhelper.alter_column_support:

            for etype in rschema.subjects():

                DropColumn(cnx, table=SQL_PREFIX + str(etype),

                           column=SQL_PREFIX + rtype)

        else:

            for etype in rschema.subjects():

                try:

                    add_inline_relation_column(cnx, str(etype), rtype)

                except Exception as ex:

                    # the column probably already exists. this occurs when the

                    # entity's type has just been added or if the column has not

                    # been previously dropped (eg sqlite)

                    self.error('error while altering table %s: %s', etype, ex)

                # copy existant data.

                # XXX don't use, it's not supported by sqlite (at least at when i tried it)