"""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.schema import KNOWN_METAATTRIBUTES

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

_MARKER = object()

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.

    :value:

       field's value, used when no value specified by other means. XXX explain

    :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

    eidparam = False

    role = None

    id = None

    help = None

    required = False

    choices = None

    sort = True

    internationalizable = False

    fieldset = None

    order = None

    value = _MARKER

    def __init__(self, name=None, label=None, widget=None, **kwargs):

        for key, val in kwargs.items():

            if key == 'initial':

                warn('[3.6] use value instead of initial', DeprecationWarning,

                     stacklevel=3)

                key = 'value'

            assert hasattr(self.__class__, key) and not key[0] == '_', key

            setattr(self, key, val)

        self.name = name

        self.label = label or name

        # has to be done after other attributes initialization

        self.init_widget(widget)

        # ordering number for this field instance

        self.creation_rank = Field.__creation_rank

        Field.__creation_rank += 1

    def __unicode__(self):

        return u'<%s name=%r eidparam=%s role=%r id=%r value=%r visible=%r @%x>' % (

            self.__class__.__name__, self.name, self.eidparam, self.role,

            self.id, self.value, self.is_visible(), id(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):

        """automatically set .label when name is set"""

        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 display_value(self, form):

        """return field's *string* value to use for display

        looks in

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

        2. req.form

        3. extra form args given to render_form

        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.

        """

        qname = self.input_name(form)

        if qname in form.form_previous_values:

            return form.form_previous_values[qname]

        if qname in form._cw.form:

            return form._cw.form[qname]

        if self.name != qname and self.name in form._cw.form:

            return form._cw.form[self.name]

        for key in (self, qname):

            try:

                value = form.formvalues[key]

                break

            except:

                continue

        else:

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

                value = form.formvalues[self.name]

            else:

                value = self.typed_value(form)

        if value != INTERNAL_FIELD_VALUE:

            value = self.format_value(form._cw, value)

        return value

    def typed_value(self, form, load_bytes=False):

        if self.value is not _MARKER:

            if callable(self.value):

                return self.value(form)

            return self.value

        return self._typed_value(form, load_bytes)

    def _typed_value(self, form, load_bytes=False):

        if self.eidparam:

            assert form._cw.vreg.schema.rschema(self.name).final

            entity = form.edited_entity

            if entity.has_eid() or self.name in entity:

                return getattr(entity, self.name)

        formattr = '%s_%s_default' % (self.role, self.name)

        if hasattr(form, formattr):

            warn('[3.6] %s.%s deprecated, use field.value' % (

                form.__class__.__name__, formattr), DeprecationWarning)

            return getattr(form, formattr)()

        if self.eidparam:

            return entity.e_schema.default(self.name)

        return None

    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 requires a vocabulary.

        """

        assert 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]

        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 format(self, form):

        """return MIME type used for the given (text or bytes) field"""

        if self.eidparam and self.role == 'subject':

            entity = form.edited_entity

            if entity.e_schema.has_metadata(self.name, 'format') and (

                entity.has_eid() or '%s_format' % self.name in entity):

                return form.edited_entity.attr_metadata(self.name, 'format')

        return form._cw.property_value('ui.default-text-format')

    def encoding(self, form):

        """return encoding used for the given (text) field"""

        if self.eidparam:

            entity = form.edited_entity

            if entity.e_schema.has_metadata(self.name, 'encoding') and (

                entity.has_eid() or '%s_encoding' % self.name in entity):

                return form.edited_entity.attr_metadata(self.name, 'encoding')

        return form._cw.encoding

    def form_init(self, form):

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

        initialization requiring the form instance

        """

        pass

    def has_been_modified(self, form):

        if self.is_visible():

            # fields not corresponding to an entity attribute / relations

            # are considered modified

            if not self.eidparam or not self.role or not form.edited_entity.has_eid():

                return True # XXX

            try:

                if self.role == 'subject':

                    previous_value = getattr(form.edited_entity, self.name)

                else:

                    previous_value = getattr(form.edited_entity,

                                             'reverse_%s' % self.name)

            except AttributeError:

                # fields with eidparam=True but not corresponding to an actual

                # attribute or relation

                return True

            # if it's a non final relation, we need the eids

            if isinstance(previous_value, list):

                # widget should return untyped eids

                previous_value = set(unicode(e.eid) for e in previous_value)

            if form.edited_entity.has_eid() and (previous_value == self.process_form_value(form)):

                return False # not modified

            return True

        return False

    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, field.process_form_value(form)

            else:

                # recursive function: we might have compound fields

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

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

                    yield field, value

class StringField(Field):

    widget = TextArea

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

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

        super(StringField, self).__init__(name=name, **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)