"""Repository users' and internal' sessions.

:organization: Logilab

:copyright: 2001-2009 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 rql.nodes import VariableRef, Function, ETYPE_PYOBJ_MAP, etype_from_pyobj

from yams import BASE_TYPES

from cubicweb import RequestSessionMixIn, Binary, UnknownEid

from cubicweb.dbapi import ConnectionProperties

from cubicweb.utils import make_uid

from cubicweb.server.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

from rql import stmts

assert hasattr(stmts.Union, 'get_variable_variables'), "You need RQL > 0.18.3"

class Session(RequestSessionMixIn):

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

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

        self._threaddata = threading.local()

        self._threads_in_transaction = set()

        self._closed = False

    def get_mode(self):

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

    def set_mode(self, value):

        self._threaddata.mode = value

    # transaction mode (read/write), resetted to read on commit / rollback

    mode = property(get_mode, set_mode)

    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)

    # set according to transaction mode for each query

    @property

    def pool(self):

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

    # pending transaction operations

    @property

    def pending_operations(self):

        try:

            return self._threaddata.pending_operations

        except AttributeError:

            self._threaddata.pending_operations = []

            return self._threaddata.pending_operations

    # rql rewriter

    @property

    def rql_rewriter(self):

        try:

            return self._threaddata._rewriter

        except AttributeError:

            self._threaddata._rewriter = RQLRewriter(self.repo.querier, self)

            return self._threaddata._rewriter

    # transaction queries data

    @property

    def _query_data(self):

        try:

            return self._threaddata._query_data

        except AttributeError:

            self._threaddata._query_data = {}

            return self._threaddata._query_data

    def set_language(self, language):

        """i18n configuration for translation"""

        vreg = self.vreg

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

        try:

            self._ = self.__ = vreg.config.translations[language]

        except KeyError:

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

            try:

                self._ = self.__ = vreg.config.translations[language]

            except KeyError:

                self._ = self.__ = unicode

        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 __str__(self):

        return '<%ssession %s (%s 0x%x)>' % (self.cnxtype, self.user.login,

                                             self.id, id(self))

    def etype_class(self, etype):

        """return an entity class for the given entity type"""

        return self.vreg.etype_class(etype)

    def entity(self, eid):

        """return a result set for the given eid"""

        return self.eid_rset(eid).get_entity(0, 0)

    def _touch(self):

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

        """

        self.timestamp = time()

        self.local_perm_cache.clear()

        self._threaddata.mode = 'read'

    def set_pool(self):

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

        if 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 = self.repo._get_pool()

            try:

                self._threaddata.pool.pool_set(self)

            except:

                self._threaddata.pool = None

                self.repo._free_pool(self.pool)

                raise

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

        return self._threaddata.pool

    def reset_pool(self):

        """the session has 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 self.mode == 'read':

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

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

            self._threaddata.pool = None

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

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

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

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

            self.mode = 'write'

        cursor = self.pool['system']

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

        return cursor

    def actual_session(self):

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

        return self

    # 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.set_query_data(key, value)

        else:

            self.data[key] = value

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

    def set_entity_cache(self, entity):

        # no entity cache in the server, too high risk of inconsistency

        # between pre/post hooks

        pass

    def entity_cache(self, eid):

        raise KeyError(eid)

    def base_url(self):

        return self.repo.config['base-url'] or u''

    def from_controller(self):

        """return the id (string) of the controller issuing the request (no

        sense here, always return 'view')

        """

        return 'view'

    def source_defs(self):

        return self.repo.source_defs()

    def describe(self, eid):

        """return a tuple (type, sourceuri, extid) for the entity with id <eid>"""

        return self.repo.type_and_source_from_eid(eid, self)

    # db-api like interface ###################################################

    def source_from_eid(self, eid):

        """return the source where the entity with id <eid> is located"""

        return self.repo.source_from_eid(eid, self)

    def decorate_rset(self, rset, propagate=False):

        rset.vreg = self.vreg

        rset.req = propagate and self or self.actual_session()

        return rset

    @property

    def super_session(self):

        try:

            csession = self._threaddata.childsession

        except AttributeError:

            if self.is_super_session:

                csession = self

            else:

                csession = ChildSession(self)

            self._threaddata.childsession = csession

        # need shared pool set

        self.set_pool()

        return csession

    def unsafe_execute(self, rql, kwargs=None, eid_key=None, build_descr=False,

                       propagate=False):

        """like .execute but with security checking disabled (this method is

        internal to the server, it's not part of the db-api)

        if `propagate` is true, the super_session will be attached to the result

        set instead of the parent session, hence further query done through

        entities fetched from this result set will bypass security as well

        """

        return self.super_session.execute(rql, kwargs, eid_key, build_descr,

                                          propagate)

    @property

    def cursor(self):

        """return a rql cursor"""

        return self

    def execute(self, rql, kwargs=None, eid_key=None, build_descr=True,

                propagate=False):

        """db-api like method directly linked to the querier execute method

        Becare that unlike actual cursor.execute, `build_descr` default to

        false

        """

        rset = self._execute(self, rql, kwargs, eid_key, build_descr)

        return self.decorate_rset(rset, propagate)

    def commit(self, reset_pool=True):

        """commit the current session's transaction"""

        if self.pool is None:

            assert not self.pending_operations

            self._query_data.clear()

            self._touch()

            return

        if self.commit_state:

            return

        # on rollback, an operation should have the following state

        # information:

        # - processed by the precommit/commit event or not

        # - if processed, is it the failed operation

        try:

            for trstate in ('precommit', 'commit'):

                processed = []

                self.commit_state = trstate

                try:

                    while self.pending_operations:

                        operation = self.pending_operations.pop(0)

                        operation.processed = trstate

                        processed.append(operation)

                        operation.handle_event('%s_event' % trstate)

                    self.pending_operations[:] = processed

                    self.debug('%s session %s done', trstate, self.id)

                except:

                    self.exception('error while %sing', trstate)

                    operation.failed = True

                    for operation in processed:

                        operation.handle_event('revert%s_event' % trstate)

                    self.rollback(reset_pool)

                    raise

            self.pool.commit()

        finally:

            self._touch()

            self.commit_state = None

            self.pending_operations[:] = []

            self._query_data.clear()

            if reset_pool:

                self.reset_pool()

    def rollback(self, reset_pool=True):

        """rollback the current session's transaction"""

        if self.pool is None:

            assert not self.pending_operations

            self._query_data.clear()

            self._touch()

            return

        try:

            while self.pending_operations:

                try:

                    operation = self.pending_operations.pop(0)

                    operation.handle_event('rollback_event')

                except:

                    self.critical('rollback error', exc_info=sys.exc_info())

                    continue

            self.pool.rollback()

        finally:

            self._touch()

            self.pending_operations[:] = []

            self._query_data.clear()

            if reset_pool:

                self.reset_pool()

    def close(self):

        """do not close pool on session close, since they are shared now"""

        self._closed = True

        # copy since _threads_in_transaction maybe modified while waiting

        for thread in self._threads_in_transaction.copy():

            if thread is threading.currentThread():

                continue

            self.info('waiting for thread %s', thread)

            # do this loop/break instead of a simple join(10) in case thread is

            # the main thread (in which case it will be removed from

            # self._threads_in_transaction but still be alive...)

            for i in xrange(10):

                thread.join(1)

                if not (thread.isAlive() and

                        thread in self._threads_in_transaction):

                    break

            else:

                self.error('thread %s still alive after 10 seconds, will close '

                           'session anyway', thread)

        self.rollback()

    # transaction data/operations management ##################################

    def add_query_data(self, key, value):

        self._query_data.setdefault(key, []).append(value)

    def set_query_data(self, key, value):

        self._query_data[key] = value

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

        if setdefault:

            assert not pop

            return self._query_data.setdefault(key, default)

        if pop:

            return self._query_data.pop(key, default)

        else:

            return self._query_data.get(key, default)

    def add_operation(self, operation, index=None):

        """add an observer"""

        assert self.commit_state != 'commit'

        if index is not None: