"""widgets for entity edition

those are in cubicweb.common since we need to know available widgets at schema

serialization time

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), license is LGPL v2.

:contact: http://www.logilab.fr/ -- mailto:contact@logilab.fr

:license: GNU Lesser General Public License, v2.1 - http://www.gnu.org/licenses

"""

__docformat__ = "restructuredtext en"

from datetime import datetime

from logilab.mtconverter import html_escape

from yams.constraints import SizeConstraint, StaticVocabularyConstraint

from cubicweb.common.uilib import toggle_action

from cubicweb.web import INTERNAL_FIELD_VALUE, eid_param

def _format_attrs(kwattrs):

    """kwattrs is the dictionary of the html attributes available for

    the edited element

    """

    # sort for predictability (required for tests)

    return u' '.join(sorted(u'%s="%s"' % item for item in kwattrs.iteritems()))

def _value_from_values(values):

    # take care, value may be 0, 0.0...

    if values:

        value = values[0]

        if value is None:

            value = u''

    else:

        value = u''

    return value

def _eclass_eschema(eschema_or_eclass):

    try:

        return eschema_or_eclass, eschema_or_eclass.e_schema

    except AttributeError:

        return None, eschema_or_eclass

def checkbox(name, value, attrs='', checked=None):

    if checked is None:

        checked = value

    checked = checked and 'checked="checked"' or ''

    return u'<input type="checkbox" name="%s" value="%s" %s %s />' % (

        name, value, checked, attrs)

def widget(vreg, subjschema, rschema, objschema, role='object'):

    """get a widget to edit the given relation"""

    if rschema == 'eid':

        # return HiddenWidget(vreg, subjschema, rschema, objschema)

        return EidWidget(vreg, _eclass_eschema(subjschema)[1], rschema, objschema)

    return widget_factory(vreg, subjschema, rschema, objschema, role=role)

class Widget(object):

    """abstract widget class"""

    need_multipart = False

    # generate the "id" attribute with the same value as the "name" (html) attribute

    autoid = True

    html_attributes = set(('id', 'class', 'tabindex', 'accesskey', 'onchange', 'onkeypress'))

    cubicwebns_attributes = set()

    def __init__(self, vreg, subjschema, rschema, objschema,

                 role='subject', description=None,

                 **kwattrs):

        self.vreg = vreg

        self.rschema = rschema

        self.subjtype = subjschema

        self.objtype = objschema

        self.role = role

        self.name = rschema.type

        self.description = description

        self.attrs = kwattrs

        # XXX accesskey may not be unique

        kwattrs['accesskey'] = self.name[0]

    def copy(self):

        """shallow copy (useful when you need to modify self.attrs

        because widget instances are cached)

        """

        # brute force copy (subclasses don't have the

        # same __init__ prototype)

        widget = self.__new__(self.__class__)

        widget.__dict__ = dict(self.__dict__)

        widget.attrs = dict(widget.attrs)

        return widget

    @staticmethod

    def size_constraint_attrs(attrs, maxsize):

        """set html attributes in the attrs dict to consider maxsize"""

        pass

    def format_attrs(self):

        """return a string with html attributes available for the edit input"""

        # sort for predictability (required for tests)

        attrs = []

        for name, value in self.attrs.iteritems():

            # namespace attributes have priority over standard xhtml ones

            if name in self.cubicwebns_attributes:

                attrs.append(u'cubicweb:%s="%s"' % (name, value))

            elif name in self.html_attributes:

                attrs.append(u'%s="%s"' % (name, value))

        return u' '.join(sorted(attrs))

    def required(self, entity):

        """indicates if the widget needs a value to be filled in"""

        card = self.rschema.cardinality(self.subjtype, self.objtype, self.role)

        return card in '1+'

    def input_id(self, entity):

        try:

            return self.rname

        except AttributeError:

            return eid_param(self.name, entity.eid)

    def render_label(self, entity, label=None):

        """render widget's label"""

        label = label or self.rschema.display_name(entity.req, self.role)

        forid = self.input_id(entity)

        if forid:

            forattr =  ' for="%s"' % forid

        else:

            forattr = ''

        if self.required(entity):

            label = u'<label class="required"%s>%s</label>' % (forattr, label)

        else:

            label = u'<label%s>%s</label>' % (forattr, label)

        return label

    def render_error(self, entity):

        """return validation error for widget's field of the given entity, if

        any

        """

        errex = entity.req.data.get('formerrors')

        if errex and errex.eid == entity.eid and self.name in errex.errors:

            entity.req.data['displayederrors'].add(self.name)

            return u'<span class="error">%s</span>' % errex.errors[self.name]

        return u''

    def render_help(self, entity):

        """render a help message about the (edited) field"""

        req = entity.req

        help = [u'<div class="helper">']

        descr = self.description or self.rschema.rproperty(self.subjtype, self.objtype, 'description')

        if descr:

            help.append(u'<span>%s</span>' % req._(descr))

        example = self.render_example(req)

        if example:

            help.append(u'<span>(%s: %s)</span>'

                        % (req._('sample format'), example))

        help.append(u'</div>')

        return u' '.join(help)

    def render_example(self, req):

        return u''

    def render(self, entity):

        """render the widget for a simple view"""

        if not entity.has_eid():

            return u''

        return entity.printable_value(self.name)

    def edit_render(self, entity, tabindex=None,

                    includehelp=False, useid=None, **kwargs):

        """render the widget for edition"""

        # this is necessary to handle multiple edition

        self.rname = eid_param(self.name, entity.eid)

        if useid:

            self.attrs['id'] = useid

        elif self.autoid:

            self.attrs['id'] = self.rname

        if tabindex is not None:

            self.attrs['tabindex'] = tabindex

        else:

            self.attrs['tabindex'] = entity.req.next_tabindex()

        output = self._edit_render(entity, **kwargs)

        if includehelp:

            output += self.render_help(entity)

        return output

    def _edit_render(self, entity):

        """do the actual job to render the widget for edition"""

        raise NotImplementedError

    def current_values(self, entity):

        """return the value of the field associated to this widget on the given

        entity. always return a list of values, which'll have size equal to 1

        if the field is monovalued (like all attribute fields, but not all non

        final relation fields

        """

        if self.rschema.is_final():

            return entity.attribute_values(self.name)

        elif entity.has_eid():

            return [row[0] for row in entity.related(self.name, self.role)]

        return ()

    def current_value(self, entity):

        return _value_from_values(self.current_values(entity))

    def current_display_values(self, entity):

        """same as .current_values but consider values stored in session in case

        of validation error

        """

        values = entity.req.data.get('formvalues')

        if values is None:

            return self.current_values(entity)

        cdvalues = values.get(self.rname)

        if cdvalues is None:

            return self.current_values(entity)

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

            cdvalues = (cdvalues,)

        return cdvalues

    def current_display_value(self, entity):

        """same as .current_value but consider values stored in session in case

        of validation error

        """

        return _value_from_values(self.current_display_values(entity))

    def hidden_input(self, entity, qvalue):

        """return an hidden field which

        1. indicates that a field is edited

        2. hold the old value to easily detect if the field has been modified

        `qvalue` is the html quoted old value

        """

        if self.role == 'subject':

            editmark = 'edits'

        else:

            editmark = 'edito'

        if qvalue is None or not entity.has_eid():

            qvalue = INTERNAL_FIELD_VALUE

        return u'<input type="hidden" name="%s-%s" value="%s"/>\n' % (

            editmark, self.rname, qvalue)

class InputWidget(Widget):

    """abstract class for input generating a <input> tag"""

    input_type = None

    html_attributes = Widget.html_attributes | set(('type', 'name', 'value'))

    def _edit_render(self, entity):

        value = self.current_value(entity)

        dvalue = self.current_display_value(entity)

        if isinstance(value, basestring):

            value = html_escape(value)

        if isinstance(dvalue, basestring):

            dvalue = html_escape(dvalue)

        return u'%s<input type="%s" name="%s" value="%s" %s/>' % (

            self.hidden_input(entity, value), self.input_type,

            self.rname, dvalue, self.format_attrs())

class HiddenWidget(InputWidget):

    input_type = 'hidden'

    autoid = False

    def __init__(self, vreg, subjschema, rschema, objschema,

                 role='subject', **kwattrs):

        InputWidget.__init__(self, vreg, subjschema, rschema, objschema,

                             role='subject',

                             **kwattrs)

        # disable access key

        del self.attrs['accesskey']

    def current_value(self, entity):

        value = InputWidget.current_value(self, entity)

        return value or INTERNAL_FIELD_VALUE

    def current_display_value(self, entity):

        value = InputWidget.current_display_value(self, entity)

        return value or INTERNAL_FIELD_VALUE

    def render_label(self, entity, label=None):

        """render widget's label"""

        return u''

    def render_help(self, entity):

        return u''

    def hidden_input(self, entity, value):

        """no hidden input for hidden input"""

        return ''

class EidWidget(HiddenWidget):

    def _edit_render(self, entity):

        return u'<input type="hidden" name="eid" value="%s" />' % entity.eid

class StringWidget(InputWidget):

    input_type = 'text'

    html_attributes = InputWidget.html_attributes | set(('size', 'maxlength'))

    @staticmethod

    def size_constraint_attrs(attrs, maxsize):

        """set html attributes in the attrs dict to consider maxsize"""

        attrs['size'] = min(maxsize, 40)

        attrs['maxlength'] = maxsize

class AutoCompletionWidget(StringWidget):

    cubicwebns_attributes = (StringWidget.cubicwebns_attributes |

                          set(('accesskey', 'size', 'maxlength')))

    attrs = ()

    wdgtype = 'SuggestField'

    def current_value(self, entity):

        value = StringWidget.current_value(self, entity)

        return value or INTERNAL_FIELD_VALUE

    def _get_url(self, entity):

        return entity.req.build_url('json', fname=entity.autocomplete_initfuncs[self.rschema],

                                pageid=entity.req.pageid, mode='remote')

    def _edit_render(self, entity):

        req = entity.req

        req.add_js( ('cubicweb.widgets.js', 'jquery.autocomplete.js') )

        req.add_css('jquery.autocomplete.css')

        value = self.current_value(entity)

        dvalue = self.current_display_value(entity)

        if isinstance(value, basestring):

            value = html_escape(value)

        if isinstance(dvalue, basestring):

            dvalue = html_escape(dvalue)

        iid = self.attrs.pop('id')

        if self.required(entity):

            cssclass = u' required'

        else:

            cssclass = u''

        dataurl = self._get_url(entity)

        return (u'%(hidden)s<input type="text" name="%(iid)s" value="%(value)s" cubicweb:dataurl="%(url)s" class="widget%(required)s" id="%(iid)s" '

                u'tabindex="%(tabindex)s" cubicweb:loadtype="auto" cubicweb:wdgtype="%(wdgtype)s"  %(attrs)s />' % {

                    'iid': iid,

                    'hidden': self.hidden_input(entity, value),

                    'wdgtype': self.wdgtype,

                    'url': html_escape(dataurl),

                    'tabindex': self.attrs.pop('tabindex'),

                    'value': dvalue,

                    'attrs': self.format_attrs(),

                    'required' : cssclass,

                    })

class StaticFileAutoCompletionWidget(AutoCompletionWidget):

    wdgtype = 'StaticFileSuggestField'

    def _get_url(self, entity):

        return entity.req.datadir_url + entity.autocomplete_initfuncs[self.rschema]

class RestrictedAutoCompletionWidget(AutoCompletionWidget):

    wdgtype = 'RestrictedSuggestField'

class PasswordWidget(InputWidget):

    input_type = 'password'

    def required(self, entity):

        if InputWidget.required(self, entity) and not entity.has_eid():

            return True

        return False

    def current_values(self, entity):

        # on existant entity, show password field has non empty (we don't have

        # the actual value

        if entity.has_eid():

            return (INTERNAL_FIELD_VALUE,)

        return super(PasswordWidget, self).current_values(entity)

    def _edit_render(self, entity):

        html = super(PasswordWidget, self)._edit_render(entity)

        name = eid_param(self.name + '-confirm', entity.eid)

        return u'%s<br/>\n<input type="%s" name="%s" id="%s" tabindex="%s"/>&nbsp;<span class="emphasis">(%s)</span>' % (

            html, self.input_type, name, name, entity.req.next_tabindex(),

            entity.req._('confirm password'))

class TextWidget(Widget):

    html_attributes = Widget.html_attributes | set(('rows', 'cols'))

    @staticmethod

    def size_constraint_attrs(attrs, maxsize):

        """set html attributes in the attrs dict to consider maxsize"""

        if 256 < maxsize < 513:

            attrs['cols'], attrs['rows'] = 60, 5