"""field classes for form construction

:organization: Logilab

:copyright: 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 warnings import warn

from datetime import datetime

from logilab.mtconverter import xml_escape

from logilab.common.decorators import cached

from yams.constraints import (SizeConstraint, StaticVocabularyConstraint,

                              FormatConstraint)

from cubicweb.utils import ustrftime

from cubicweb import tags, uilib

from cubicweb.web import INTERNAL_FIELD_VALUE, eid_param

from cubicweb.web.formwidgets import (

    HiddenInput, TextInput, FileInput, PasswordInput, TextArea, FCKEditor,

    Radio, Select, DateTimePicker)

def vocab_sort(vocab):

    """sort vocabulary, considering option groups"""

    result = []

    partresult = []

    for label, value in vocab:

        if value is None: # opt group start

            if partresult:

                result += sorted(partresult)

                partresult = []

            result.append( (label, value) )

        else:

            partresult.append( (label, value) )

    result += sorted(partresult)

    return result

class Field(object):

    """field class is introduced to control what's displayed in forms. It makes

    the link between something to edit and its display in the form. Actual

    display is handled by a widget associated to the field.

    Attributes

    ----------

    all the attributes described below have sensible default value which may be

    overriden by value given to field's constructor.

    :name:

       name of the field (basestring), should be unique in a form.

    :id:

       dom identifier (default to the same value as `name`), should be unique in

       a form.

    :label:

       label of the field (default to the same value as `name`).

    :help:

       help message about this field.

    :widget:

       widget associated to the field. Each field class has a default widget

       class which may be overriden per instance.

    :required:

       bool flag telling if the field is required or not.

    :choices:

       static vocabulary for this field. May be a list of values or a list of

       (label, value) tuples if specified.

    :sort:

       bool flag telling if the vocabulary (either static vocabulary specified

       in `choices` or dynamic vocabulary fetched from the form) should be

       sorted on label.

    :internationalizable:

       bool flag telling if the vocabulary labels should be translated using the

       current request language.

    :eidparam:

       bool flag telling if this field is linked to a specific entity

    :role:

       when the field is linked to an entity attribute or relation, tells the

       role of the entity in the relation (eg 'subject' or 'object')

    :fieldset:

       optional fieldset to which this field belongs to

    :order:

       key used by automatic forms to sort fields

    """

    # default widget associated to this class of fields. May be overriden per

    # instance

    widget = TextInput

    # does this field requires a multipart form

    needs_multipart = False

    # class attribute used for ordering of fields in a form

    __creation_rank = 0

        self.name = name

        self.label = label or name

        self.init_widget(widget)

        # ordering number for this field instance

        self.creation_rank = Field.__creation_rank

        Field.__creation_rank += 1

    def __unicode__(self):

    def __repr__(self):

        return self.__unicode__().encode('utf-8')

    def init_widget(self, widget):

        if widget is not None:

            self.widget = widget

        elif self.choices and not self.widget.vocabulary_widget:

            self.widget = Select()

        if isinstance(self.widget, type):

            self.widget = self.widget()

    def set_name(self, name):

        assert name

        self.name = name

        if not self.label:

            self.label = name

    def is_visible(self):

        """return true if the field is not an hidden field"""

        return not isinstance(self.widget, HiddenInput)

    def actual_fields(self, form):

        """return actual fields composing this field in case of a compound

        field, usually simply return self

        """

        yield self

    def format_value(self, req, value):

        """return value suitable for display where value may be a list or tuple

        of values

        """

        if isinstance(value, (list, tuple)):

            return [self.format_single_value(req, val) for val in value]

        return self.format_single_value(req, value)

    def format_single_value(self, req, value):

        """return value suitable for display"""

        if value is None or value is False:

            return u''

        if value is True:

            return u'1'

        return unicode(value)

    def get_widget(self, form):

        """return the widget instance associated to this field"""

        return self.widget

    # cached is necessary else we get some pb on entity creation : entity.eid is

    # modified from creation mark (eg 'X') to its actual eid (eg 123), and then

    # `field.input_name()` won't return the right key anymore if not cached

    # (first call to input_name done *before* eventual eid affectation).

    @cached

    def input_name(self, form, suffix=None):

        """return 'qualified name' for this field"""

        if self.eidparam:

            if suffix is None:

                return eid_param(self.role_name(), form.edited_entity.eid)

            return eid_param(self.role_name() + suffix, form.edited_entity.eid)

        if suffix is None:

            return self.name

        return self.name + suffix

    def role_name(self):

        """return <field.name>-<field.role> if role is specified, else field.name"""

        if self.role is not None:

            return '%s-%s' % (self.name, self.role)

        return self.name

    def dom_id(self, form):

        """return an html dom identifier for this field"""

        id = self.id or self.role_name()

        if self.eidparam:

            return eid_param(id, form.edited_entity.eid)

        return id

    def example_format(self, req):

        """return a sample string describing what can be given as input for this

        field

        """

        return u''

    def render(self, form, renderer):

        """render this field, which is part of form, using the given form

        renderer

        """

        widget = self.get_widget(form)

        return widget.render(form, self, renderer)

    def vocabulary(self, form):

        """return vocabulary for this field. This method will be called by

        widgets which desire it."""

        if self.choices is not None:

            if callable(self.choices):

                try:

                    vocab = self.choices(form=form)

                except TypeError:

                    warn('[3.3] vocabulary method (eg field.choices) should now take '

                         'the form instance as argument', DeprecationWarning)

                    vocab = self.choices(req=form._cw)

            else:

                vocab = self.choices

            if vocab and not isinstance(vocab[0], (list, tuple)):

                vocab = [(x, x) for x in vocab]

        else:

            vocab = form.form_field_vocabulary(self)

        if self.internationalizable:

            # the short-cirtcuit 'and' boolean operator is used here to permit

            # a valid empty string in vocabulary without attempting to translate

            # it by gettext (which can lead to weird strings display)

            vocab = [(label and form._cw._(label), value) for label, value in vocab]

        if self.sort:

            vocab = vocab_sort(vocab)

        return vocab

    def form_init(self, form):

        """method called before by build_context to trigger potential field

        initialization requiring the form instance

        """

        pass

    def process_form_value(self, form):

        """process posted form and return correctly typed value"""

        widget = self.get_widget(form)

        return widget.process_field_data(form, self)

    def process_posted(self, form):

        for field in self.actual_fields(form):

            if field is self:

                yield field.name, field.process_form_value(form)

            else:

                # recursive function: we might have compound fields

                # of compound fields (of compound fields of ...)

                for fieldname, value in field.process_posted(form):

                    yield fieldname, value

class StringField(Field):

    widget = TextArea

    def __init__(self, max_length=None, **kwargs):

        self.max_length = max_length # must be set before super call

        super(StringField, self).__init__(**kwargs)

    def init_widget(self, widget):

        if widget is None:

            if self.choices:

                widget = Select()

            elif self.max_length and self.max_length < 257:

                widget = TextInput()

        super(StringField, self).init_widget(widget)

        if isinstance(self.widget, TextArea):

            self.init_text_area(self.widget)

        elif isinstance(self.widget, TextInput):

            self.init_text_input(self.widget)

    def init_text_input(self, widget):

        if self.max_length:

            widget.attrs.setdefault('size', min(45, self.max_length))

            widget.attrs.setdefault('maxlength', self.max_length)

    def init_text_area(self, widget):

        if self.max_length < 513:

            widget.attrs.setdefault('cols', 60)

            widget.attrs.setdefault('rows', 5)

class RichTextField(StringField):

    widget = None

    def __init__(self, format_field=None, **kwargs):

        super(RichTextField, self).__init__(**kwargs)

        self.format_field = format_field

    def init_text_area(self, widget):

        pass

    def get_widget(self, form):

        if self.widget is None:

            if self.use_fckeditor(form):

                return FCKEditor()

            widget = TextArea()

            self.init_text_area(widget)

            return widget