"""widget classes for form construction

:organization: Logilab

:copyright: 2009-2010 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 date

from warnings import warn

from logilab.mtconverter import xml_escape

from logilab.common.deprecation import deprecated

from logilab.common.date import todatetime

from cubicweb import tags, uilib

from cubicweb.web import stdmsgs, INTERNAL_FIELD_VALUE, ProcessFormError

class FieldWidget(object):

    """abstract widget class"""

    # javascript / css files required by the widget

    needs_js = ()

    needs_css = ()

    # automatically set id and tabindex attributes ?

    setdomid = True

    settabindex = True

    # to ease usage as a sub-widgets (eg widget used by another widget)

    suffix = None

    # does this widget expect a vocabulary

    vocabulary_widget = False

    def __init__(self, attrs=None, setdomid=None, settabindex=None, suffix=None):

        if attrs is None:

            attrs = {}

        self.attrs = attrs

        if setdomid is not None:

            # override class's default value

            self.setdomid = setdomid

        if settabindex is not None:

            # override class's default value

            self.settabindex = settabindex

        if suffix is not None:

            self.suffix = suffix

    def add_media(self, form):

        """adds media (CSS & JS) required by this widget"""

        if self.needs_js:

            form._cw.add_js(self.needs_js)

        if self.needs_css:

            form._cw.add_css(self.needs_css)

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

        self.add_media(form)

        return self._render(form, field, renderer)

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

        raise NotImplementedError()

    def typed_value(self, form, field):

        """return field's *typed* value specified in:

        3. extra form values given to render()

        4. field's typed value

        """

        qname = field.input_name(form)

        for key in (field, qname):

            try:

                return form.formvalues[key]

            except KeyError:

                continue

        if field.name != qname and field.name in form.formvalues:

            return form.formvalues[field.name]

        return field.typed_value(form)

    def format_value(self, form, field, value):

        return field.format_value(form._cw, value)

    def values_and_attributes(self, form, field):

        """found field's *string* value in:

        1. previously submitted form values if any (eg on validation error)

        2. req.form

        3. extra form values given to render()

        4. field's typed value

        values found in 1. and 2. are expected te be already some 'display'

        value while those found in 3. and 4. are expected to be correctly typed.

        3 and 4 are handle by the .typed_value(form, field) method

        """

        attrs = dict(self.attrs)

        if self.setdomid:

            attrs['id'] = field.dom_id(form, self.suffix)

        if self.settabindex and not 'tabindex' in attrs:

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

        return self.values(form, field), attrs

    def values(self, form, field):

        qname = field.input_name(form, self.suffix)

        if qname in form.form_previous_values:

            values = form.form_previous_values[qname]

        elif qname in form._cw.form:

            values = form._cw.form[qname]

        elif field.name != qname and field.name in form._cw.form:

            # compat: accept attr=value in req.form to specify value of attr-subject

            values = form._cw.form[field.name]

        else:

            values = self.typed_value(form, field)

            if values != INTERNAL_FIELD_VALUE:

                values = self.format_value(form, field, values)

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

            values = (values,)

        return values

    def process_field_data(self, form, field):

        posted = form._cw.form

        val = posted.get(field.input_name(form, self.suffix))

        if isinstance(val, basestring):

            val = val.strip()

        return val

    @deprecated('[3.6] use values_and_attributes')

    def _render_attrs(self, form, field):

        """return html tag name, attributes and a list of values for the field

        """

        values, attrs = self.values_and_attributes(form, field)

        return field.input_name(form, self.suffix), values, attrs

class Input(FieldWidget):

    """abstract widget class for <input> tag based widgets"""

    type = None

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

        """render the widget for the given `field` of `form`.

        Generate one <input> tag for each field's value

        """

        values, attrs = self.values_and_attributes(form, field)

        # ensure something is rendered

        if not values:

            values = (INTERNAL_FIELD_VALUE,)

        inputs = [tags.input(name=field.input_name(form, self.suffix),

                             type=self.type, value=value, **attrs)

                  for value in values]

        return u'\n'.join(inputs)

# basic html widgets ###########################################################

class TextInput(Input):

    """<input type='text'>"""

    type = 'text'

class PasswordInput(Input):

    """<input type='password'> and its confirmation field (using

    <field's name>-confirm as name)

    """

    type = 'password'

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

        assert self.suffix is None, 'suffix not supported'

        values, attrs = self.values_and_attributes(form, field)

        assert len(values) == 1

        domid = attrs.pop('id')

        inputs = [tags.input(name=field.input_name(form),

                             value=values[0], type=self.type, id=domid, **attrs),

                  '<br/>',

                  tags.input(name=field.input_name(form, '-confirm'),

                             value=values[0], type=self.type, **attrs),

                  ' ', tags.span(form._cw._('confirm password'),

                                      **{'class': 'emphasis'})]

        return u'\n'.join(inputs)

    def process_field_data(self, form, field):

        passwd1 = super(PasswordInput, self).process_field_data(form, field)

        passwd2 = form._cw.form.get(field.input_name(form, '-confirm'))

        if passwd1 == passwd2:

            if passwd1 is None:

                return None

            return passwd1.encode('utf-8')

        raise ProcessFormError(form._cw._("password and confirmation don't match"))

class PasswordSingleInput(Input):

    """<input type='password'> without a confirmation field"""

    type = 'password'

    def process_field_data(self, form, field):

        value = super(PasswordSingleInput, self).process_field_data(form, field)

        if value is not None:

            return value.encode('utf-8')

        return value

class FileInput(Input):

    """<input type='file'>"""

    type = 'file'

    def values_and_attributes(self, form, field):

        # ignore value which makes no sense here (XXX even on form validation error?)

        values, attrs = super(FileInput, self).values_and_attributes(form, field)

        return ('',), attrs

class HiddenInput(Input):

    """<input type='hidden'>"""

    type = 'hidden'

    setdomid = False # by default, don't set id attribute on hidden input

    settabindex = False

class ButtonInput(Input):

    """<input type='button'>

    if you want a global form button, look at the Button, SubmitButton,

    ResetButton and ImgButton classes below.

    """

    type = 'button'

class TextArea(FieldWidget):

    """<textarea>"""

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

        values, attrs = self.values_and_attributes(form, field)

        attrs.setdefault('onkeyup', 'autogrow(this)')

        if not values:

            value = u''

        elif len(values) == 1:

            value = values[0]

        else:

            raise ValueError('a textarea is not supposed to be multivalued')

        lines = value.splitlines()

        linecount = len(lines)

        for line in lines:

            linecount += len(line) / 80

        attrs.setdefault('cols', 80)

        attrs.setdefault('rows', min(15, linecount + 2))

        return tags.textarea(value, name=field.input_name(form, self.suffix),

                             **attrs)

class FCKEditor(TextArea):

    """FCKEditor enabled <textarea>"""

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

        super(FCKEditor, self).__init__(*args, **kwargs)

        self.attrs['cubicweb:type'] = 'wysiwyg'

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

        form._cw.fckeditor_config()

        return super(FCKEditor, self)._render(form, field, renderer)

class Select(FieldWidget):

    """<select>, for field having a specific vocabulary"""

    vocabulary_widget = True

    def __init__(self, attrs=None, multiple=False):

        super(Select, self).__init__(attrs)

        self._multiple = multiple

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

        curvalues, attrs = self.values_and_attributes(form, field)

        if not 'size' in attrs:

            attrs['size'] = self._multiple and '5' or '1'

        options = []

        optgroup_opened = False

        for option in field.vocabulary(form):

            try:

                label, value, oattrs = option

            except ValueError:

                label, value = option

                oattrs = {}

            if value is None:

                # handle separator

                if optgroup_opened:

                    options.append(u'</optgroup>')

                oattrs.setdefault('label', label or '')

                options.append(u'<optgroup %s>' % uilib.sgml_attributes(oattrs))

                optgroup_opened = True

            elif value in curvalues:

                options.append(tags.option(label, value=value,

                                           selected='selected', **oattrs))

            else:

                options.append(tags.option(label, value=value, **oattrs))

        if optgroup_opened:

            options.append(u'</optgroup>')

        return tags.select(name=field.input_name(form, self.suffix),

                           multiple=self._multiple, options=options, **attrs)

class CheckBox(Input):

    """<input type='checkbox'>, for field having a specific vocabulary. One

    input will be generated for each possible value.

    """

    type = 'checkbox'

    vocabulary_widget = True

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

        curvalues, attrs = self.values_and_attributes(form, field)

        domid = attrs.pop('id', None)

        sep = attrs.pop('separator', u'<br/>\n')

        options = []

        for i, option in enumerate(field.vocabulary(form)):

            try:

                label, value, oattrs = option

            except ValueError:

                label, value = option

                oattrs = {}

            iattrs = attrs.copy()

            iattrs.update(oattrs)

            if i == 0 and domid is not None:

                iattrs.setdefault('id', domid)

            if value in curvalues:

                iattrs['checked'] = u'checked'

            tag = tags.input(name=field.input_name(form, self.suffix),

                             type=self.type, value=value, **iattrs)

            options.append(u'%s %s' % (tag, label))

        return sep.join(options)

class Radio(CheckBox):

    """<input type='radio'>, for field having a specific vocabulary. One

    input will be generated for each possible value.

    """

    type = 'radio'

# compound widgets #############################################################

class IntervalWidget(FieldWidget):

    """custom widget to display an interval composed by 2 fields. This widget

    is expected to be used with a CompoundField containing the two actual

    fields.

    Exemple usage::

from uicfg import autoform_field, autoform_section

autoform_field.tag_attribute(('Concert', 'minprice'),

                              CompoundField(fields=(IntField(name='minprice'),

                                                    IntField(name='maxprice')),

                                            label=_('price'),

                                            widget=IntervalWidget()

                                            ))

# we've to hide the other field manually for now

autoform_section.tag_attribute(('Concert', 'maxprice'), 'generated')

    """

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

        actual_fields = field.fields

        assert len(actual_fields) == 2

        return u'<div>%s %s %s %s</div>' % (

            form._cw._('from_interval_start'),

            actual_fields[0].render(form, renderer),

            form._cw._('to_interval_end'),

            actual_fields[1].render(form, renderer),

            )

class HorizontalLayoutWidget(FieldWidget):

    """custom widget to display a set of fields grouped together horizontally

    in a form. See `IntervalWidget` for example usage.

    """

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

        if self.attrs.get('display_label', True):

            subst = self.attrs.get('label_input_substitution', '%(label)s %(input)s')

            fields = [subst % {'label': renderer.render_label(form, f),

                              'input': f.render(form, renderer)}