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

from copy import copy

from yams.schema import BASE_TYPES, RelationSchema, RelationDefinitionSchema

from yams import buildobjs as ybo, schema2sql as y2sql

from logilab.common.decorators import clear_cache

from logilab.common.testlib import mock_object

from cubicweb import ValidationError

from cubicweb.selectors import implements

from cubicweb.schema import META_RTYPES, VIRTUAL_RTYPES, CONSTRAINTS, display_name

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

        hook.SingleLastOperation.__init__(self, session)

    def precommit_event(self):

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

            if not eschema.final:

                clear_cache(eschema, 'ordered_relations')

    def commit_event(self):

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

        repo = self.session.repo

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

        # do so because it triggers full vreg reloading

        try:

            repo.set_schema(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 repo._sessions.values():

                session.user.__class__ = cwuser_cls

        except:

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

    def rollback_event(self):

        self.precommit_event()

class MemSchemaOperation(hook.Operation):

    """base class for schema operations"""

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

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

        # if constraints is already a list, reuse it (we're updating multiple

        # constraints of the same rdef in the same transactions)

        if not isinstance(rdef.constraints, list):

            rdef.constraints = list(rdef.constraints)

        self.constraints = rdef.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(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 = entity = values = None # make pylint happy

    def precommit_event(self):

        rschema = self.rschema

        if rschema.final:

            return

        session = self.session

        if 'fulltext_container' in self.values:

            ftiupdates = session.transaction_data.setdefault(

                'fti_update_etypes', set())

            for subjtype, objtype in rschema.rdefs:

                ftiupdates.add(subjtype)

                ftiupdates.add(objtype)

            UpdateFTIndexOp(session)

        if not 'inlined' in self.values:

            return # nothing to do

        inlined = self.values['inlined']

        # check in-lining is necessary / possible

        if inlined:

            self.entity.check_inlined_allowed()

        # 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 = y2sql.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 = ybo.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 = y2sql.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