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

"""abstract component class and base components definition for CubicWeb web

client

"""

__docformat__ = "restructuredtext en"

_ = unicode

from warnings import warn

from logilab.common.deprecation import class_deprecated, class_renamed, deprecated

from logilab.mtconverter import xml_escape

from cubicweb import Unauthorized, role, target, tags

from cubicweb.schema import display_name

from cubicweb.uilib import js, domid

from cubicweb.utils import json_dumps, js_href

from cubicweb.view import ReloadableMixIn, Component

from cubicweb.predicates import (no_cnx, paginated_rset, one_line_rset,

                                non_final_entity, partial_relation_possible,

                                partial_has_related_entities)

from cubicweb.appobject import AppObject

from cubicweb.web import INTERNAL_FIELD_VALUE, stdmsgs

# abstract base class for navigation components ################################

class NavigationComponent(Component):

    """abstract base class for navigation components"""

    __regid__ = 'navigation'

    __select__ = paginated_rset()

    cw_property_defs = {

        _('visible'):  dict(type='Boolean', default=True,

                            help=_('display the component or not')),

        }

    page_size_property = 'navigation.page-size'

    start_param = '__start'

    stop_param = '__stop'

    page_link_templ = u'<span class="slice"><a href="%s" title="%s">%s</a></span>'

    selected_page_link_templ = u'<span class="selectedSlice"><a href="%s" title="%s">%s</a></span>'

    previous_page_link_templ = next_page_link_templ = page_link_templ

    def __init__(self, req, rset, **kwargs):

        super(NavigationComponent, self).__init__(req, rset=rset, **kwargs)

        self.starting_from = 0

        self.total = rset.rowcount

    def get_page_size(self):

        try:

            return self._page_size

        except AttributeError:

            page_size = self.cw_extra_kwargs.get('page_size')

            if page_size is None:

                if 'page_size' in self._cw.form:

                    page_size = int(self._cw.form['page_size'])

                else:

                    page_size = self._cw.property_value(self.page_size_property)

            self._page_size = page_size

            return page_size

    def set_page_size(self, page_size):

        self._page_size = page_size

    page_size = property(get_page_size, set_page_size)

    def page_boundaries(self):

        try:

            stop = int(self._cw.form[self.stop_param]) + 1

            start = int(self._cw.form[self.start_param])

        except KeyError:

            start, stop = 0, self.page_size

        if start >= len(self.cw_rset):

            start, stop = 0, self.page_size

        self.starting_from = start

        return start, stop

    def clean_params(self, params):

        if self.start_param in params:

            del params[self.start_param]

        if self.stop_param in params:

            del params[self.stop_param]

    def page_url(self, path, params, start=None, stop=None):

        params = dict(params)

        params['__fromnavigation'] = 1

        if start is not None:

            params[self.start_param] = start

        if stop is not None:

            params[self.stop_param] = stop

        view = self.cw_extra_kwargs.get('view')

        if view is not None and hasattr(view, 'page_navigation_url'):

            url = view.page_navigation_url(self, path, params)

            url = self.ajax_page_url(**params)

        # XXX hack to avoid opening a new page containing the evaluation of the

        # js expression on ajax call

        if url.startswith('javascript:'):

            url += '; $.noop();'

        return url

    def ajax_page_url(self, **params):

        divid = params.setdefault('divid', 'pageContent')

        params['rql'] = self.cw_rset.printable_rql()

    def page_link(self, path, params, start, stop, content):

        url = xml_escape(self.page_url(path, params, start, stop))

        if start == self.starting_from:

            return self.selected_page_link_templ % (url, content, content)

        return self.page_link_templ % (url, content, content)

    @property

    def prev_icon_url(self):

        return xml_escape(self._cw.data_url('go_prev.png'))

    @property

    def next_icon_url(self):

        return xml_escape(self._cw.data_url('go_next.png'))

    @property

    def no_previous_page_link(self):

        return (u'<img src="%s" alt="%s" class="prevnext_nogo"/>' %

                (self.prev_icon_url, self._cw._('there is no previous page')))

    @property

    def no_next_page_link(self):

        return (u'<img src="%s" alt="%s" class="prevnext_nogo"/>' %

                (self.next_icon_url, self._cw._('there is no next page')))

    @property

    def no_content_prev_link(self):

        return (u'<img src="%s" alt="%s" class="prevnext"/>' % (

                (self.prev_icon_url, self._cw._('no content prev link'))))

    @property

    def no_content_next_link(self):

        return (u'<img src="%s" alt="%s" class="prevnext"/>' %

                (self.next_icon_url, self._cw._('no content next link')))

    def previous_link(self, path, params, content=None, title=_('previous_results')):

        if not content:

            content = self.no_content_prev_link

        start = self.starting_from

        if not start :

            return self.no_previous_page_link

        start = max(0, start - self.page_size)

        stop = start + self.page_size - 1

        url = xml_escape(self.page_url(path, params, start, stop))

        return self.previous_page_link_templ % (url, self._cw._(title), content)

    def next_link(self, path, params, content=None, title=_('next_results')):

        if not content:

            content = self.no_content_next_link

        start = self.starting_from + self.page_size

        if start >= self.total:

            return self.no_next_page_link

        stop = start + self.page_size - 1

        url = xml_escape(self.page_url(path, params, start, stop))

        return self.next_page_link_templ % (url, self._cw._(title), content)

# new contextual components system #############################################

def override_ctx(cls, **kwargs):

    cwpdefs = cls.cw_property_defs.copy()

    cwpdefs['context']  = cwpdefs['context'].copy()

    cwpdefs['context'].update(kwargs)

    return cwpdefs

class EmptyComponent(Exception):

    """some selectable component has actually no content and should not be

    rendered

    """

class Link(object):

    """a link to a view or action in the ui.

    Use this rather than `cw.web.htmlwidgets.BoxLink`.

    Note this class could probably be avoided with a proper DOM on the server

    side.

    """

    newstyle = True

    def __init__(self, href, label, **attrs):

        self.href = href

        self.label = label

        self.attrs = attrs

    def __unicode__(self):

        return tags.a(self.label, href=self.href, **self.attrs)

    def render(self, w):

        w(tags.a(self.label, href=self.href, **self.attrs))

class Separator(object):

    """a menu separator.

    Use this rather than `cw.web.htmlwidgets.BoxSeparator`.

    """

    newstyle = True

    def render(self, w):

        w(u'<hr class="boxSeparator"/>')

def _bwcompatible_render_item(w, item):

    if hasattr(item, 'render'):

        if getattr(item, 'newstyle', False):

            if isinstance(item, Separator):

                w(u'</ul>')

                item.render(w)

                w(u'<ul>')

            else:

                w(u'<li>')

                item.render(w)

                w(u'</li>')

        else:

            item.render(w) # XXX displays <li> by itself

    else:

        w(u'<li>%s</li>' % item)

class Layout(Component):

    __regid__ = 'component_layout'

    __abstract__ = True

    def init_rendering(self):

        """init view for rendering. Return true if we should go on, false

        if we should stop now.

        """

        view = self.cw_extra_kwargs['view']

        try:

            view.init_rendering()

        except Unauthorized as ex:

            self.warning("can't render %s: %s", view, ex)

            return False

        except EmptyComponent:

            return False

        return True

class LayoutableMixIn(object):

    layout_id = None # to be defined in concret class

    layout_args = {}

    def layout_render(self, w):

        getlayout = self._cw.vreg['components'].select

        layout = getlayout(self.layout_id, self._cw, **self.layout_select_args())

        layout.render(w)

    def layout_select_args(self):

        args  = dict(rset=self.cw_rset, row=self.cw_row, col=self.cw_col,

                     view=self)

        args.update(self.layout_args)

        return args

class CtxComponent(LayoutableMixIn, AppObject):

    """base class for contextual components. The following contexts are

    predefined:

    * boxes: 'left', 'incontext', 'right'

    * section: 'navcontenttop', 'navcontentbottom', 'navtop', 'navbottom'

    * other: 'ctxtoolbar'

    The 'incontext', 'navcontenttop', 'navcontentbottom' and 'ctxtoolbar'

    contexts are handled by the default primary view, others by the default main

    template.

    All subclasses may not support all those contexts (for instance if it can't

    be displayed as box, or as a toolbar icon). You may restrict allowed context

    as follows:

    .. sourcecode:: python

      class MyComponent(CtxComponent):

          cw_property_defs = override_ctx(CtxComponent,

                                          vocabulary=[list of contexts])

          context = 'my default context'

    You can configure a component's default context by simply giving an

    appropriate value to the `context` class attribute, as seen above.

    """

    __registry__ = 'ctxcomponents'

    __select__ = ~no_cnx()

    categories_in_order = ()

    cw_property_defs = {

        _('visible'): dict(type='Boolean', default=True,

                           help=_('display the box or not')),

        _('order'):   dict(type='Int', default=99,

                           help=_('display order of the box')),

        _('context'): dict(type='String', default='left',

                           vocabulary=(_('left'), _('incontext'), _('right'),

                                       _('navtop'), _('navbottom'),

                                       _('navcontenttop'), _('navcontentbottom'),

                                       _('ctxtoolbar')),

                           help=_('context where this component should be displayed')),

        }

    visible = True

    order = 0

    context = 'left'

    contextual = False

    title = None

    layout_id = 'component_layout'

    # XXX support kwargs for compat with old boxes which gets the view as

    # argument

    def render(self, w, **kwargs):

        if hasattr(self, 'call'):

            warn('[3.10] should not anymore implement call on %s, see new CtxComponent api'

                 % self.__class__, DeprecationWarning)

            self.w = w

            def wview(__vid, rset=None, __fallback_vid=None, **kwargs):

                self._cw.view(__vid, rset, __fallback_vid, w=self.w, **kwargs)

            self.wview = wview

            self.call(**kwargs) # pylint: disable=E1101

            return

        self.layout_render(w)

    def layout_select_args(self):

        args = super(CtxComponent, self).layout_select_args()

        try:

            # XXX ensure context is given when the component is reloaded through

            # ajax

            args['context'] = self.cw_extra_kwargs['context']

        except KeyError:

            args['context'] = self.cw_propval('context')

        return args

    def init_rendering(self):

        """init rendering callback: that's the good time to check your component

        has some content to display. If not, you can still raise

        :exc:`EmptyComponent` to inform it should be skipped.

        Also, :exc:`Unauthorized` will be catched, logged, then the component

        will be skipped.

        """

        self.items = []

    @property

    def domid(self):

        """return the HTML DOM identifier for this component"""

        return domid(self.__regid__)

    @property

    def cssclass(self):

        """return the CSS class name for this component"""

        return domid(self.__regid__)

    def render_title(self, w):

        """return the title for this component"""

        if self.title:

            w(self._cw._(self.title))

    def render_body(self, w):

        """return the body (content) for this component"""

        raise NotImplementedError()