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

#

# (disable pylint msg for client obj access to protected member as in obj._cw)

# pylint: disable=W0212

"""The ``ajaxcontroller`` module defines the :class:`AjaxController`

controller and the ``ajax-func`` cubicweb registry.

.. autoclass:: cubicweb.web.views.ajaxcontroller.AjaxController

   :members:

``ajax-funcs`` registry hosts exposed remote functions, that is

functions that can be called from the javascript world.

To register a new remote function, either decorate your function

with the :func:`~cubicweb.web.views.ajaxcontroller.ajaxfunc` decorator:

.. sourcecode:: python

    from cubicweb.predicates import mactch_user_groups

    from cubicweb.web.views.ajaxcontroller import ajaxfunc

    @ajaxfunc(output_type='json', selector=match_user_groups('managers'))

    def list_users(self):

        return [u for (u,) in self._cw.execute('Any L WHERE U login L')]

or inherit from :class:`~cubicweb.web.views.ajaxcontroller.AjaxFunction` and

implement the ``__call__`` method:

.. sourcecode:: python

    from cubicweb.web.views.ajaxcontroller import AjaxFunction

    class ListUser(AjaxFunction):

        __regid__ = 'list_users' # __regid__ is the name of the exposed function

        __select__ = match_user_groups('managers')

        output_type = 'json'

        def __call__(self):

            return [u for (u, ) in self._cw.execute('Any L WHERE U login L')]

.. autoclass:: cubicweb.web.views.ajaxcontroller.AjaxFunction

   :members:

.. autofunction:: cubicweb.web.views.ajaxcontroller.ajaxfunc

"""

__docformat__ = "restructuredtext en"

from warnings import warn

from functools import partial

from logilab.common.date import strptime

from logilab.common.registry import yes

from logilab.common.deprecation import deprecated

from cubicweb import ObjectNotFound, NoSelectableObject

from cubicweb.appobject import AppObject

from cubicweb.utils import json, json_dumps, UStringIO

from cubicweb.uilib import exc_message

from cubicweb.web import RemoteCallFailed, DirectResponse

from cubicweb.web.controller import Controller

from cubicweb.web.views import vid_from_rset

from cubicweb.web.views import basecontrollers

def optional_kwargs(extraargs):

    if extraargs is None:

        return {}

    # we receive unicode keys which is not supported by the **syntax

    return dict((str(key), value) for key, value in extraargs.iteritems())

class AjaxController(Controller):

    """AjaxController handles ajax remote calls from javascript

    The following javascript function call:

    .. sourcecode:: javascript

      var d = asyncRemoteExec('foo', 12, "hello");

      d.addCallback(function(result) {

          alert('server response is: ' + result);

      });

    will generate an ajax HTTP GET on the following url::

        BASE_URL/ajax?fname=foo&arg=12&arg="hello"

    The AjaxController controller will therefore be selected to handle those URLs

    and will itself select the :class:`cubicweb.web.views.ajaxcontroller.AjaxFunction`

    matching the *fname* parameter.

    """

    __regid__ = 'ajax'

    def publish(self, rset=None):

        self._cw.ajax_request = True

        try:

            fname = self._cw.form['fname']

        except KeyError:

            raise RemoteCallFailed('no method specified')

        # 1/ check first for old-style (JSonController) ajax func for bw compat

        try:

            func = getattr(basecontrollers.JSonController, 'js_%s' % fname).im_func

            func = partial(func, self)

        except AttributeError:

            # 2/ check for new-style (AjaxController) ajax func

            try:

                func = self._cw.vreg['ajax-func'].select(fname, self._cw)

            except ObjectNotFound:

                raise RemoteCallFailed('no %s method' % fname)

        else:

            warn('[3.15] remote function %s found on JSonController, '

                 'use AjaxFunction / @ajaxfunc instead' % fname,

                 DeprecationWarning, stacklevel=2)

        # no <arg> attribute means the callback takes no argument

        args = self._cw.form.get('arg', ())

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

            args = (args,)

        try:

            args = [json.loads(arg) for arg in args]

        except ValueError as exc:

            self.exception('error while decoding json arguments for '

                           'js_%s: %s (err: %s)', fname, args, exc)

            raise RemoteCallFailed(exc_message(exc, self._cw.encoding))

        try:

            result = func(*args)

        except (RemoteCallFailed, DirectResponse):

            raise

        except Exception as exc:

            self.exception('an exception occurred while calling js_%s(%s): %s',

                           fname, args, exc)

            raise RemoteCallFailed(exc_message(exc, self._cw.encoding))

        if result is None:

            return ''

        # get unicode on @htmlize methods, encoded string on @jsonize methods

        elif isinstance(result, unicode):

            return result.encode(self._cw.encoding)

        return result

class AjaxFunction(AppObject):

    """

    Attributes on this base class are:

    :attr: `check_pageid`: make sure the pageid received is valid before proceeding

    :attr: `output_type`:

           - *None*: no processing, no change on content-type

           - *json*: serialize with `json_dumps` and set *application/json*

                     content-type

           - *xhtml*: wrap result in an XML node and forces HTML / XHTML

                      content-type (use ``_cw.html_content_type()``)

    """

    __registry__ = 'ajax-func'

    __select__ = yes()

    __abstract__ = True

    check_pageid = False

    output_type = None

    @staticmethod

    def _rebuild_posted_form(names, values, action=None):

        form = {}

        for name, value in zip(names, values):

            # remove possible __action_xxx inputs

            if name.startswith('__action'):

                if action is None:

                    # strip '__action_' to get the actual action name

                    action = name[9:]

                continue

            # form.setdefault(name, []).append(value)

            if name in form:

                curvalue = form[name]

                if isinstance(curvalue, list):

                    curvalue.append(value)

                else:

                    form[name] = [curvalue, value]

            else:

                form[name] = value

        # simulate click on __action_%s button to help the controller

        if action:

            form['__action_%s' % action] = u'whatever'

        return form

    def validate_form(self, action, names, values):

        self._cw.form = self._rebuild_posted_form(names, values, action)

        return basecontrollers._validate_form(self._cw, self._cw.vreg)

    def _exec(self, rql, args=None, rocheck=True):

        """json mode: execute RQL and return resultset as json"""

        rql = rql.strip()

        if rql.startswith('rql:'):

            rql = rql[4:]

        if rocheck:

            self._cw.ensure_ro_rql(rql)

        try:

            return self._cw.execute(rql, args)

        except Exception as ex:

            self.exception("error in _exec(rql=%s): %s", rql, ex)

            return None

        return None

    def _call_view(self, view, paginate=False, **kwargs):

        divid = self._cw.form.get('divid')

        # we need to call pagination before with the stream set

        try:

            stream = view.set_stream()

        except AttributeError:

            stream = UStringIO()

            kwargs['w'] = stream.write

            assert not paginate

        if divid == 'pageContent':

            # ensure divid isn't reused by the view (e.g. table view)

            del self._cw.form['divid']

            # mimick main template behaviour

            stream.write(u'<div id="pageContent">')

            vtitle = self._cw.form.get('vtitle')

            if vtitle:

                stream.write(u'<h1 class="vtitle">%s</h1>\n' % vtitle)

            paginate = True

        nav_html = UStringIO()

        if paginate and not view.handle_pagination:

            view.paginate(w=nav_html.write)

        stream.write(nav_html.getvalue())

        if divid == 'pageContent':

            stream.write(u'<div id="contentmain">')

        view.render(**kwargs)

        extresources = self._cw.html_headers.getvalue(skiphead=True)

        if extresources:

            stream.write(u'<div class="ajaxHtmlHead">\n') # XXX use a widget?

            stream.write(extresources)

            stream.write(u'</div>\n')

        if divid == 'pageContent':

            stream.write(u'</div>%s</div>' % nav_html.getvalue())

        return stream.getvalue()

def _ajaxfunc_factory(implementation, selector=yes(), _output_type=None,

                      _check_pageid=False, regid=None):

    """converts a standard python function into an AjaxFunction appobject"""

    class AnAjaxFunc(AjaxFunction):

        __regid__ = regid or implementation.__name__

        __select__ = selector

        output_type = _output_type

        check_pageid = _check_pageid

        def serialize(self, content):

            if self.output_type is None:

                return content

            elif self.output_type == 'xhtml':

                self._cw.set_content_type(self._cw.html_content_type())

                return ''.join((u'<div>',

                                content.strip(), u'</div>'))

            elif self.output_type == 'json':

                self._cw.set_content_type('application/json')

                return json_dumps(content)

            raise RemoteCallFailed('no serializer found for output type %s'

                                   % self.output_type)

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

            if self.check_pageid:

                data = self._cw.session.data.get(self._cw.pageid)

                if data is None:

                    raise RemoteCallFailed(self._cw._('pageid-not-found'))

            return self.serialize(implementation(self, *args, **kwargs))

    AnAjaxFunc.__name__ = implementation.__name__

    # make sure __module__ refers to the original module otherwise

    # vreg.register(obj) will ignore ``obj``.

    AnAjaxFunc.__module__ = implementation.__module__

    # relate the ``implementation`` object to its wrapper appobject

    # will be used by e.g.:

    #   import base_module

    #   @ajaxfunc

    #   def foo(self):

    #       return 42

    #   assert foo(object) == 42

    #   vreg.register_and_replace(foo, base_module.older_foo)

    implementation.__appobject__ = AnAjaxFunc

    return implementation

def ajaxfunc(implementation=None, selector=yes(), output_type=None,

             check_pageid=False, regid=None):

    """promote a standard function to an ``AjaxFunction`` appobject.

    All parameters are optional:

    :param selector: a custom selector object if needed, default is ``yes()``

    :param output_type: either None, 'json' or 'xhtml' to customize output

                        content-type. Default is None

    :param check_pageid: whether the function requires a valid `pageid` or not

                         to proceed. Default is False.

    :param regid: a custom __regid__ for the created ``AjaxFunction`` object. Default

                  is to keep the wrapped function name.

    ``ajaxfunc`` can be used both as a standalone decorator:

    .. sourcecode:: python

        @ajaxfunc

        def my_function(self):

            return 42

    or as a parametrizable decorator:

    .. sourcecode:: python

        @ajaxfunc(output_type='json')

        def my_function(self):

            return 42

    """

    # if used as a parametrized decorator (e.g. @ajaxfunc(output_type='json'))

    if implementation is None:

        def _decorator(func):

            return _ajaxfunc_factory(func, selector=selector,

                                     _output_type=output_type,

                                     _check_pageid=check_pageid,

                                     regid=regid)

        return _decorator

    # else, used as a standalone decorator (i.e. @ajaxfunc)

    return _ajaxfunc_factory(implementation, selector=selector,

                             _output_type=output_type,

                             _check_pageid=check_pageid, regid=regid)

###############################################################################

#  Cubicweb remote functions for :                                            #

#  - appobject rendering                                                      #

#  - user / page session data management                                      #

###############################################################################

@ajaxfunc(output_type='xhtml')

def view(self):

    # XXX try to use the page-content template

    req = self._cw

    rql = req.form.get('rql')

    if rql:

        rset = self._exec(rql)

    elif 'eid' in req.form:

        rset = self._cw.eid_rset(req.form['eid'])

    else:

        rset = None

    vid = req.form.get('vid') or vid_from_rset(req, rset, self._cw.vreg.schema)

    try:

        viewobj = self._cw.vreg['views'].select(vid, req, rset=rset)

    except NoSelectableObject:

        vid = req.form.get('fallbackvid', 'noresult')

        viewobj = self._cw.vreg['views'].select(vid, req, rset=rset)

    viewobj.set_http_cache_headers()

    if req.is_client_cache_valid():

        return ''

    return self._call_view(viewobj, paginate=req.form.pop('paginate', False))

@ajaxfunc(output_type='xhtml')

def component(self, compid, rql, registry='components', extraargs=None):

    if rql:

        rset = self._exec(rql)

    else:

        rset = None

    # XXX while it sounds good, addition of the try/except below cause pb:

    # when filtering using facets return an empty rset, the edition box

    # isn't anymore selectable, as expected. The pb is that with the

    # try/except below, we see a "an error occurred" message in the ui, while

    # we don't see it without it. Proper fix would probably be to deal with

    # this by allowing facet handling code to tell to js_component that such

    # error is expected and should'nt be reported.

    #try:

    comp = self._cw.vreg[registry].select(compid, self._cw, rset=rset,

                                          **optional_kwargs(extraargs))

    #except NoSelectableObject:

    #    raise RemoteCallFailed('unselectable')

    return self._call_view(comp, **optional_kwargs(extraargs))

@ajaxfunc(output_type='xhtml')

def render(self, registry, oid, eid=None,

              selectargs=None, renderargs=None):

    if eid is not None:

        rset = self._cw.eid_rset(eid)

        # XXX set row=0

    elif self._cw.form.get('rql'):

        rset = self._cw.execute(self._cw.form['rql'])

    else:

        rset = None

    viewobj = self._cw.vreg[registry].select(oid, self._cw, rset=rset,

                                             **optional_kwargs(selectargs))

    return self._call_view(viewobj, **optional_kwargs(renderargs))

@ajaxfunc(output_type='json')