# copyright 2003-2013 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 urlparse import  urlparse

from logilab.common.logging_ext import set_log_methods

from logilab.common.decorators import monkeypatch, cachedproperty

from logilab.common.deprecation import deprecated

from cubicweb import (ETYPE_NAME_MAP, AuthenticationError, ProgrammingError,

                      cwvreg, cwconfig)

from cubicweb.repoapi import get_repository

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.CWRegistryStore.REGISTRY_FACTORY[None]

    etypescls = cwvreg.CWRegistryStore.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.CWRegistryStore.REGISTRY_FACTORY['etypes']

    etypescls.etype_class = etypescls.orig_etype_class

class ConnectionProperties(object):

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

        if cnxtype is not None:

            warn('[3.16] cnxtype argument is deprecated', DeprecationWarning,

                 stacklevel=2)

        self.cnxtype = cnxtype

        self.log_queries = log

        self.close_on_del = close

@deprecated('[3.19] the dbapi is deprecated. Have a look at the new repoapi.')

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

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

    Returns a Connection instance.

    Raises AuthenticationError if authentication failed

    """

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

    cnx = Connection(repo, cnxid, kwargs.get('cnxprops'))

    if cnx.is_repo_in_memory:

        cnx.vreg = repo.vreg

    return cnx

def connect(database, login=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')

    `database` may be:

    * a simple instance id for in-memory connection

    * an uri like scheme://host:port/instanceid where scheme may be one of

      'pyro', 'inmemory' or 'zmqpickle'

      * if scheme is 'pyro', <host:port> determine the name server address. If

        not specified (e.g. 'pyro:///instanceid'), it will be detected through a

        broadcast query. The instance id is the name of the instance in the name

        server and may be prefixed by a group (e.g.

        'pyro:///:cubicweb.instanceid')

      * if scheme is handled by ZMQ (eg 'tcp'), you should not specify an

        instance id

    Other arguments:

    :login:

      the user login to use to authenticate.

    :cnxprops:

      a :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.

    """

    if not urlparse(database).scheme:

        warn('[3.16] give an qualified URI as database instead of using '

             'host/cnxprops to specify the connection method',

             DeprecationWarning, stacklevel=2)

        if cnxprops and cnxprops.cnxtype == 'zmq':

            database = kwargs.pop('host')

        elif cnxprops and cnxprops.cnxtype == 'inmemory':

            database = 'inmemory://' + database

        else:

            host = kwargs.pop('host', None)

            if host is None:

                host = ''

            group = kwargs.pop('group', None)

            if group is None:

                group = 'cubicweb'

            database = 'pyro://%s/%s.%s' % (host, group, database)

    puri = urlparse(database)

    method = puri.scheme.lower()

    if method == 'inmemory':

        config = cwconfig.instance_configuration(puri.netloc)

    else:

        config = cwconfig.CubicWebNoAppConfiguration()

    repo = get_repository(database, config=config)

    if method == 'inmemory':

        vreg = repo.vreg

    elif setvreg:

        if mulcnx:

            multiple_connections_fix()

        vreg = cwvreg.CWRegistryStore(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.CWRegistryStore):

        vreg = config

        config = None

    else:

        vreg = None

    # get local access to the repository

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

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, _repo_connect(repo, login, **kwargs)

# XXX web only method, move to webconfig?

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[0] is None: # no anonymous user

        raise AuthenticationError('anonymous access is not authorized')

    anon_login, anon_password = anoninfo

    # use vreg's repository cache

    repo = vreg.config.repository(vreg)

    anon_cnx = _repo_connect(repo, anon_login, 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

        # 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

    def __repr__(self):

        return '<DBAPISession %r>' % self.sessionid

class DBAPIRequest(RequestSessionBase):

    #: Request language identifier eg: 'en'

    lang = None

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

        super(DBAPIRequest, self).__init__(vreg)

        #: 'language' => translation_function() mapping

        try:

            # no vreg or config which doesn't handle translations

            self.translations = vreg.config.translations

        except AttributeError:

            self.translations = {}

        #: 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 = DBAPISession(None)

            self.cnx = self.user = _NeedAuthAccessMock()

        self.set_default_language(vreg)

    def get_option_value(self, option, foreid=None):

        if foreid is not None:

            warn('[3.19] foreid argument is deprecated', DeprecationWarning,

                 stacklevel=2)

        return self.cnx.get_option_value(option)

    def set_session(self, session):

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

            self.user = self.cnx.user(self)

            self.set_entity_cache(self.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:

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

        except Exception: # property may not be registered

            lang = 'en'

        try:

            self.set_language(lang)

        except KeyError:

            # this occurs usually during test execution

            self._ = self.__ = unicode

            self.pgettext = lambda x, y: unicode(y)

    # server-side service call #################################################

    def call_service(self, regid, **kwargs):

        return self.cnx.call_service(regid, **kwargs)

    # 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 entity_metas(self, eid):

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

        return self.cnx.entity_metas(eid)

    def source_defs(self):

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

        return self.cnx.source_defs()

    @deprecated('[3.19] use .entity_metas(eid) instead')

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

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

        return self.cnx.describe(eid, asdict)

    # these are overridden by set_log_methods below

    # only defining here to prevent pylint from complaining

    info = warning = error = critical = exception = debug = lambda msg,*a,**kw: None

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

# 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