"""Repository users' and internal' sessions.

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

import sys

import threading

from time import time

from logilab.common.deprecation import deprecated

from rql.nodes import VariableRef, Function, ETYPE_PYOBJ_MAP, etype_from_pyobj

from yams import BASE_TYPES

from cubicweb import Binary, UnknownEid

from cubicweb.req import RequestSessionBase

from cubicweb.dbapi import ConnectionProperties

from cubicweb.utils import make_uid

from cubicweb.rqlrewrite import RQLRewriter

ETYPE_PYOBJ_MAP[Binary] = 'Bytes'

def is_final(rqlst, variable, args):

    # try to find if this is a final var or not

    for select in rqlst.children:

        for sol in select.solutions:

            etype = variable.get_type(sol, args)

            if etype is None:

                continue

            if etype in BASE_TYPES:

                return True

            return False

def _make_description(selected, args, solution):

    """return a description for a result set"""

    description = []

    for term in selected:

        description.append(term.get_type(solution, args))

    return description

class Session(RequestSessionBase):

    """tie session id, user, connections pool and other session data all

    together

    """

    def __init__(self, user, repo, cnxprops=None, _id=None):

        super(Session, self).__init__(repo.vreg)

        self.id = _id or make_uid(user.login.encode('UTF8'))

        cnxprops = cnxprops or ConnectionProperties('inmemory')

        self.user = user

        self.repo = repo

        self.cnxtype = cnxprops.cnxtype

        self.creation = time()

        self.timestamp = self.creation

        self.is_internal_session = False

        self.is_super_session = False

        self.default_mode = 'read'

        # short cut to querier .execute method

        self._execute = repo.querier.execute

        # shared data, used to communicate extra information between the client

        # and the rql server

        self.data = {}

        # i18n initialization

        self.set_language(cnxprops.lang)

        # internals

        self._threaddata = threading.local()

        self._threads_in_transaction = set()

        self._closed = False

    def __unicode__(self):

        return '<%ssession %s (%s 0x%x)>' % (

            self.cnxtype, unicode(self.user.login), self.id, id(self))

    def hijack_user(self, user):

        """return a fake request/session using specified user"""

        session = Session(user, self.repo)

        session._threaddata = self.actual_session()._threaddata

        return session

    def _super_call(self, __cb, *args, **kwargs):

        if self.is_super_session:

            __cb(self, *args, **kwargs)

            return

        self.is_super_session = True

        try:

            __cb(self, *args, **kwargs)

        finally:

            self.is_super_session = False

    def add_relation(self, fromeid, rtype, toeid):

        """provide direct access to the repository method to add a relation.

        This is equivalent to the following rql query:

          SET X rtype Y WHERE X eid  fromeid, T eid toeid

        without read security check but also all the burden of rql execution.

        You may use this in hooks when you know both eids of the relation you

        want to add.

        """

        if self.vreg.schema[rtype].inlined:

            entity = self.entity_from_eid(fromeid)

            entity[rtype] = toeid

            self._super_call(self.repo.glob_update_entity,

                             entity, set((rtype,)))

        else:

            self._super_call(self.repo.glob_add_relation,

                             fromeid, rtype, toeid)

    def delete_relation(self, fromeid, rtype, toeid):

        """provide direct access to the repository method to delete a relation.

        This is equivalent to the following rql query:

          DELETE X rtype Y WHERE X eid  fromeid, T eid toeid

        without read security check but also all the burden of rql execution.

        You may use this in hooks when you know both eids of the relation you

        want to delete.

        """

        if self.vreg.schema[rtype].inlined:

            entity = self.entity_from_eid(fromeid)

            entity[rtype] = None

            self._super_call(self.repo.glob_update_entity,

                             entity, set((rtype,)))

        else:

            self._super_call(self.repo.glob_delete_relation,

                             fromeid, rtype, toeid)

    # relations cache handling #################################################

    def update_rel_cache_add(self, subject, rtype, object, symmetric=False):

        self._update_entity_rel_cache_add(subject, rtype, 'subject', object)

        if symmetric:

            self._update_entity_rel_cache_add(object, rtype, 'subject', subject)

        else:

            self._update_entity_rel_cache_add(object, rtype, 'object', subject)

    def update_rel_cache_del(self, subject, rtype, object, symmetric=False):

        self._update_entity_rel_cache_del(subject, rtype, 'subject', object)

        if symmetric:

            self._update_entity_rel_cache_del(object, rtype, 'object', object)

        else:

            self._update_entity_rel_cache_del(object, rtype, 'object', subject)

    def _update_entity_rel_cache_add(self, eid, rtype, role, targeteid):

        try:

            entity = self.entity_cache(eid)

        except KeyError:

            return

        rcache = entity.relation_cached(rtype, role)

        if rcache is not None:

            rset, entities = rcache

            rset = rset.copy()

            entities = list(entities)

            rset.rows.append([targeteid])

            if not isinstance(rset.description, list): # else description not set

                rset.description = list(rset.description)

            rset.description.append([self.describe(targeteid)[0]])

            targetentity = self.entity_from_eid(targeteid)

            if targetentity.cw_rset is None:

                targetentity.cw_rset = rset

                targetentity.cw_row = rset.rowcount

                targetentity.cw_col = 0

            rset.rowcount += 1

            entities.append(targetentity)

            entity._related_cache['%s_%s' % (rtype, role)] = (rset, tuple(entities))

    def _update_entity_rel_cache_del(self, eid, rtype, role, targeteid):

        try:

            entity = self.entity_cache(eid)

        except KeyError:

            return

        rcache = entity.relation_cached(rtype, role)

        if rcache is not None:

            rset, entities = rcache

            for idx, row in enumerate(rset.rows):

                if row[0] == targeteid:

                    break

            else:

                # this may occurs if the cache has been filed by a hook

                # after the database update

                self.debug('cache inconsistency for %s %s %s %s', eid, rtype,

                           role, targeteid)

                return

            rset = rset.copy()

            entities = list(entities)

            del rset.rows[idx]

            if isinstance(rset.description, list): # else description not set

                del rset.description[idx]

            del entities[idx]

            rset.rowcount -= 1

            entity._related_cache['%s_%s' % (rtype, role)] = (rset, tuple(entities))

    # resource accessors ######################################################

    def actual_session(self):

        """return the original parent session if any, else self"""

        return self

    def system_sql(self, sql, args=None, rollback_on_failure=True):

        """return a sql cursor on the system database"""

        if not sql.split(None, 1)[0].upper() == 'SELECT':

            self.mode = 'write'

        return self.pool.source('system').doexec(self, sql, args,

                                                 rollback=rollback_on_failure)

    def set_language(self, language):

        """i18n configuration for translation"""

        vreg = self.vreg

        language = language or self.user.property_value('ui.language')

        try:

            gettext, pgettext = vreg.config.translations[language]

            self._ = self.__ = gettext

            self.pgettext = pgettext

        except KeyError:

            language = vreg.property_value('ui.language')

            try:

                gettext, pgettext = vreg.config.translations[language]

                self._ = self.__ = gettext

                self.pgettext = pgettext

            except KeyError:

                self._ = self.__ = unicode

                self.pgettext = lambda x, y: y

        self.lang = language

    def change_property(self, prop, value):

        assert prop == 'lang' # this is the only one changeable property for now

        self.set_language(value)

    def deleted_in_transaction(self, eid):

        """return True if the entity of the given eid is being deleted in the

        current transaction

        """

        return eid in self.transaction_data.get('pendingeids', ())

    def added_in_transaction(self, eid):

        """return True if the entity of the given eid is being created in the

        current transaction

        """

        return eid in self.transaction_data.get('neweids', ())

    def schema_rproperty(self, rtype, eidfrom, eidto, rprop):

        rschema = self.repo.schema[rtype]

        subjtype = self.describe(eidfrom)[0]

        objtype = self.describe(eidto)[0]

        rdef = rschema.rdef(subjtype, objtype)

        return rdef.get(rprop)

    # connection management ###################################################

    def keep_pool_mode(self, mode):

        """set pool_mode, e.g. how the session will keep its pool:

        * if mode == 'write', the pool is freed after each ready query, but kept

          until the transaction's end (eg commit or rollback) when a write query

          is detected (eg INSERT/SET/DELETE queries)

        * if mode == 'transaction', the pool is only freed after the

          transaction's end

        notice that a repository has a limited set of pools, and a session has to

        wait for a free pool to run any rql query (unless it already has a pool

        set).

        """

        assert mode in ('transaction', 'write')

        if mode == 'transaction':

            self.default_mode = 'transaction'

        else: # mode == 'write'

            self.default_mode = 'read'

    def get_mode(self):

        return getattr(self._threaddata, 'mode', self.default_mode)

    def set_mode(self, value):

        self._threaddata.mode = value

    mode = property(get_mode, set_mode,

                    doc='transaction mode (read/write/transaction), resetted to'

                    ' default_mode on commit / rollback')

    def get_commit_state(self):

        return getattr(self._threaddata, 'commit_state', None)

    def set_commit_state(self, value):

        self._threaddata.commit_state = value

    commit_state = property(get_commit_state, set_commit_state)

    @property

    def pool(self):

        """connections pool, set according to transaction mode for each query"""

        return getattr(self._threaddata, 'pool', None)

    def set_pool(self, checkclosed=True):

        """the session need a pool to execute some queries"""

        if checkclosed and self._closed:

            raise Exception('try to set pool on a closed session')

        if self.pool is None:

            # get pool first to avoid race-condition

            self._threaddata.pool = pool = self.repo._get_pool()

            try:

                pool.pool_set()

            except:

                self._threaddata.pool = None

                self.repo._free_pool(pool)

                raise

            self._threads_in_transaction.add(threading.currentThread())

        return self._threaddata.pool

    def reset_pool(self, ignoremode=False):

        """the session is no longer using its pool, at least for some time"""

        # pool may be none if no operation has been done since last commit

        # or rollback

        if self.pool is not None and (ignoremode or self.mode == 'read'):

            # even in read mode, we must release the current transaction

            pool = self.pool

            try:

                self._threads_in_transaction.remove(threading.currentThread())

            except KeyError:

                pass

            pool.pool_reset()

            del self._threaddata.pool

            # free pool once everything is done to avoid race-condition

            self.repo._free_pool(pool)

    def _touch(self):

        """update latest session usage timestamp and reset mode to read"""

        self.timestamp = time()

        self.local_perm_cache.clear()

        self._threaddata.mode = self.default_mode

    # shared data handling ###################################################

    def get_shared_data(self, key, default=None, pop=False):

        """return value associated to `key` in session data"""

        if pop:

            return self.data.pop(key, default)

        else:

            return self.data.get(key, default)

    def set_shared_data(self, key, value, querydata=False):

        """set value associated to `key` in session data"""

        if querydata:

            self.transaction_data[key] = value

        else:

            self.data[key] = value

    # request interface #######################################################

    @property

    def cursor(self):

        """return a rql cursor"""

        return self

    def set_entity_cache(self, entity):

        # XXX session level caching may be a pb with multiple repository

        #     instances, but 1. this is probably not the only one :$ and 2. it

        #     may be an acceptable risk. Anyway we could activate it or not

        #     according to a configuration option

        try:

            self.transaction_data['ecache'].setdefault(entity.eid, entity)

        except KeyError:

            self.transaction_data['ecache'] = ecache = {}

            ecache[entity.eid] = entity

    def entity_cache(self, eid):

        try:

            return self.transaction_data['ecache'][eid]

        except:

            raise

    def cached_entities(self):

        return self.transaction_data.get('ecache', {}).values()

    def drop_entity_cache(self, eid=None):