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

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

from yams.schema import BASE_TYPES

from yams.buildobjs import EntityType, RelationType, RelationDefinition

from yams.schema2sql import eschema2sql, rschema2sql, type_from_constraints

from logilab.common.decorators import clear_cache

from cubicweb import ValidationError, RepositoryError

from cubicweb.schema import META_RTYPES, VIRTUAL_RTYPES, CONSTRAINTS

from cubicweb.server import schemaserial as ss

from cubicweb.server.sqlutils import SQL_PREFIX

from cubicweb.server.pool import Operation, SingleLastOperation, PreCommitOperation

from cubicweb.server.hookhelper import entity_oldnewvalue, check_internal_entity

TYPE_CONVERTER = { # XXX

    'Boolean': bool,

    'Int': int,

    'Float': float,

    'Password': str,

    'String': unicode,

    'Date' : unicode,

    'Datetime' : unicode,

    'Time' : unicode,

    }

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

CORE_ETYPES = list(BASE_TYPES) + ['CWEType', 'CWRType', 'CWUser', 'CWGroup',

                                  'CWConstraint', 'CWAttribute', 'CWRelation']

CORE_RTYPES = ['eid', 'creation_date', 'modification_date', 'cwuri',

               'login', 'upassword', 'name',

               'is', 'instanceof', 'owned_by', 'created_by', 'in_group',

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

               'constrainted_by',

               'read_permission', 'add_permission',

               'delete_permission', 'updated_permission',

               ]

def get_constraints(session, entity):

    constraints = []

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

        cstrent = session.entity_from_eid(cstreid)

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

        cstr.eid = cstreid

        constraints.append(cstr)

    return constraints

def add_inline_relation_column(session, etype, rtype):

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

    table = SQL_PREFIX + etype

    column = SQL_PREFIX + rtype

    try:

        session.system_sql(str('ALTER TABLE %s ADD COLUMN %s integer'

                               % (table, column)), rollback_on_failure=False)

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

    except:

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

        # column already exists, index creation will fail anyway

        session.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)

    session.pool.source('system').create_index(session, table, column)

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

    session.transaction_data.setdefault('createdattrs', []).append(

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

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

class DropTable(PreCommitOperation):

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

    table = None # make pylint happy

    def precommit_event(self):

        dropped = self.session.transaction_data.setdefault('droppedtables',

                                                           set())

        if self.table in dropped:

            return # already processed

        dropped.add(self.table)

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

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

class DropRelationTable(DropTable):

    def __init__(self, session, rtype):

        super(DropRelationTable, self).__init__(

            session, table='%s_relation' % rtype)

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

class DropColumn(PreCommitOperation):

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

    database

    """

    table = column = None # make pylint happy

    def precommit_event(self):

        session, table, column = self.session, self.table, self.column

        # drop index if any

        session.pool.source('system').drop_index(session, table, column)

        try:

            session.system_sql('ALTER TABLE %s DROP COLUMN %s'

                               % (table, column), rollback_on_failure=False)

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

        except Exception, ex:

            # not supported by sqlite for instance

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

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

class MemSchemaNotifyChanges(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, session):

        self.repo = session.repo

        SingleLastOperation.__init__(self, session)

    def precommit_event(self):

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

            if not eschema.final:

                clear_cache(eschema, 'ordered_relations')

    def commit_event(self):

        rebuildinfered = self.session.data.get('rebuild-infered', True)

        self.repo.set_schema(self.repo.schema, rebuildinfered=rebuildinfered)

        # CWUser class might have changed, update current session users

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

        for session in self.repo._sessions.values():

            session.user.__class__ = cwuser_cls

    def rollback_event(self):

        self.precommit_event()

class MemSchemaOperation(Operation):

    """base class for schema operations"""

    def __init__(self, session, kobj=None, **kwargs):

        self.schema = session.schema

        self.kobj = kobj

        # once Operation.__init__ has been called, event may be triggered, so

        # do this last !

        Operation.__init__(self, session, **kwargs)

        # every schema operation is triggering a schema update

        MemSchemaNotifyChanges(session)

    def prepare_constraints(self, subjtype, rtype, objtype):

        constraints = rtype.rproperty(subjtype, objtype, 'constraints')

        self.constraints = list(constraints)

        rtype.set_rproperty(subjtype, objtype, 'constraints', self.constraints)

class MemSchemaEarlyOperation(MemSchemaOperation):

    def insert_index(self):

        """schema operation which are inserted at the begining of the queue

        (typically to add/remove entity or relation types)

        """

        i = -1

        for i, op in enumerate(self.session.pending_operations):

            if not isinstance(op, MemSchemaEarlyOperation):

                return i

        return i + 1

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

class SourceDbCWETypeRename(PreCommitOperation):

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

    oldname = newname = None # make pylint happy

    def precommit_event(self):

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

        sqlexec = self.session.system_sql

        sqlexec('ALTER TABLE %s%s RENAME TO %s%s' % (SQL_PREFIX, self.oldname,

                                                     SQL_PREFIX, self.newname))

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

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

                (self.newname, self.oldname))

        sqlexec('UPDATE deleted_entities SET type=%s WHERE type=%s',

                (self.newname, self.oldname))

class SourceDbCWRTypeUpdate(PreCommitOperation):

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

    rschema = values = entity = None # make pylint happy

    def precommit_event(self):

        session = self.session

        rschema = self.rschema

        if rschema.final or not 'inlined' in self.values:

            return # nothing to do

        inlined = self.values['inlined']

        entity = self.entity

        # check in-lining is necessary / possible

        if not entity.inlined_changed(inlined):

            return # nothing to do

        # inlined changed, make necessary physical changes!

        sqlexec = self.session.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 session.transaction_data.get('createdtables', ()):

                tablesql = rschema2sql(rschema)

                # create the necessary table

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

                    if sql.strip():

                        sqlexec(sql)

                session.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

            for etype in rschema.subjects():

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

                             column=SQL_PREFIX + rtype)

        else:

            for etype in rschema.subjects():

                try:

                    add_inline_relation_column(session, str(etype), rtype)

                except Exception, 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

                    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)

                #sqlexec('UPDATE %(etype)s SET %(rtype)s=eid_to '

                #        'FROM %(rtype)s_relation '

                #        'WHERE %(etype)s.eid=%(rtype)s_relation.eid_from'

                #        % locals())

                table = SQL_PREFIX + str(etype)

                cursor = sqlexec('SELECT eid_from, eid_to FROM %(table)s, '

                                 '%(rtype)s_relation WHERE %(table)s.%(eidcolumn)s='

                                 '%(rtype)s_relation.eid_from' % locals())

                args = [{'val': eid_to, 'x': eid} for eid, eid_to in cursor.fetchall()]

                if args:

                    column = SQL_PREFIX + rtype

                    cursor.executemany('UPDATE %s SET %s=%%(val)s WHERE %s=%%(x)s'

                                       % (table, column, eidcolumn), args)

                # drop existant table

                DropRelationTable(session, rtype)

class SourceDbCWAttributeAdd(PreCommitOperation):

    """an attribute relation (CWAttribute) has been added:

    * add the necessary column

    * set default on this column if any and possible

    * register an operation to add the relation definition to the

      instance's schema on commit

    constraints are handled by specific hooks

    """

    entity = None # make pylint happy

    def init_rdef(self, **kwargs):

        entity = self.entity

        fromentity = entity.stype

        self.session.execute('SET X ordernum Y+1 '

                             'WHERE X from_entity SE, SE eid %(se)s, X ordernum Y, '

                             'X ordernum >= %(order)s, NOT X eid %(x)s',

                             {'x': entity.eid, 'se': fromentity.eid,

                              'order': entity.ordernum or 0})

        subj = str(fromentity.name)

        rtype = entity.rtype.name

        obj = str(entity.otype.name)

        constraints = get_constraints(self.session, entity)

        rdef = RelationDefinition(subj, rtype, obj,

                                  description=entity.description,

                                  cardinality=entity.cardinality,

                                  constraints=constraints,

                                  order=entity.ordernum,

                                  eid=entity.eid,

                                  **kwargs)

        MemSchemaRDefAdd(self.session, rdef)

        return rdef

    def precommit_event(self):

        session = self.session

        entity = self.entity

        # entity.defaultval is a string or None, but we need a correctly typed

        # value

        default = entity.defaultval

        if default is not None:

            default = TYPE_CONVERTER[entity.otype.name](default)

        props = {'default': default,

                 'indexed': entity.indexed,

                 'fulltextindexed': entity.fulltextindexed,

                 'internationalizable': entity.internationalizable}

        rdef = self.init_rdef(**props)

        sysource = session.pool.source('system')

        attrtype = type_from_constraints(sysource.dbhelper, rdef.object,

                                         rdef.constraints)

        # XXX should be moved somehow into lgc.adbh: sqlite doesn't support to

        # add a new column with UNIQUE, it should be added after the ALTER TABLE

        # using ADD INDEX

        if sysource.dbdriver == 'sqlite' and 'UNIQUE' in attrtype:

            extra_unique_index = True

            attrtype = attrtype.replace(' UNIQUE', '')

        else:

            extra_unique_index = False

        # added some str() wrapping query since some backend (eg psycopg) don't

        # allow unicode queries

        table = SQL_PREFIX + rdef.subject

        column = SQL_PREFIX + rdef.name

        try:

            session.system_sql(str('ALTER TABLE %s ADD COLUMN %s %s'

                                   % (table, column, attrtype)),

                               rollback_on_failure=False)

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

        except Exception, 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

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

        if extra_unique_index or entity.indexed:

            try:

                sysource.create_index(session, table, column,

                                      unique=extra_unique_index)

            except Exception, ex:

                self.error('error while creating index for %s.%s: %s',

                           table, column, ex)

        # final relations are not infered, propagate

        try:

            eschema = self.schema.eschema(rdef.subject)

        except KeyError:

            return # entity type currently being added

        # propagate attribute to children classes

        rschema = self.schema.rschema(rdef.name)

        # if relation type has been inserted in the same transaction, its final

        # attribute is still set to False, so we've to ensure it's False

        rschema.final = True

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

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

                      'description': rdef.description,

                      'cardinality': rdef.cardinality,

                      'constraints': rdef.constraints,

                      'order': rdef.order})

        for specialization in eschema.specialized_by(False):

            if rschema.has_rdef(specialization, rdef.object):

                continue

            for rql, args in ss.frdef2rql(rschema, str(specialization),

                                          rdef.object, props):

                session.execute(rql, args)

        # set default value, using sql for performance and to avoid

        # modification_date update

        if default:

            session.system_sql('UPDATE %s SET %s=%%(default)s' % (table, column),

                               {'default': default})