# copyright 2003-2010 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 logging import getLogger

from time import time, clock

from itertools import count

from warnings import warn

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

        try:

            return ns_get_proxy(database,

                                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 for

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

    """

    config = cwconfig.CubicWebNoAppConfiguration()

    if host:

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

    if group:

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

    cnxprops = cnxprops or ConnectionProperties()

    method = cnxprops.cnxtype

    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_cnx(config, login, **kwargs):

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

    object connected to an in-memory repository instance

    """

    if isinstance(config, cwvreg.CubicWebVRegistry):

        vreg = config

        config = None

    else:

        vreg = None

    # get local access to the repository

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

    # connection to the CubicWeb repository

    cnxprops = ConnectionProperties('inmemory')

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

    return repo, cnx

class _NeedAuthAccessMock(object):

    def __getattribute__(self, attr):

        raise AuthenticationError()

    def __nonzero__(self):

        return False

class DBAPISession(object):

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

        self.cnx = cnx

        self.data = {}

        self.login = login

        self.authinfo = authinfo

        # 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 = None

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

        return self.vreg.config['base-url']

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

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

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

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

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

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

        if `querydata` is true, the value will be added to the repository

        session's query data which are cleared on commit/rollback of the current

        transaction, and won't be available through the connexion, only on the

        repository side.

        """

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

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

    def describe(self, eid):

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

        return self.cnx.describe(eid)

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

    def set_session_data(self, key, value):

        self.session.data[key] = value

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

    def del_session_data(self, key):

        self.session.data.pop(key, None)

set_log_methods(DBAPIRequest, getLogger('cubicweb.dbapi'))

# exceptions ##################################################################

class ProgrammingError(Exception): #DatabaseError):

    """Exception raised for errors that are related to the database's operation

    and not necessarily under the control of the programmer, e.g. an unexpected

    disconnect occurs, the data source name is not found, a transaction could

    not be processed, a memory allocation error occurred during processing,

    etc.

    """

# cursor / connection objects ##################################################

class Cursor(object):

    """These objects represent a database cursor, which is used to manage the

    context of a fetch operation. Cursors created from the same connection are

    not isolated, i.e., any changes done to the database by a cursor are

    immediately visible by the other cursors. Cursors created from different

    connections are isolated.

    """

    def __init__(self, connection, repo, req=None):

        """This read-only attribute return a reference to the Connection

        object on which the cursor was created.

        """

        self.connection = connection

        """optionnal issuing request instance"""

        self.req = req

        self._repo = repo

        self._sessid = connection.sessionid

    def close(self):