# copyright 2003-2011 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/>.
"""Core hooks: set generic metadata"""

__docformat__ = "restructuredtext en"

from datetime import datetime

from cubicweb.selectors import is_instance
from cubicweb.server import hook
from cubicweb.server.edition import EditedEntity


class MetaDataHook(hook.Hook):
    __abstract__ = True
    category = 'metadata'


class InitMetaAttrsHook(MetaDataHook):
    """before create a new entity -> set creation and modification date

    this is a conveniency hook, you shouldn't have to disable it
    """
    __regid__ = 'metaattrsinit'
    events = ('before_add_entity',)

    def __call__(self):
        timestamp = datetime.now()
        edited = self.entity.cw_edited
        if not edited.get('creation_date'):
            edited['creation_date'] = timestamp
        if not edited.get('modification_date'):
            edited['modification_date'] = timestamp
        if not self._cw.get_shared_data('do-not-insert-cwuri'):
            cwuri = u'%s%s' % (self._cw.base_url(), self.entity.eid)
            edited.setdefault('cwuri', cwuri)


class UpdateMetaAttrsHook(MetaDataHook):
    """update an entity -> set modification date"""
    __regid__ = 'metaattrsupdate'
    events = ('before_update_entity',)

    def __call__(self):
        # repairing is true during c-c upgrade/shell and similar commands. We
        # usually don't want to update modification date in such cases.
        #
        # XXX to be really clean, we should turn off modification_date update
        # explicitly on each command where we do not want that behaviour.
        if not self._cw.vreg.config.repairing:
            self.entity.cw_edited.setdefault('modification_date', datetime.now())


class SetCreatorOp(hook.DataOperationMixIn, hook.Operation):

    def precommit_event(self):
        session = self.session
        relations = [(eid, session.user.eid) for eid in self.get_data()
                # don't consider entities that have been created and deleted in
                # the same transaction, nor ones where created_by has been
                # explicitly set
                if not session.deleted_in_transaction(eid) and \
                   not session.entity_from_eid(eid).created_by]
        session.add_relations([('created_by', relations)])


class SetOwnershipHook(MetaDataHook):
    """create a new entity -> set owner and creator metadata"""
    __regid__ = 'setowner'
    events = ('after_add_entity',)

    def __call__(self):
        if not self._cw.is_internal_session:
            self._cw.add_relation(self.entity.eid, 'owned_by', self._cw.user.eid)
            SetCreatorOp.get_instance(self._cw).add_data(self.entity.eid)


class SyncOwnersOp(hook.DataOperationMixIn, hook.Operation):
    def precommit_event(self):
        for compositeeid, composedeid in self.get_data():
            self.session.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': compositeeid, 'x': composedeid})


class SyncCompositeOwner(MetaDataHook):
    """when adding composite relation, the composed should have the same owners
    has the composite
    """
    __regid__ = 'synccompositeowner'
    events = ('after_add_relation',)

    def __call__(self):
        if self.rtype == 'wf_info_for':
            # skip this special composite relation # XXX (syt) why?
            return
        eidfrom, eidto = self.eidfrom, self.eidto
        composite = self._cw.rtype_eids_rdef(self.rtype, eidfrom, eidto).composite
        if composite == 'subject':
            SyncOwnersOp.get_instance(self._cw).add_data( (eidfrom, eidto) )
        elif composite == 'object':
            SyncOwnersOp.get_instance(self._cw).add_data( (eidto, eidfrom) )


class FixUserOwnershipHook(MetaDataHook):
    """when a user has been created, add owned_by relation on itself"""
    __regid__ = 'fixuserowner'
    __select__ = MetaDataHook.__select__ & is_instance('CWUser')
    events = ('after_add_entity',)

    def __call__(self):
        self._cw.add_relation(self.entity.eid, 'owned_by', self.entity.eid)


class UpdateFTIHook(MetaDataHook):
    """sync fulltext index text index container when a relation with
    fulltext_container set is added / removed
    """
    __regid__ = 'updateftirel'
    events = ('after_add_relation', 'after_delete_relation')

    def __call__(self):
        rtype = self.rtype
        session = self._cw
        ftcontainer = session.vreg.schema.rschema(rtype).fulltext_container
        if ftcontainer == 'subject':
            session.repo.system_source.index_entity(
                session, session.entity_from_eid(self.eidfrom))
        elif ftcontainer == 'object':
            session.repo.system_source.index_entity(
                session, session.entity_from_eid(self.eidto))



# entity source handling #######################################################

class ChangeEntityUpdateCaches(hook.Operation):
    def postcommit_event(self):
        self.oldsource.reset_caches()
        repo = self.session.repo
        entity = self.entity
        extid = entity.cw_metainformation()['extid']
        repo._type_source_cache[entity.eid] = (
            entity.__regid__, self.newsource.uri, None, self.newsource.uri)
        if self.oldsource.copy_based_source:
            uri = 'system'
        else:
            uri = self.oldsource.uri
        repo._extid_cache[(extid, uri)] = -entity.eid

class ChangeEntitySourceDeleteHook(MetaDataHook):
    """support for moving an entity from an external source by watching 'Any
    cw_source CWSource' relation
    """

    __regid__ = 'cw.metadata.source-change'
    __select__ = MetaDataHook.__select__ & hook.match_rtype('cw_source')
    events = ('before_delete_relation',)

    def __call__(self):
        if (self._cw.deleted_in_transaction(self.eidfrom)
            or self._cw.deleted_in_transaction(self.eidto)):
            return
        schange = self._cw.transaction_data.setdefault('cw_source_change', {})
        schange[self.eidfrom] = self.eidto


class ChangeEntitySourceAddHook(MetaDataHook):
    __regid__ = 'cw.metadata.source-change'
    __select__ = MetaDataHook.__select__ & hook.match_rtype('cw_source')
    events = ('before_add_relation',)

    def __call__(self):
        schange = self._cw.transaction_data.get('cw_source_change')
        if schange is not None and self.eidfrom in schange:
            newsource = self._cw.entity_from_eid(self.eidto)
            if newsource.name != 'system':
                raise Exception('changing source to something else than the '
                                'system source is unsupported')
            syssource = newsource.repo_source
            oldsource = self._cw.entity_from_eid(schange[self.eidfrom])
            entity = self._cw.entity_from_eid(self.eidfrom)
            # copy entity if necessary
            if not oldsource.repo_source.copy_based_source:
                entity.complete(skip_bytes=False)
                if not entity.creation_date:
                    entity.cw_attr_cache['creation_date'] = datetime.now()
                if not entity.modification_date:
                    entity.cw_attr_cache['modification_date'] = datetime.now()
                entity.cw_attr_cache['cwuri'] = u'%s%s' % (self._cw.base_url(), entity.eid)
                for rschema, attrschema in entity.e_schema.attribute_definitions():
                    if attrschema == 'Password' and \
                       rschema.rdef(entity.e_schema, attrschema).cardinality[0] == '1':
                        from logilab.common.shellutils import generate_password
                        entity.cw_attr_cache[rschema.type] = generate_password()
                entity.cw_edited = EditedEntity(entity, **entity.cw_attr_cache)
                syssource.add_entity(self._cw, entity)
            # we don't want the moved entity to be reimported later.  To
            # distinguish this state, the trick is to change the associated
            # record in the 'entities' system table with eid=-eid while leaving
            # other fields unchanged, and to add a new record with eid=eid,
            # source='system'. External source will then have consider case
            # where `extid2eid` return a negative eid as 'this entity was known
            # but has been moved, ignore it'.
            self._cw.system_sql('UPDATE entities SET eid=-eid WHERE eid=%(eid)s',
                                {'eid': self.eidfrom})
            attrs = {'type': entity.__regid__, 'eid': entity.eid, 'extid': None,
                     'source': 'system', 'asource': 'system',
                     'mtime': datetime.now()}
            self._cw.system_sql(syssource.sqlgen.insert('entities', attrs), attrs)
            # register an operation to update repository/sources caches
            ChangeEntityUpdateCaches(self._cw, entity=entity,
                                     oldsource=oldsource.repo_source,
                                     newsource=syssource)
