"""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-2008 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr

"""

__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.server import schemaserial as ss

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

from cubicweb.server.hookhelper import (entity_attr, entity_name,

                                     check_internal_entity)

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

CORE_ETYPES = list(BASE_TYPES) + ['EEType', 'ERType', 'EUser', 'EGroup',

                                  'EConstraint', 'EFRDef', 'ENFRDef']

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

               '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.query_data(entity.eid, ()):

        cstrent = session.entity(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"""

    try:

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

                               % (etype, rtype)))

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

    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', etype, rtype)

    # 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, etype, rtype)

    session.info('added index on %s(%s)', etype, rtype)

    session.add_query_data('createdattrs', '%s.%s' % (etype, rtype))

class SchemaOperation(Operation):

    """base class for schema operations"""

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

        self.schema = session.repo.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

        UpdateSchemaOp(session)

class EarlySchemaOperation(SchemaOperation):

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

                return i

        return i + 1

class UpdateSchemaOp(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 commit_event(self):

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

class DropTableOp(PreCommitOperation):

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

    def precommit_event(self):

        dropped = self.session.query_data('droppedtables',

                                          default=set(), setdefault=True)

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

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

    database

    """

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

            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)

# deletion ####################################################################

class DeleteEETypeOp(SchemaOperation):

    """actually remove the entity type from the application's schema"""    

    def commit_event(self):

        try:

            # del_entity_type also removes entity's relations

            self.schema.del_entity_type(self.kobj)

        except KeyError:

            # s/o entity type have already been deleted

            pass

def before_del_eetype(session, eid):

    """before deleting a EEType entity:

    * check that we don't remove a core entity type

    * cascade to delete related EFRDef and ENFRDef entities

    * instantiate an operation to delete the entity type on commit

    """

    # final entities can't be deleted, don't care about that

    name = check_internal_entity(session, eid, CORE_ETYPES)

    # delete every entities of this type

    session.unsafe_execute('DELETE %s X' % name)

    DropTableOp(session, table=name)

    DeleteEETypeOp(session, name)

def after_del_eetype(session, eid):

    # workflow cleanup

    session.execute('DELETE State X WHERE NOT X state_of Y')

    session.execute('DELETE Transition X WHERE NOT X transition_of Y')

class DeleteERTypeOp(SchemaOperation):

    """actually remove the relation type from the application's schema"""    

    def commit_event(self):

        try:

            self.schema.del_relation_type(self.kobj)

        except KeyError:

            # s/o entity type have already been deleted

            pass

def before_del_ertype(session, eid):

    """before deleting a ERType entity:

    * check that we don't remove a core relation type

    * cascade to delete related EFRDef and ENFRDef entities

    * instantiate an operation to delete the relation type on commit

    """

    name = check_internal_entity(session, eid, CORE_RTYPES)

    # delete relation definitions using this relation type

    session.execute('DELETE EFRDef X WHERE X relation_type Y, Y eid %(x)s',

                    {'x': eid})

    session.execute('DELETE ENFRDef X WHERE X relation_type Y, Y eid %(x)s',

                    {'x': eid})

    DeleteERTypeOp(session, name)

class DelErdefOp(SchemaOperation):

    """actually remove the relation definition from the application's schema"""

    def commit_event(self):

        subjtype, rtype, objtype = self.kobj

        try:

            self.schema.del_relation_def(subjtype, rtype, objtype)

        except KeyError:

            # relation type may have been already deleted

            pass

def after_del_relation_type(session, rdefeid, rtype, rteid):

    """before deleting a EFRDef or ENFRDef entity:

    * if this is a final or inlined relation definition, instantiate an

      operation to drop necessary column, else if this is the last instance

      of a non final relation, instantiate an operation to drop necessary

      table

    * instantiate an operation to delete the relation definition on commit

    * delete the associated relation type when necessary

    """

    subjschema, rschema, objschema = session.repo.schema.schema_by_eid(rdefeid)

    pendings = session.query_data('pendingeids', ())

    # first delete existing relation if necessary

    if rschema.is_final():

        rdeftype = 'EFRDef'

    else:

        rdeftype = 'ENFRDef'

        if not (subjschema.eid in pendings or objschema.eid in pendings):

            session.execute('DELETE X %s Y WHERE X is %s, Y is %s'

                            % (rschema, subjschema, objschema))

    execute = session.unsafe_execute

    rset = execute('Any COUNT(X) WHERE X is %s, X relation_type R,'

                   'R eid %%(x)s' % rdeftype, {'x': rteid})

    lastrel = rset[0][0] == 0

    # we have to update physical schema systematically for final and inlined

    # relations, but only if it's the last instance for this relation type

    # for other relations

    if (rschema.is_final() or rschema.inlined):

        rset = execute('Any COUNT(X) WHERE X is %s, X relation_type R, '

                       'R eid %%(x)s, X from_entity E, E name %%(name)s'

                       % rdeftype, {'x': rteid, 'name': str(subjschema)})

        if rset[0][0] == 0 and not subjschema.eid in pendings:

            DropColumnOp(session, table=subjschema.type, column=rschema.type)

    elif lastrel:

        DropTableOp(session, table='%s_relation' % rschema.type)

    # if this is the last instance, drop associated relation type

    if lastrel and not rteid in pendings:

        execute('DELETE ERType X WHERE X eid %(x)s', {'x': rteid}, 'x')

    DelErdefOp(session, (subjschema, rschema, objschema))

# addition ####################################################################

class AddEETypeOp(EarlySchemaOperation):

    """actually add the entity type to the application's schema"""    

    def commit_event(self):

        eschema = self.schema.add_entity_type(self.kobj)

        eschema.eid = self.eid

def before_add_eetype(session, entity):

    """before adding a EEType entity:

    * check that we are not using an existing entity type,

    """

    name = entity['name']

    schema = session.repo.schema

    if name in schema and schema[name].eid is not None:

        raise RepositoryError('an entity type %s already exists' % name)

def after_add_eetype(session, entity):

    """after adding a EEType entity:

    * create the necessary table

    * set creation_date and modification_date by creating the necessary

      EFRDef entities

    * add owned_by relation by creating the necessary ENFRDef entity

    * register an operation to add the entity type to the application's

      schema on commit

    """

    if entity.get('final'):

        return

    schema = session.repo.schema

    name = entity['name']

    etype = EntityType(name=name, description=entity.get('description'),

                       meta=entity.get('meta')) # don't care about final

    # fake we add it to the schema now to get a correctly initialized schema

    # but remove it before doing anything more dangerous...

    schema = session.repo.schema

    eschema = schema.add_entity_type(etype)

    eschema.set_default_groups()

    # generate table sql and rql to add metadata

    tablesql = eschema2sql(session.pool.source('system').dbhelper, eschema)

    relrqls = []

    for rtype in ('is', 'is_instance_of', 'creation_date', 'modification_date',

                  'created_by', 'owned_by'):

        rschema = schema[rtype]

        sampletype = rschema.subjects()[0]

        desttype = rschema.objects()[0]

        props = rschema.rproperties(sampletype, desttype)

        relrqls += list(ss.rdef2rql(rschema, name, desttype, props))

    # now remove it !

    schema.del_entity_type(name)

    # create the necessary table

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

        if sql.strip():

            session.system_sql(sql)

    # register operation to modify the schema on commit

    # this have to be done before adding other relations definitions

    # or permission settings

    AddEETypeOp(session, etype, eid=entity.eid)

    # add meta creation_date, modification_date and owned_by relations

    for rql, kwargs in relrqls:

        session.execute(rql, kwargs)

class AddERTypeOp(EarlySchemaOperation):

    """actually add the relation type to the application's schema"""    

    def commit_event(self):

        rschema = self.schema.add_relation_type(self.kobj)

        rschema.set_default_groups()

        rschema.eid = self.eid

def before_add_ertype(session, entity):

    """before adding a ERType entity:

    * check that we are not using an existing relation type,

    * register an operation to add the relation type to the application's

      schema on commit

    We don't know yeat this point if a table is necessary

    """

    name = entity['name']

    if name in session.repo.schema.relations():

        raise RepositoryError('a relation type %s already exists' % name)

def after_add_ertype(session, entity):

    """after a ERType entity has been added:

    * register an operation to add the relation type to the application's

      schema on commit

    We don't know yeat this point if a table is necessary

    """

    AddERTypeOp(session, RelationType(name=entity['name'],

                                      description=entity.get('description'),

                                      meta=entity.get('meta', False),

                                      inlined=entity.get('inlined', False),

                                      symetric=entity.get('symetric', False)),

                eid=entity.eid)

class AddErdefOp(EarlySchemaOperation):

    """actually add the attribute relation definition to the application's

    schema

    """    

    def commit_event(self):

        self.schema.add_relation_def(self.kobj)