"""Core hooks: check schema validity, unsure we are not deleting necessary

entities...

:organization: Logilab

:copyright: 2001-2010 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 threading import Lock

from datetime import datetime

from cubicweb import UnknownProperty, ValidationError, BadConnectionId

from cubicweb.schema import RQLConstraint, RQLUniqueConstraint

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

from cubicweb.server.hookhelper import (check_internal_entity,

                                        get_user_sessions, rproperty)

from cubicweb.server.repository import FTIndexEntityOp

# special relations that don't have to be checked for integrity, usually

# because they are handled internally by hooks (so we trust ourselves)

DONT_CHECK_RTYPES_ON_ADD = set(('owned_by', 'created_by',

                                'is', 'is_instance_of',

                                'wf_info_for', 'from_state', 'to_state'))

DONT_CHECK_RTYPES_ON_DEL = set(('is', 'is_instance_of',

                                'wf_info_for', 'from_state', 'to_state'))

_UNIQUE_CONSTRAINTS_LOCK = Lock()

class _ReleaseUniqueConstraintsHook(Operation):

    def commit_event(self):

        pass

    def postcommit_event(self):

        _release_unique_cstr_lock(self.session)

    def rollback_event(self):

        _release_unique_cstr_lock(self.session)

def _acquire_unique_cstr_lock(session):

    """acquire the _UNIQUE_CONSTRAINTS_LOCK for the session.

    This lock used to avoid potential integrity pb when checking

    RQLUniqueConstraint in two different transactions, as explained in

    http://intranet.logilab.fr/jpl/ticket/36564

    """

    asession = session.actual_session()

    if 'uniquecstrholder' in asession.transaction_data:

        return

    _UNIQUE_CONSTRAINTS_LOCK.acquire()

    asession.transaction_data['uniquecstrholder'] = True

    # register operation responsible to release the lock on commit/rollback

    _ReleaseUniqueConstraintsHook(asession)

def _release_unique_cstr_lock(session):

    if 'uniquecstrholder' in session.transaction_data:

        del session.transaction_data['uniquecstrholder']

        _UNIQUE_CONSTRAINTS_LOCK.release()

def relation_deleted(session, eidfrom, rtype, eidto):

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

        (eidfrom, rtype, eidto))

def eschema_type_eid(session, etype):

    """get eid of the CWEType entity for the given yams type"""

    eschema = session.repo.schema.eschema(etype)

    # eschema.eid is None if schema has been readen from the filesystem, not

    # from the database (eg during tests)

    if eschema.eid is None:

        eschema.eid = session.unsafe_execute(

            'Any X WHERE X is CWEType, X name %(name)s',

            {'name': str(etype)})[0][0]

    return eschema.eid

# base meta-data handling ######################################################

def setctime_before_add_entity(session, entity):

    """before create a new entity -> set creation and modification date

    this is a conveniency hook, you shouldn't have to disable it

    """

    timestamp = datetime.now()

    entity.setdefault('creation_date', timestamp)

    entity.setdefault('modification_date', timestamp)

    if not session.get_shared_data('do-not-insert-cwuri'):

        entity.setdefault('cwuri', u'%seid/%s' % (session.base_url(), entity.eid))

def setmtime_before_update_entity(session, entity):

    """update an entity -> set modification date"""

    entity.setdefault('modification_date', datetime.now())

class SetCreatorOp(PreCommitOperation):

    def precommit_event(self):

        session = self.session

        if self.entity.eid in session.transaction_data.get('pendingeids', ()):

            # entity have been created and deleted in the same transaction

            return

        if not self.entity.created_by:

            session.add_relation(self.entity.eid, 'created_by', session.user.eid)

def setowner_after_add_entity(session, entity):

    """create a new entity -> set owner and creator metadata"""

    asession = session.actual_session()

    if not asession.is_internal_session:

        session.add_relation(entity.eid, 'owned_by', asession.user.eid)

        SetCreatorOp(asession, entity=entity)

def setis_after_add_entity(session, entity):

    """create a new entity -> set is relation"""

    if hasattr(entity, '_cw_recreating'):

        return

    try:

        #session.add_relation(entity.eid, 'is',

        #                     eschema_type_eid(session, entity.id))

        session.system_sql('INSERT INTO is_relation(eid_from,eid_to) VALUES (%s,%s)'

                           % (entity.eid, eschema_type_eid(session, entity.id)))

    except IndexError:

        # during schema serialization, skip

        return

    for etype in entity.e_schema.ancestors() + [entity.e_schema]:

        #session.add_relation(entity.eid, 'is_instance_of',

        #                     eschema_type_eid(session, etype))

        session.system_sql('INSERT INTO is_instance_of_relation(eid_from,eid_to) VALUES (%s,%s)'

                           % (entity.eid, eschema_type_eid(session, etype)))

def setowner_after_add_user(session, entity):

    """when a user has been created, add owned_by relation on itself"""

    session.add_relation(entity.eid, 'owned_by', entity.eid)

def fti_update_after_add_relation(session, eidfrom, rtype, eidto):

    """sync fulltext index when relevant relation is added. Reindexing the

    contained entity is enough since it will implicitly reindex the container

    entity.

    """

    ftcontainer = session.repo.schema.rschema(rtype).fulltext_container

    if ftcontainer == 'subject':

        FTIndexEntityOp(session, entity=session.entity_from_eid(eidto))

    elif ftcontainer == 'object':

        FTIndexEntityOp(session, entity=session.entity_from_eid(eidfrom))

def fti_update_after_delete_relation(session, eidfrom, rtype, eidto):

    """sync fulltext index when relevant relation is deleted. Reindexing both

    entities is necessary.

    """

    if session.repo.schema.rschema(rtype).fulltext_container:

        FTIndexEntityOp(session, entity=session.entity_from_eid(eidto))

        FTIndexEntityOp(session, entity=session.entity_from_eid(eidfrom))

class SyncOwnersOp(PreCommitOperation):

    def precommit_event(self):

        self.session.unsafe_execute('SET X owned_by U WHERE C owned_by U, C eid %(c)s,'

                                    'NOT EXISTS(X owned_by U, X eid %(x)s)',

                                    {'c': self.compositeeid, 'x': self.composedeid},

                                    ('c', 'x'))

def sync_owner_after_add_composite_relation(session, eidfrom, rtype, eidto):

    """when adding composite relation, the composed should have the same owners

    has the composite

    """

    if rtype == 'wf_info_for':

        # skip this special composite relation # XXX (syt) why?

        return

    composite = rproperty(session, rtype, eidfrom, eidto, 'composite')

    if composite == 'subject':

        SyncOwnersOp(session, compositeeid=eidfrom, composedeid=eidto)

    elif composite == 'object':

        SyncOwnersOp(session, compositeeid=eidto, composedeid=eidfrom)

def _register_metadata_hooks(hm):

    """register meta-data related hooks on the hooks manager"""

    hm.register_hook(setctime_before_add_entity, 'before_add_entity', '')

    hm.register_hook(setmtime_before_update_entity, 'before_update_entity', '')

    hm.register_hook(setowner_after_add_entity, 'after_add_entity', '')

    hm.register_hook(sync_owner_after_add_composite_relation, 'after_add_relation', '')

    hm.register_hook(fti_update_after_add_relation, 'after_add_relation', '')

    hm.register_hook(fti_update_after_delete_relation, 'after_delete_relation', '')

    if 'is' in hm.schema:

        hm.register_hook(setis_after_add_entity, 'after_add_entity', '')

    if 'CWUser' in hm.schema:

        hm.register_hook(setowner_after_add_user, 'after_add_entity', 'CWUser')

# core hooks ##################################################################

class DelayedDeleteOp(PreCommitOperation):

    """delete the object of composite relation except if the relation

    has actually been redirected to another composite

    """

    def precommit_event(self):

        session = self.session

        # don't do anything if the entity is being created or deleted

        if not (self.eid in session.transaction_data.get('pendingeids', ()) or

                self.eid in session.transaction_data.get('neweids', ())):

            etype = session.describe(self.eid)[0]

            if self.role == 'subject':

                rql = 'DELETE %s X WHERE X eid %%(x)s, NOT X %s Y'

            else: # self.role == 'object':

                rql = 'DELETE %s X WHERE X eid %%(x)s, NOT Y %s X'

            session.unsafe_execute(rql % (etype, self.rtype), {'x': self.eid}, 'x')

def handle_composite_before_del_relation(session, eidfrom, rtype, eidto):

    """delete the object of composite relation"""

    # if the relation is being delete, don't delete composite's components

    # automatically

    pendingrdefs = session.transaction_data.get('pendingrdefs', ())

    if (session.describe(eidfrom)[0], rtype, session.describe(eidto)[0]) in pendingrdefs:

        return

    composite = rproperty(session, rtype, eidfrom, eidto, 'composite')

    if composite == 'subject':

        DelayedDeleteOp(session, eid=eidto, rtype=rtype, role='object')

    elif composite == 'object':

        DelayedDeleteOp(session, eid=eidfrom, rtype=rtype, role='subject')

def before_del_group(session, eid):

    """check that we don't remove the owners group"""

    check_internal_entity(session, eid, ('owners',))

# schema validation hooks #####################################################

class CheckConstraintsOperation(LateOperation):

    """check a new relation satisfy its constraints

    """

    def precommit_event(self):

        eidfrom, rtype, eidto = self.rdef

        # first check related entities have not been deleted in the same

        # transaction

        pending = self.session.transaction_data.get('pendingeids', ())

        if eidfrom in pending:

            return

        if eidto in pending:

            return

        for constraint in self.constraints:

            # XXX

            # * lock RQLConstraint as well?

            # * use a constraint id to use per constraint lock and avoid

            #   unnecessary commit serialization ?

            if isinstance(constraint, RQLUniqueConstraint):

                _acquire_unique_cstr_lock(self.session)

            try:

                constraint.repo_check(self.session, eidfrom, rtype, eidto)

            except NotImplementedError:

                self.critical('can\'t check constraint %s, not supported',

                              constraint)

    def commit_event(self):

        pass

def cstrcheck_after_add_relation(session, eidfrom, rtype, eidto):

    """check the relation satisfy its constraints

    this is delayed to a precommit time operation since other relation which

    will make constraint satisfied may be added later.

    """

    if session.is_super_session:

        return

    constraints = rproperty(session, rtype, eidfrom, eidto, 'constraints')

    if constraints:

        # XXX get only RQL[Unique]Constraints?

        CheckConstraintsOperation(session, constraints=constraints,

                                  rdef=(eidfrom, rtype, eidto))

def uniquecstrcheck_before_modification(session, entity):

    if session.is_super_session:

        return

    eschema = entity.e_schema

    for attr in entity.edited_attributes:

        val = entity[attr]

        if val is None:

            continue

        if eschema.subjrels[attr].final and \

               eschema.has_unique_values(attr):

            rql = '%s X WHERE X %s %%(val)s' % (entity.e_schema, attr)

            rset = session.unsafe_execute(rql, {'val': val})

            if rset and rset[0][0] != entity.eid:

                msg = session._('the value "%s" is already used, use another one')

                raise ValidationError(entity.eid, {attr: msg % val})

def cstrcheck_after_update_attributes(session, entity):

    if session.is_super_session:

        return

    eschema = entity.e_schema

    for attr in entity.edited_attributes:

        if eschema.subjrels[attr].final:

            constraints = [c for c in entity.e_schema.constraints(attr)

                           if isinstance(c, (RQLConstraint, RQLUniqueConstraint))]

            if constraints:

                CheckConstraintsOperation(session, rdef=(entity.eid, attr, None),

                                          constraints=constraints)

class CheckRequiredRelationOperation(LateOperation):

    """checking relation cardinality has to be done after commit in

    case the relation is being replaced

    """

    eid, rtype = None, None

    def precommit_event(self):

        # recheck pending eids

        if self.eid in self.session.transaction_data.get('pendingeids', ()):

            return

        if self.rtype in self.session.transaction_data.get('pendingrtypes', ()):

            return

        if self.session.unsafe_execute(*self._rql()).rowcount < 1:

            etype = self.session.describe(self.eid)[0]

            _ = self.session._

            msg = _('at least one relation %(rtype)s is required on %(etype)s (%(eid)s)')

            msg %= {'rtype': _(self.rtype), 'etype': _(etype), 'eid': self.eid}

            raise ValidationError(self.eid, {self.rtype: msg})

    def commit_event(self):

        pass

    def _rql(self):

        raise NotImplementedError()

class CheckSRelationOp(CheckRequiredRelationOperation):

    """check required subject relation"""

    def _rql(self):

        return 'Any O WHERE S eid %%(x)s, S %s O' % self.rtype, {'x': self.eid}, 'x'

class CheckORelationOp(CheckRequiredRelationOperation):

    """check required object relation"""

    def _rql(self):

        return 'Any S WHERE O eid %%(x)s, S %s O' % self.rtype, {'x': self.eid}, 'x'

def checkrel_if_necessary(session, opcls, rtype, eid):

    """check an equivalent operation has not already been added"""

    for op in session.pending_operations:

        if isinstance(op, opcls) and op.rtype == rtype and op.eid == eid:

            break

    else:

        opcls(session, rtype=rtype, eid=eid)

def cardinalitycheck_after_add_entity(session, entity):

    """check cardinalities are satisfied"""

    if session.is_super_session:

        return

    eid = entity.eid

    for rschema, targetschemas, x in entity.e_schema.relation_definitions():

        # skip automatically handled relations

        if rschema.type in DONT_CHECK_RTYPES_ON_ADD:

            continue

        if x == 'subject':

            subjtype = entity.e_schema

            objtype = targetschemas[0].type

            cardindex = 0

            opcls = CheckSRelationOp

        else:

            subjtype = targetschemas[0].type

            objtype = entity.e_schema

            cardindex = 1

            opcls = CheckORelationOp

        card = rschema.rproperty(subjtype, objtype, 'cardinality')

        if card[cardindex] in '1+':

            checkrel_if_necessary(session, opcls, rschema.type, eid)