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

"""Specific views for CWProperty (eg site/user preferences"""

__docformat__ = "restructuredtext en"

_ = unicode

from logilab.mtconverter import xml_escape

from logilab.common.decorators import cached

from cubicweb import UnknownProperty

from cubicweb.selectors import (one_line_rset, none_rset, is_instance,

                                match_user_groups, objectify_selector,

                                logged_user_in_rset)

from cubicweb.view import StartupView

from cubicweb.web import uicfg, stdmsgs

from cubicweb.web.form import FormViewMixIn

from cubicweb.web.formfields import FIELDS, StringField

from cubicweb.web.formwidgets import (Select, TextInput, Button, SubmitButton,

                                      FieldWidget)

from cubicweb.web.views import primary, formrenderers, editcontroller

uicfg.primaryview_section.tag_object_of(('*', 'for_user', '*'), 'hidden')

# some string we want to be internationalizable for nicer display of property

# groups

_('navigation')

_('ui')

_('boxes')

_('components')

_('ctxcomponents')

_('navigation.combobox-limit')

_('navigation.page-size')

_('navigation.related-limit')

_('navigation.short-line-size')

_('ui.date-format')

_('ui.datetime-format')

_('ui.default-text-format')

_('ui.fckeditor')

_('ui.float-format')

_('ui.language')

_('ui.time-format')

_('open all')

_('ui.main-template')

_('ui.site-title')

_('ui.encoding')

_('category')

def make_togglable_link(nodeid, label):

    """builds a HTML link that switches the visibility & remembers it"""

    return u'<a href="javascript: togglePrefVisibility(\'%s\')">%s</a>' % (

        nodeid, label)

def css_class(someclass):

    return someclass and 'class="%s"' % someclass or ''

class CWPropertyPrimaryView(primary.PrimaryView):

    __select__ = is_instance('CWProperty')

    skip_none = False

class SystemCWPropertiesForm(FormViewMixIn, StartupView):

    """site-wide properties edition form"""

    __regid__ = 'systempropertiesform'

    __select__ = none_rset() & match_user_groups('managers')

    form_buttons = [SubmitButton()]

    title = _('site configuration')

    category = 'startupview'

    def linkable(self):

        return True

    def url(self):

        """return the url associated with this view. We can omit rql here"""

        return self._cw.build_url('view', vid=self.__regid__)

    def _cookie_name(self, somestr):

        return str('%s_property_%s' % (self._cw.vreg.config.appid, somestr))

    def _group_status(self, group, default=u'hidden'):

        """return css class name 'hidden' (collapsed), or '' (open)"""

        cookies = self._cw.get_cookie()

        cookiename = self._cookie_name(group)

        cookie = cookies.get(cookiename)

        if cookie is None:

            self._cw.set_cookie(cookiename, default, maxage=None)

            status = default

        else:

            status = cookie.value

        return status

    def call(self, **kwargs):

        self._cw.add_js(('cubicweb.preferences.js',

                         'cubicweb.edition.js', 'cubicweb.ajax.js'))

        self._cw.add_css('cubicweb.preferences.css')

        values = self.defined_keys

        mainopts, groupedopts = self.group_properties()

        # precompute all forms first to consume error message

        mainforms, groupedforms = self.build_forms(mainopts, groupedopts)

        _ = self._cw._

        self.w(u'<h1>%s</h1>\n' % _(self.title))

        for label, group, form in sorted((_(g), g, f)

                                         for g, f in mainforms.iteritems()):

            self.wrap_main_form(group, label, form)

        for label, group, objects in sorted((_(g), g, o)

                                            for g, o in groupedforms.iteritems()):

            self.wrap_grouped_form(group, label, objects)

    @property

    @cached

    def cwprops_rset(self):

        return self._cw.execute('Any P,K,V WHERE P is CWProperty, P pkey K, '

                                'P value V, NOT P for_user U')

    @property

    def defined_keys(self):

        values = {}

        for i, entity in enumerate(self.cwprops_rset.entities()):

            values[entity.pkey] = i

        return values

    def group_properties(self):

        mainopts, groupedopts = {}, {}

        vreg = self._cw.vreg

        # "self._regid__=='systempropertiesform'" to skip site wide properties on

        # user's preference but not site's configuration

        for key in vreg.user_property_keys(self.__regid__=='systempropertiesform'):

            parts = key.split('.')

            if parts[0] in vreg and len(parts) >= 3:

                # appobject configuration

                reg = parts[0]

                propid = parts[-1]

                oid = '.'.join(parts[1:-1])

                groupedopts.setdefault(reg, {}).setdefault(oid, []).append(key)

            else:

                mainopts.setdefault(parts[0], []).append(key)

        return mainopts, groupedopts

    def build_forms(self, mainopts, groupedopts):

        mainforms, groupedforms = {}, {}

        for group, keys in mainopts.items():

            mainforms[group] = self.form(group, keys, False)

        for group, objects in groupedopts.items():

            groupedforms[group] = {}

            for oid, keys in objects.items():

                groupedforms[group][oid] = self.form(group + '_' + oid, keys, True)

        return mainforms, groupedforms

    def entity_for_key(self, key):

        values = self.defined_keys

        if key in values:

            entity = self.cwprops_rset.get_entity(values[key], 0)

        else:

            entity = self._cw.vreg['etypes'].etype_class('CWProperty')(self._cw)

            entity.eid = self._cw.varmaker.next()

            entity.cw_attr_cache['pkey'] = key

            entity.cw_attr_cache['value'] = self._cw.vreg.property_value(key)

        return entity

    def form(self, formid, keys, splitlabel=False):

        form = self._cw.vreg['forms'].select(

            'composite', self._cw, domid=formid, action=self._cw.build_url(),

            form_buttons=self.form_buttons,

            onsubmit="return validatePrefsForm('%s')" % formid,

            submitmsg=self._cw._('changes applied'))

        path = self._cw.relative_path()

        if '?' in path:

            path, params = path.split('?', 1)

            form.add_hidden('__redirectparams', params)

        form.add_hidden('__redirectpath', path)

        for key in keys:

            self.form_row(form, key, splitlabel)

        renderer = self._cw.vreg['formrenderers'].select('cwproperties', self._cw,

                                                     display_progress_div=False)

        data = []

        form.render(w=data.append, renderer=renderer)

        return u'\n'.join(data)

    def form_row(self, form, key, splitlabel):

        entity = self.entity_for_key(key)

        if splitlabel:

            label = key.split('.')[-1]

        else:

            label = key

        subform = self._cw.vreg['forms'].select('base', self._cw, entity=entity,

                                                mainform=False)

        subform.append_field(PropertyValueField(name='value', label=label, role='subject',

                                                eidparam=True))

        subform.add_hidden('pkey', key, eidparam=True, role='subject')

        form.add_subform(subform)

        return subform

    def wrap_main_form(self, group, label, form):

        status = css_class(self._group_status(group))

        self.w(u'<div class="propertiesform">%s</div>\n' %

               (make_togglable_link('fieldset_' + group, label)))

        self.w(u'<div id="fieldset_%s" %s>' % (group, status))

        self.w(u'<fieldset class="preferences">')

        self.w(form)

        self.w(u'</fieldset></div>')

    def wrap_grouped_form(self, group, label, objects):

        status = css_class(self._group_status(group))

        self.w(u'<div class="propertiesform">%s</div>\n' %

          (make_togglable_link('fieldset_' + group, label)))

        self.w(u'<div id="fieldset_%s" %s>' % (group, status))

        sorted_objects = sorted((self._cw.__('%s_%s' % (group, o)), o, f)

                                for o, f in objects.iteritems())

        for label, oid, form in sorted_objects:

            self.wrap_object_form(group, oid, label, form)

        self.w(u'</div>')

    def wrap_object_form(self, group, oid, label, form):

        w = self.w

        w(u'<div class="component">')

        w(u'''<div class="componentLink"><a href="javascript:$.noop();"

                   onclick="javascript:toggleVisibility('field_%(oid)s_%(group)s')"

                   class="componentTitle">%(label)s</a>''' % {'label':label, 'oid':oid, 'group':group})

        w(u''' (<div class="openlink"><a href="javascript:$.noop();"

                onclick="javascript:openFieldset('fieldset_%(group)s')">%(label)s</a></div>)'''

                  % {'label':self._cw._('open all'), 'group':group})

        w(u'</div>')

        docmsgid = '%s_%s_description' % (group, oid)

        doc = self._cw._(docmsgid)

        if doc != docmsgid:

            w(u'<div class="helper">%s</div>' % xml_escape(doc).capitalize())

        w(u'</div>')

        w(u'<fieldset id="field_%(oid)s_%(group)s" class="%(group)s preferences hidden">'

          % {'oid':oid, 'group':group})

        w(form)

        w(u'</fieldset>')

class CWPropertiesForm(SystemCWPropertiesForm):

    """user's preferences properties edition form"""

    __regid__ = 'propertiesform'

    __select__ = (

        (none_rset() & match_user_groups('users','managers'))

        | (one_line_rset() & match_user_groups('users') & logged_user_in_rset())

        | (one_line_rset() & match_user_groups('managers') & is_instance('CWUser'))

        )

    title = _('user preferences')

    @property

    def user(self):

        if self.cw_rset is None:

            return self._cw.user

        return self.cw_rset.get_entity(self.cw_row or 0, self.cw_col or 0)

    @property

    @cached

    def cwprops_rset(self):

        return self._cw.execute('Any P,K,V WHERE P is CWProperty, P pkey K, P value V,'

                                'P for_user U, U eid %(x)s', {'x': self.user.eid})

    def form_row(self, form, key, splitlabel):

        subform = super(CWPropertiesForm, self).form_row(form, key, splitlabel)

        # if user is in the managers group and the property is being created,

        # we have to set for_user explicitly

        if not subform.edited_entity.has_eid() and self.user.matching_groups('managers'):

            subform.add_hidden('for_user', self.user.eid, eidparam=True, role='subject')

        return subform

# cwproperty form objects ######################################################

class PlaceHolderWidget(FieldWidget):

    def render(self, form, field, renderer):

        domid = field.dom_id(form)

        # empty span as well else html validation fail (label is refering to

        # this id)

        return '<div id="div:%s"><span id="%s">%s</span></div>' % (

            domid, domid, form._cw._('select a key first'))

class NotEditableWidget(FieldWidget):

    def __init__(self, value, msg=None):

        self.value = value

        self.msg = msg

    def render(self, form, field, renderer):

        domid = field.dom_id(form)

        value = '<span class="value" id="%s">%s</span>' % (domid, self.value)

        if self.msg:

            value + '<div class="helper">%s</div>' % self.msg

        return value

class PropertyKeyField(StringField):

    """specific field for CWProperty.pkey to set the value widget according to

    the selected key

    """

    widget = Select

    def render(self, form, renderer):

        wdg = self.get_widget(form)

        # pylint: disable=E1101

        wdg.attrs['tabindex'] = form._cw.next_tabindex()

        wdg.attrs['onchange'] = "javascript:setPropValueWidget('%s', %s)" % (

            form.edited_entity.eid, form._cw.next_tabindex())

        return wdg.render(form, self, renderer)

    def vocabulary(self, form):

        entity = form.edited_entity

        _ = form._cw._

        if entity.has_eid():

            return [(_(entity.pkey), entity.pkey)]

        choices = entity._cw.vreg.user_property_keys()

        return [(u'', u'')] + sorted(zip((_(v) for v in choices), choices))

class PropertyValueField(StringField):

    """specific field for CWProperty.value  which will be different according to

    the selected key type and vocabulary information

    """

    widget = PlaceHolderWidget

    def render(self, form, renderer=None, tabindex=None):

        wdg = self.get_widget(form)

        if tabindex is not None:

            wdg.attrs['tabindex'] = tabindex

        return wdg.render(form, self, renderer)

    def form_init(self, form):

        entity = form.edited_entity

        if not (entity.has_eid() or 'pkey' in entity.cw_attr_cache):

            # no key set yet, just include an empty div which will be filled

            # on key selection

            return

        try:

            pdef = form._cw.vreg.property_info(entity.pkey)

        except UnknownProperty, ex: