# 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

from logilab.common.deprecation import deprecated

from cubicweb import ETYPE_NAME_MAP, ConnectionError, AuthenticationError,\

     cwvreg, cwconfig

from cubicweb.req import RequestSessionBase

from cubicweb.utils import parse_repo_uri

_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

def _get_inmemory_repo(config, vreg=None):

    from cubicweb.server.repository import Repository

    from cubicweb.server.utils import TasksManager

    return Repository(config, TasksManager(), vreg=vreg)

def get_repository(uri=None, config=None, vreg=None):

    """get a repository for the given URI or config/vregistry (in case we're

    loading the repository for a client, eg web server, configuration).

    The returned repository may be an in-memory repository or a proxy object

    using a specific RPC method, depending on the given URI (pyro or zmq).

    """

    try:

        return _get_repository(uri, config, vreg)

    except ConnectionError:

        raise

    except Exception as exc:

        raise ConnectionError('cause: %r' % exc)

def _get_repository(uri=None, config=None, vreg=None):

    """ implements get_repository (see above) """

    if uri is None:

        return _get_inmemory_repo(config, vreg)

    protocol, hostport, appid = parse_repo_uri(uri)

    if protocol == 'inmemory':

        # me may have been called with a dummy 'inmemory://' uri ...

        return _get_inmemory_repo(config, vreg)

    if protocol == 'pyroloc': # direct connection to the instance

        from logilab.common.pyro_ext import get_proxy

        uri = uri.replace('pyroloc', 'PYRO')

        return get_proxy(uri)

    if protocol == 'pyro': # connection mediated through the pyro ns

        from logilab.common.pyro_ext import ns_get_proxy

        path = appid.strip('/')

        if not path:

            raise ConnectionError(

                "can't find instance name in %s (expected to be the path component)"

                % uri)

        if '.' in path:

            nsgroup, nsid = path.rsplit('.', 1)

        else:

            nsgroup = 'cubicweb'

            nsid = path

        return ns_get_proxy(nsid, defaultnsgroup=nsgroup, nshost=hostport)

    if protocol.startswith('zmqpickle-'):

        from cubicweb.zmqclient import ZMQRepositoryClient

        return ZMQRepositoryClient(uri)

    else:

        raise ConnectionError('unknown protocol: `%s`' % protocol)

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 urlparse(database).scheme is None:

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

             'host/cnxprops to specify the connection method',

             DeprecationWarning, stacklevel=2)

        if cnxprops.cnxtype == 'zmq':

            database = kwargs.pop('host')

        elif cnxprops.cnxtype == 'inmemory':

            database = 'inmemory://' + database

        else:

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

                                            kwargs.pop('group', 'cubicweb'),

                                            database)

    puri = urlparse(database)

    method = puri.scheme.lower()

    if method == 'inmemory':

        config = cwconfig.instance_configuration(puri.path)

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

        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

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

            self.cnx = self.user = _NeedAuthAccessMock()

        self.set_default_language(vreg)

    def from_controller(self):

        return 'view'

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

        return self.cnx.get_option_value(option, foreid)

    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)

        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:

            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, async=False, **kwargs):

        return self.cnx.call_service(regid, async, **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 = {}