# copyright 2003-2016 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/>.

"""Base class for request/session"""

__docformat__ = "restructuredtext en"

from warnings import warn

from datetime import time, datetime, timedelta

from six import PY2, PY3, text_type

from six.moves.urllib.parse import (parse_qs, parse_qsl,

                                    quote as urlquote, unquote as urlunquote,

                                    urlsplit, urlunsplit)

from logilab.common.decorators import cached

from logilab.common.deprecation import deprecated

from logilab.common.date import ustrftime, strptime, todate, todatetime

from rql.utils import rqlvar_maker

from cubicweb import (Unauthorized, NoSelectableObject, NoResultError,

                      MultipleResultsError, uilib)

from cubicweb.rset import ResultSet

ONESECOND = timedelta(0, 1, 0)

CACHE_REGISTRY = {}

class FindEntityError(Exception):

    """raised when find_one_entity() can not return one and only one entity"""

class Cache(dict):

    def __init__(self):

        super(Cache, self).__init__()

        _now = datetime.now()

        self.cache_creation_date = _now

        self.latest_cache_lookup = _now

class RequestSessionBase(object):

    """base class containing stuff shared by server session and web request

    request/session is the main resources accessor, mainly through it's vreg

    attribute:

    :attribute vreg: the instance's registry

    :attribute vreg.schema: the instance's schema

    :attribute vreg.config: the instance's configuration

    """

    is_request = True  # False for repository session

    def __init__(self, vreg):

        self.vreg = vreg

        try:

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

        except Exception:  # no vreg or property not registered

            encoding = 'utf-8'

        self.encoding = encoding

        # cache result of execution for (rql expr / eids),

        # should be emptied on commit/rollback of the server session / web

        # connection

        self.user = None

        self.local_perm_cache = {}

        self._ = text_type

    def _set_user(self, orig_user):

        """set the user for this req_session_base

        A special method is needed to ensure the linked user is linked to the

        connection too.

        """

        rset = self.eid_rset(orig_user.eid, 'CWUser')

        self.user = user

        self.set_entity_cache(user)

    def set_language(self, lang):

        """install i18n configuration for `lang` translation.

        Raises :exc:`KeyError` if translation doesn't exist.

        """

        self.lang = lang

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

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

        self._ = self.__ = gettext

        self.pgettext = pgettext

    def get_option_value(self, option):

        raise NotImplementedError

    def property_value(self, key):

        """return value of the property with the given key, giving priority to

        user specific value if any, else using site value

        """

        if self.user:

            val = self.user.property_value(key)

            if val is not None:

                return val

        return self.vreg.property_value(key)

    def etype_rset(self, etype, size=1):

        """return a fake result set for a particular entity type"""

        rset = ResultSet([('A',)] * size, '%s X' % etype,

                         description=[(etype,)] * size)

        def get_entity(row, col=0, etype=etype, req=self, rset=rset):

            return req.vreg['etypes'].etype_class(etype)(req, rset, row, col)

        rset.get_entity = get_entity

        rset.req = self

        return rset

    def eid_rset(self, eid, etype=None):

        """return a result set for the given eid without doing actual query

        (we have the eid, we can suppose it exists and user has access to the

        entity)

        """

        eid = int(eid)

        if etype is None:

            etype = self.entity_metas(eid)['type']

        rset = ResultSet([(eid,)], 'Any X WHERE X eid %(x)s', {'x': eid},

                         [(etype,)])

        rset.req = self

        return rset

    def empty_rset(self):

        """ return a guaranteed empty result """

        rset = ResultSet([], 'Any X WHERE X eid -1')

        rset.req = self

        return rset

    def entity_from_eid(self, eid, etype=None):

        """return an entity instance for the given eid. No query is done"""

        try:

            return self.entity_cache(eid)

        except KeyError:

            rset = self.eid_rset(eid, etype)

            entity = rset.get_entity(0, 0)

            self.set_entity_cache(entity)

            return entity

    def entity_cache(self, eid):

        raise KeyError

    def set_entity_cache(self, entity):

        pass

    def create_entity(self, etype, **kwargs):

        """add a new entity of the given type

        Example (in a shell session):

        >>> c = create_entity('Company', name=u'Logilab')

        >>> create_entity('Person', firstname=u'John', surname=u'Doe',

        ...               works_for=c)

        """

        cls = self.vreg['etypes'].etype_class(etype)

        return cls.cw_instantiate(self.execute, **kwargs)

    @deprecated('[3.18] use find(etype, **kwargs).entities()')

    def find_entities(self, etype, **kwargs):

        """find entities of the given type and attribute values.

        >>> users = find_entities('CWGroup', name=u'users')

        >>> groups = find_entities('CWGroup')

        """

        return self.find(etype, **kwargs).entities()

    @deprecated('[3.18] use find(etype, **kwargs).one()')

    def find_one_entity(self, etype, **kwargs):

        """find one entity of the given type and attribute values.

        raise :exc:`FindEntityError` if can not return one and only one entity.

        >>> users = find_one_entity('CWGroup', name=u'users')

        >>> groups = find_one_entity('CWGroup')

        Exception()

        """

        try:

            return self.find(etype, **kwargs).one()

        except (NoResultError, MultipleResultsError) as e:

            raise FindEntityError("%s: (%s, %s)" % (str(e), etype, kwargs))

    def find(self, etype, **kwargs):

        """find entities of the given type and attribute values.

        :returns: A :class:`ResultSet`

        >>> users = find('CWGroup', name=u"users").one()

        >>> groups = find('CWGroup').entities()

        """

        parts = ['Any X WHERE X is %s' % etype]

        varmaker = rqlvar_maker(defined='X')

        eschema = self.vreg.schema.eschema(etype)

        for attr, value in kwargs.items():

            if isinstance(value, list) or isinstance(value, tuple):

                raise NotImplementedError("List of values are not supported")

            if hasattr(value, 'eid'):

                kwargs[attr] = value.eid

            if attr.startswith('reverse_'):

                attr = attr[8:]

                assert attr in eschema.objrels, \

                    '%s not in %s object relations' % (attr, eschema)

                parts.append(

                    '%(varname)s %(attr)s X, '

                    '%(varname)s eid %%(reverse_%(attr)s)s'

                    % {'attr': attr, 'varname': next(varmaker)})

            else:

                assert attr in eschema.subjrels, \

                    '%s not in %s subject relations' % (attr, eschema)

                parts.append('X %(attr)s %%(%(attr)s)s' % {'attr': attr})

        rql = ', '.join(parts)

        return self.execute(rql, kwargs)

    def ensure_ro_rql(self, rql):

        """raise an exception if the given rql is not a select query"""

        first = rql.split(None, 1)[0].lower()

        if first in ('insert', 'set', 'delete'):

            raise Unauthorized(self._('only select queries are authorized'))

    def get_cache(self, cachename):

        """cachename should be dotted names as in :

        - cubicweb.mycache

        - cubes.blog.mycache

        - etc.

        """

        warn.warning('[3.19] .get_cache will disappear soon. '

                     'Distributed caching mechanisms are being introduced instead.'

                     'Other caching mechanism can be used more reliably '

                     'to the same effect.',

                     DeprecationWarning)

        if cachename in CACHE_REGISTRY:

            cache = CACHE_REGISTRY[cachename]

        else:

            cache = CACHE_REGISTRY[cachename] = Cache()

        _now = datetime.now()

        if _now > cache.latest_cache_lookup + ONESECOND:

            ecache = self.execute(

                'Any C,T WHERE C is CWCache, C name %(name)s, C timestamp T',

                {'name': cachename}).get_entity(0, 0)

            cache.latest_cache_lookup = _now

            if not ecache.valid(cache.cache_creation_date):

                cache.clear()

                cache.cache_creation_date = _now

        return cache

    # url generation methods ##################################################

    def build_url(self, *args, **kwargs):

        """return an absolute URL using params dictionary key/values as URL

        parameters. Values are automatically URL quoted, and the

        publishing method to use may be specified or will be guessed.

        if ``__secure__`` argument is True, the request will try to build a

        https url.

        raises :exc:`ValueError` if None is found in arguments

        """

        # use *args since we don't want first argument to be "anonymous" to

        # avoid potential clash with kwargs

        method = None

        if args:

            assert len(args) == 1, 'only 0 or 1 non-named-argument expected'

            method = args[0]

        if method is None:

            method = 'view'

        # XXX I (adim) think that if method is passed explicitly, we should

        #     not try to process it and directly call req.build_url()

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

        if base_url is None:

            secure = kwargs.pop('__secure__', None)

            base_url = self.base_url(secure=secure)

        if '_restpath' in kwargs:

            assert method == 'view', repr(method)

            path = kwargs.pop('_restpath')

        else:

            path = method

        if not kwargs:

            return u'%s%s' % (base_url, path)

        return u'%s%s?%s' % (base_url, path, self.build_url_params(**kwargs))

    def build_url_params(self, **kwargs):

        """return encoded params to incorporate them in a URL"""

        args = []

        for param, values in kwargs.items():

            if not isinstance(values, (list, tuple)):

                values = (values,)

            for value in values:

                assert value is not None

                args.append(u'%s=%s' % (param, self.url_quote(value)))

        return '&'.join(args)

    def url_quote(self, value, safe=''):

        """urllib.quote is not unicode safe, use this method to do the

        necessary encoding / decoding. Also it's designed to quote each

        part of a url path and so the '/' character will be encoded as well.

        """

        if PY2 and isinstance(value, unicode):

            quoted = urlquote(value.encode(self.encoding), safe=safe)

            return unicode(quoted, self.encoding)

        return urlquote(str(value), safe=safe)

    def url_unquote(self, quoted):

        """returns a unicode unquoted string

        decoding is based on `self.encoding` which is the encoding

        used in `url_quote`

        """

        if PY3:

            return urlunquote(quoted)

        if isinstance(quoted, unicode):

            quoted = quoted.encode(self.encoding)

        try:

            return unicode(urlunquote(quoted), self.encoding)

        except UnicodeDecodeError:  # might occurs on manually typed URLs

            return unicode(urlunquote(quoted), 'iso-8859-1')

    def url_parse_qsl(self, querystring):

        """return a list of (key, val) found in the url quoted query string"""

        if PY3:

            for key, val in parse_qsl(querystring):

                yield key, val

            return

        if isinstance(querystring, unicode):

            querystring = querystring.encode(self.encoding)

        for key, val in parse_qsl(querystring):

            try:

                yield unicode(key, self.encoding), unicode(val, self.encoding)

            except UnicodeDecodeError:  # might occurs on manually typed URLs

                yield unicode(key, 'iso-8859-1'), unicode(val, 'iso-8859-1')

    def rebuild_url(self, url, **newparams):

        """return the given url with newparams inserted. If any new params

        is already specified in the url, it's overriden by the new value

        newparams may only be mono-valued.

        """

        if PY2 and isinstance(url, unicode):

            url = url.encode(self.encoding)

        schema, netloc, path, query, fragment = urlsplit(url)

        query = parse_qs(query)

        # sort for testing predictability

        for key, val in sorted(newparams.items()):

            query[key] = (self.url_quote(val),)

        query = '&'.join(u'%s=%s' % (param, value)

                         for param, values in sorted(query.items())

                         for value in values)

        return urlunsplit((schema, netloc, path, query, fragment))

    # bound user related methods ###############################################

    @cached

    def user_data(self):

        """returns a dictionary with this user's information.

        The keys are :

        login

            The user login

        name

            The user name, returned by user.name()

        email

            The user principal email

        """

        userinfo = {}