"""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 cubicweb import ValidationError, RepositoryError

from cubicweb.selectors import entity_implements

from cubicweb.schema import META_RTYPES, VIRTUAL_RTYPES, CONSTRAINTS

from cubicweb.server import hook, schemaserial as ss

from cubicweb.server.sqlutils import SQL_PREFIX

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

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

    errors = {}

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

    for attr in entity.edited_attributes:

        if attr in ro_attrs:

            newval = entity.pop(attr)

            origval = getattr(entity, attr)

            if newval != origval:

                errors[attr] = session._("can't change the %s attribute") % \

                               display_name(session, attr)

            entity[attr] = newval

    if errors:

        raise ValidationError(entity.eid, errors)

# 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.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(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):

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

        self.repo = session.repo

        hook.SingleLastOperation.__init__(self, session)

    def commit_event(self):

        self.repo.set_schema(self.repo.schema)

class MemSchemaOperation(hook.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 !

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

class MemSchemaPermOperation(MemSchemaOperation):

    """base class to synchronize schema permission definitions"""

    def __init__(self, session, perm, etype_eid):

        self.perm = perm

        try:

            self.name = session.entity_from_eid(etype_eid).name

        except IndexError:

            self.error('changing permission of a no more existant type #%s',

                etype_eid)

        else:

            hook.Operation.__init__(self, session)

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

class SourceDbCWETypeRename(hook.Operation):

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

    """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.is_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(hook.Operation):

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

        rdef = self.init_rdef(default=default,

                              indexed=entity.indexed,

                              fulltextindexed=entity.fulltextindexed,

                              internationalizable=entity.internationalizable)

        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)

class SourceDbCWRelationAdd(SourceDbCWAttributeAdd):

    """an actual relation has been added:

    * if this is an inlined relation, add the necessary column

      else if it's the first instance of this relation type, add the

      necessary table and set default permissions

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

        session = self.session

        entity = self.entity

        rdef = self.init_rdef(composite=entity.composite)

        schema = session.schema

        rtype = rdef.name

        rschema = session.schema.rschema(rtype)

        # this have to be done before permissions setting