# copyright 2003-2010 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"

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

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_TYPES = BASE_TYPES | SCHEMA_TYPES | META_RTYPES | set(

    ('CWUser', 'CWGroup','login', 'upassword', 'name', 'in_group'))

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

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

    createdattrs = session.transaction_data.setdefault('createdattrs', set())

    if attrkey in createdattrs:

        return

    createdattrs.add(attrkey)

    table = SQL_PREFIX + etype

    column = SQL_PREFIX + rtype

    try:

        session.system_sql(str('ALTER TABLE %s ADD %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)

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

    groupmap = group_mapping(session)

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

        ss.execschemarql(session.execute, sperdef,

                         ss.rdef2rql(sperdef, cstrtypemap, groupmap))

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.cw_edited:

        if attr in ro_attrs:

            origval, newval = entity.cw_edited.oldnewvalue(attr)

            if newval != origval:

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

                               display_name(session, attr)

    if errors:

        raise ValidationError(entity.eid, errors)

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

    # XXX revertprecommit_event

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

        source = session.repo.system_source

        # drop index if any

        source.drop_index(session, table, column)

        if source.dbhelper.alter_column_support:

            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)

        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, 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 postcommit_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, **kwargs):

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

        # every schema operation is triggering a schema update

        MemSchemaNotifyChanges(session)

# 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 owned_by relation by creating the necessary CWRelation entity

    """

    def precommit_event(self):

        session = self.session

        entity = self.entity

        schema = session.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(session.pool.source('system').dbhelper,

                                     eschema, prefix=SQL_PREFIX)

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

            if sql.strip():

                session.system_sql(sql)

        # add meta relations

        gmap = group_mapping(session)

        cmap = ss.cstrtype_mapping(session)

        for rtype in (META_RTYPES - VIRTUAL_RTYPES):

            rschema = schema[rtype]

            sampletype = rschema.subjects()[0]

            desttype = rschema.objects()[0]

            rdef = copy(rschema.rdef(sampletype, desttype))

            rdef.subject = mock_object(eid=entity.eid)

            mock = mock_object(eid=None)

            ss.execschemarql(session.execute, mock, ss.rdef2rql(rdef, cmap, gmap))

    def revertprecommit_event(self):

        # revert changes on in memory schema

        self.session.vreg.schema.del_entity_type(self.entity.name)

        # revert changes on database

        self.session.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.session.vreg.schema.rename_entity_type(oldname, newname)

        # 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, oldname,

                                                     SQL_PREFIX, newname))

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

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

                (newname, oldname))

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

                (newname, oldname))

        # 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

    oldvalus = None

    def precommit_event(self):

        rschema = self.rschema

        if rschema.final:

            return # watched changes to final relation type are unexpected

        session = self.session

        if 'fulltext_container' in self.values:

            for subjtype, objtype in rschema.rdefs:

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

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

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

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