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

"""DB-API 2.0 compliant module

Take a look at http://www.python.org/peps/pep-0249.html

(most parts of this document are reported here in docstrings)

"""

__docformat__ = "restructuredtext en"

from threading import currentThread

from logging import getLogger

from time import time, clock

from itertools import count

from warnings import warn

from os.path import join

from uuid import uuid4

from logilab.common.logging_ext import set_log_methods

from logilab.common.decorators import monkeypatch

from logilab.common.deprecation import deprecated

from cubicweb import ETYPE_NAME_MAP, ConnectionError, AuthenticationError,\

     cwvreg, cwconfig

from cubicweb.req import RequestSessionBase

_MARKER = object()

def _fake_property_value(self, name):

    try:

        return super(DBAPIRequest, self).property_value(name)

    except KeyError:

        return ''

def fake(*args, **kwargs):

    return None

def multiple_connections_fix():

    """some monkey patching necessary when an application has to deal with

    several connections to different repositories. It tries to hide buggy class

    attributes since classes are not designed to be shared among multiple

    registries.

    """

    defaultcls = cwvreg.VRegistry.REGISTRY_FACTORY[None]

    etypescls = cwvreg.VRegistry.REGISTRY_FACTORY['etypes']

    orig_etype_class = etypescls.orig_etype_class = etypescls.etype_class

    @monkeypatch(defaultcls)

    def etype_class(self, etype):

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

        Try to find out a specific class for this kind of entity or

        default to a dump of the class registered for 'Any'

        """

        usercls = orig_etype_class(self, etype)

        if etype == 'Any':

            return usercls

        usercls.e_schema = self.schema.eschema(etype)

        return usercls

def multiple_connections_unfix():

    etypescls = cwvreg.VRegistry.REGISTRY_FACTORY['etypes']

    etypescls.etype_class = etypescls.orig_etype_class

class ConnectionProperties(object):

    def __init__(self, cnxtype=None, lang=None, close=True, log=False):

        self.cnxtype = cnxtype or 'pyro'

        self.lang = lang

        self.log_queries = log

        self.close_on_del = close

def get_repository(method, database=None, config=None, vreg=None):

    """get a proxy object to the CubicWeb repository, using a specific RPC method.

    Only 'in-memory' and 'pyro' are supported for now. Either vreg or config

    argument should be given

    """

    assert method in ('pyro', 'inmemory')

    assert vreg or config

    if vreg and not config:

        config = vreg.config

    if method == 'inmemory':

        # get local access to the repository

        from cubicweb.server.repository import Repository

        return Repository(config, vreg=vreg)

    else: # method == 'pyro'

        # resolve the Pyro object

        from logilab.common.pyro_ext import ns_get_proxy, get_proxy

        pyroid = database or config['pyro-instance-id'] or config.appid

        try:

            if config['pyro-ns-host'] == 'NO_PYRONS':

                return get_proxy(pyroid)

            else:

                return ns_get_proxy(pyroid, defaultnsgroup=config['pyro-ns-group'],

                                    nshost=config['pyro-ns-host'])

        except Exception, ex:

            raise ConnectionError(str(ex))

def repo_connect(repo, login, **kwargs):

    """Constructor to create a new connection to the CubicWeb repository.

    Returns a Connection instance.

    """

    if not 'cnxprops' in kwargs:

        kwargs['cnxprops'] = ConnectionProperties('inmemory')

    cnxid = repo.connect(unicode(login), **kwargs)

    cnx = Connection(repo, cnxid, kwargs['cnxprops'])

    if kwargs['cnxprops'].cnxtype == 'inmemory':

        cnx.vreg = repo.vreg

    return cnx

def connect(database=None, login=None, host=None, group=None,

            cnxprops=None, setvreg=True, mulcnx=True, initlog=True, **kwargs):

    """Constructor for creating a connection to the CubicWeb repository.

    Returns a :class:`Connection` object.

    Typical usage::

      cnx = connect('myinstance', login='me', password='toto')

    Arguments:

    :database:

      the instance's pyro identifier.

    :login:

      the user login to use to authenticate.

    :host:

      the pyro nameserver host. Will be detected using broadcast query if

      unspecified.

    :group:

      the instance's pyro nameserver group. You don't have to specify it unless

      tweaked in instance's configuration.

    :cnxprops:

      an optional :class:`ConnectionProperties` instance, allowing to specify

      the connection method (eg in memory or pyro). A Pyro connection will be

      established if you don't specify that argument.

    :setvreg:

      flag telling if a registry should be initialized for the connection.

      Don't change this unless you know what you're doing.

    :mulcnx:

      Will disappear at some point. Try to deal with connections to differents

      instances in the same process unless specified otherwise by setting this

      flag to False. Don't change this unless you know what you're doing.

    :initlog:

      flag telling if logging should be initialized. You usually don't want

      logging initialization when establishing the connection from a process

      where it's already initialized.

    :kwargs:

      there goes authentication tokens. You usually have to specify a password

      for the given user, using a named 'password' argument.

    """

    cnxprops = cnxprops or ConnectionProperties()

    method = cnxprops.cnxtype

    if method == 'pyro':

        config = cwconfig.CubicWebNoAppConfiguration()

        if host:

            config.global_set_option('pyro-ns-host', host)

        if group:

            config.global_set_option('pyro-ns-group', group)

    else:

        assert database

        config = cwconfig.instance_configuration(database)

    repo = get_repository(method, database, config=config)

    if method == 'inmemory':

        vreg = repo.vreg

    elif setvreg:

        if mulcnx:

            multiple_connections_fix()

        vreg = cwvreg.CubicWebVRegistry(config, initlog=initlog)

        schema = repo.get_schema()

        for oldetype, newetype in ETYPE_NAME_MAP.items():

            if oldetype in schema:

                print 'aliasing', newetype, 'to', oldetype

                schema._entities[newetype] = schema._entities[oldetype]

        vreg.set_schema(schema)

    else:

        vreg = None

    cnx = repo_connect(repo, login, cnxprops=cnxprops, **kwargs)

    cnx.vreg = vreg

    return cnx

def in_memory_repo(config):

    """Return and in_memory Repository object from a config (or vreg)"""

    if isinstance(config, cwvreg.CubicWebVRegistry):

        vreg = config

        config = None

    else:

        vreg = None

    # get local access to the repository

    return get_repository('inmemory', config=config, vreg=vreg)

def in_memory_cnx(repo, login, **kwargs):

    """Establish a In memory connection to a <repo> for the user with <login>

    additionel credential might be required"""

    cnxprops = ConnectionProperties('inmemory')

    return repo_connect(repo, login, cnxprops=cnxprops, **kwargs)

def in_memory_repo_cnx(config, login, **kwargs):

    """useful method for testing and scripting to get a dbapi.Connection

    object connected to an in-memory repository instance

    """

    # connection to the CubicWeb repository

    repo = in_memory_repo(config)

    return repo, in_memory_cnx(repo, login, **kwargs)

def anonymous_session(vreg):

    """return a new anonymous session

    raises an AuthenticationError if anonymous usage is not allowed

    """

    anoninfo = vreg.config.anonymous_user()

    if anoninfo is None: # no anonymous user

        raise AuthenticationError('anonymous access is not authorized')

    anon_login, anon_password = anoninfo

    cnxprops = ConnectionProperties(vreg.config.repo_method)

    # use vreg's repository cache

    repo = vreg.config.repository(vreg)

    anon_cnx = repo_connect(repo, anon_login,

                            cnxprops=cnxprops, password=anon_password)

    anon_cnx.vreg = vreg

    return DBAPISession(anon_cnx, anon_login)

class _NeedAuthAccessMock(object):

    def __getattribute__(self, attr):

        raise AuthenticationError()

    def __nonzero__(self):

        return False

class DBAPISession(object):

    def __init__(self, cnx, login=None):

        self.cnx = cnx

        self.data = {}

        self.login = login

        self.mtime = time()

        # dbapi session identifier is the same as the first connection

        # identifier, but may later differ in case of auto-reconnection as done

        # by the web authentication manager (in cw.web.views.authentication)

        if cnx is not None:

            self.sessionid = cnx.sessionid

        else:

            self.sessionid = uuid4().hex

    @property

    def anonymous_session(self):

        return not self.cnx or self.cnx.anonymous_connection

class DBAPIRequest(RequestSessionBase):

    def __init__(self, vreg, session=None):

        super(DBAPIRequest, self).__init__(vreg)

        try:

            # no vreg or config which doesn't handle translations

            self.translations = vreg.config.translations

        except AttributeError:

            self.translations = {}

        self.set_default_language(vreg)

        # cache entities built during the request

        self._eid_cache = {}

        if session is not None:

            self.set_session(session)

        else:

            # these args are initialized after a connection is

            # established

            self.session = None

            self.cnx = self.user = _NeedAuthAccessMock()

    def from_controller(self):

        return 'view'

    def set_session(self, session, user=None):

        """method called by the session handler when the user is authenticated

        or an anonymous connection is open

        """

        self.session = session

        if session.cnx:

            self.cnx = session.cnx

            self.execute = session.cnx.cursor(self).execute

            if user is None:

                user = self.cnx.user(self, {'lang': self.lang})

        if user is not None:

            self.user = user

            self.set_entity_cache(user)

    def execute(self, *args, **kwargs): # pylint: disable=E0202

        """overriden when session is set. By default raise authentication error

        so authentication is requested.

        """

        raise AuthenticationError()

    def set_default_language(self, vreg):

        try:

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

        except Exception: # property may not be registered

            self.lang = 'en'

        # use req.__ to translate a message without registering it to the catalog

        try:

            gettext, pgettext = self.translations[self.lang]

            self._ = self.__ = gettext

            self.pgettext = pgettext

        except KeyError:

            # this occurs usually during test execution

            self._ = self.__ = unicode

            self.pgettext = lambda x, y: y

        self.debug('request default language: %s', self.lang)

    # entities cache management ###############################################

    def entity_cache(self, eid):

        return self._eid_cache[eid]

    def set_entity_cache(self, entity):

        self._eid_cache[entity.eid] = entity

    def cached_entities(self):

        return self._eid_cache.values()

    def drop_entity_cache(self, eid=None):

        if eid is None:

            self._eid_cache = {}

        else:

            del self._eid_cache[eid]

    # low level session data management #######################################

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

        """see :meth:`Connection.get_shared_data`"""

        return self.cnx.get_shared_data(key, default, pop, txdata)

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

        """see :meth:`Connection.set_shared_data`"""

        if querydata is not None:

            txdata = querydata

            warn('[3.10] querydata argument has been renamed to txdata',

                 DeprecationWarning, stacklevel=2)

        return self.cnx.set_shared_data(key, value, txdata)

    # server session compat layer #############################################

    def describe(self, eid, asdict=False):

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

        return self.cnx.describe(eid, asdict)

    def source_defs(self):

        """return the definition of sources used by the repository."""

        return self.cnx.source_defs()

    def hijack_user(self, user):

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

        req = DBAPIRequest(self.vreg)

        req.set_session(self.session, user)

        return req

    @deprecated('[3.8] use direct access to req.session.data dictionary')

    def session_data(self):

        """return a dictionnary containing session data"""

        return self.session.data

    @deprecated('[3.8] use direct access to req.session.data dictionary')

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

        if pop:

            return self.session.data.pop(key, default)

        return self.session.data.get(key, default)

    @deprecated('[3.8] use direct access to req.session.data dictionary')