"""some base form classes for CubicWeb web client

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

from logilab.common.compat import any

from cubicweb.selectors import non_final_entity, match_kwargs, one_line_rset

from cubicweb.web import INTERNAL_FIELD_VALUE, eid_param

from cubicweb.web import form, formwidgets as fwdgs

from cubicweb.web.controller import NAV_FORM_PARAMETERS

from cubicweb.web.formfields import StringField

class FieldsForm(form.Form):

    """base class for fields based forms.

    The following attributes may be either set on subclasses or given on

    form selection to customize the generated form:

    * `needs_js`: sequence of javascript files that should be added to handle

      this form (through `req.add_js`)

    * `needs_css`: sequence of css files that should be added to handle this

      form (through `req.add_css`)

    * `domid`: value for the "id" attribute of the <form> tag

    * `action`: value for the "action" attribute of the <form> tag

    * `onsubmit`: value for the "onsubmit" attribute of the <form> tag

    * `cssclass`: value for the "class" attribute of the <form> tag

    * `cssstyle`: value for the "style" attribute of the <form> tag

    * `cwtarget`: value for the "cubicweb:target" attribute of the <form> tag

    * `redirect_path`: relative to redirect to after submitting the form

    * `copy_nav_params`: flag telling if navigation paramenters should be copied

      back in hidden input

    * `form_buttons`:  form buttons sequence (button widgets instances)

    * `form_renderer_id`: id of the form renderer to use to render the form

    * `fieldsets_in_order`: fieldset name sequence, to control order

    """

    __regid__ = 'base'

    internal_fields = ('__errorurl',) + NAV_FORM_PARAMETERS

    # attributes overrideable by subclasses or through __init__

    needs_js = ('cubicweb.ajax.js', 'cubicweb.edition.js',)

    needs_css = ('cubicweb.form.css',)

    domid = 'form'

    action = None

    onsubmit = "return freezeFormButtons('%(domid)s');"

    cssclass = None

    cssstyle = None

    cwtarget = None

    redirect_path = None

    copy_nav_params = False

    form_buttons = None

    form_renderer_id = 'default'

    fieldsets_in_order = None

    def __init__(self, req, rset=None, row=None, col=None,

                 submitmsg=None, mainform=True,

                 **kwargs):

        super(FieldsForm, self).__init__(req, rset=rset, row=row, col=col)

        self.fields = list(self.__class__._fields_)

        for key, val in kwargs.items():

            if key in NAV_FORM_PARAMETERS:

                self.form_add_hidden(key, val)

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

                setattr(self, key, val)

            else:

                self.extra_kwargs[key] = val

            # skip other parameters, usually given for selection

            # (else write a custom class to handle them)

        if mainform:

            self.form_add_hidden('__errorurl', self.session_key())

            self.form_add_hidden('__domid', self.domid)

        if self.copy_nav_params:

            for param in NAV_FORM_PARAMETERS:

                if not param in kwargs:

                    value = req.form.get(param)

                    if value:

                        self.form_add_hidden(param, value)

        if submitmsg is not None:

            self.form_add_hidden('__message', submitmsg)

        self.context = None

        if 'domid' in kwargs:# session key changed

            self.restore_previous_post(self.session_key())

    @property

    def form_needs_multipart(self):

        """true if the form needs enctype=multipart/form-data"""

        return any(field.needs_multipart for field in self.fields)

    def form_add_hidden(self, name, value=None, **kwargs):

        """add an hidden field to the form"""

        kwargs.setdefault('widget', fwdgs.HiddenInput)

        field = StringField(name=name, initial=value, **kwargs)

        if 'id' in kwargs:

            # by default, hidden input don't set id attribute. If one is

            # explicitly specified, ensure it will be set

            field.widget.setdomid = True

        self.append_field(field)

        return field

    def add_media(self):

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

        if self.needs_js:

            self._cw.add_js(self.needs_js)

        if self.needs_css:

            self._cw.add_css(self.needs_css)

    def form_render(self, **values):

        """render this form, using the renderer given in args or the default

        FormRenderer()

        """

        self.build_context(values)

        renderer = values.pop('renderer', None)

        if renderer is None:

            renderer = self.form_default_renderer()

        return renderer.render(self, values)

    def form_default_renderer(self):

        return self._cw.vreg['formrenderers'].select(self.form_renderer_id,

                                                     self._cw, rset=self.cw_rset,

                                                     row=self.cw_row, col=self.cw_col)

    def build_context(self, rendervalues=None):

        """build form context values (the .context attribute which is a

        dictionary with field instance as key associated to a dictionary

        containing field 'name' (qualified), 'id', 'value' (for display, always

        a string).

        rendervalues is an optional dictionary containing extra kwargs given to

        form_render()

        """

        if self.context is not None:

            return # already built

        self.context = context = {}

        # ensure rendervalues is a dict

        if rendervalues is None:

            rendervalues = {}

        # use a copy in case fields are modified while context is build (eg

        # __linkto handling for instance)

        for field in self.fields[:]:

            for field in field.actual_fields(self):

                field.form_init(self)

                value = self.form_field_display_value(field, rendervalues)

                context[field] = {'value': value,

                                  'name': self.form_field_name(field),

                                  'id': self.form_field_id(field),

                                  }

    def form_field_display_value(self, field, rendervalues, load_bytes=False):

        """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 kw 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.

        """

        value = self._req_display_value(field)

        if value is None:

            if field.name in rendervalues:

                value = rendervalues[field.name]

            elif field.name in self.extra_kwargs:

                value = self.extra_kwargs[field.name]

            else:

                value = self.form_field_value(field, load_bytes)

                if callable(value):

                    value = value(self)

            if value != INTERNAL_FIELD_VALUE:

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

        return value

    def _req_display_value(self, field):

        qname = self.form_field_name(field)

        if qname in self.form_previous_values:

            return self.form_previous_values[qname]

        if qname in self._cw.form:

            return self._cw.form[qname]

        if field.name in self._cw.form:

            return self._cw.form[field.name]

        return None

    def form_field_value(self, field, load_bytes=False):

        """return field's *typed* value"""

        myattr = '%s_%s_default' % (field.role, field.name)

        if hasattr(self, myattr):

            return getattr(self, myattr)()

        value = field.initial

        if callable(value):

            value = value(self)

        return value

    def form_field_error(self, field):

        """return validation error for widget's field, if any"""

        if self._field_has_error(field):

            self.form_displayed_errors.add(field.name)

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

        return u''

    def form_field_format(self, field):

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

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

    def form_field_encoding(self, field):

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

        return self._cw.encoding

    def form_field_name(self, field):

        """return qualified name for the given field"""

        return field.name

    def form_field_id(self, field):

        """return dom id for the given field"""

        return field.id

    def form_field_vocabulary(self, field, limit=None):

        """return vocabulary for the given field. Should be overriden in

        specific forms using fields which requires some vocabulary

        """

        raise NotImplementedError

    def form_field_modified(self, field):

        return field.is_visible()

    def _field_has_error(self, field):

        """return true if the field has some error in given validation exception

        """

        return self.form_valerror and field.name in self.form_valerror.errors

class EntityFieldsForm(FieldsForm):

    __regid__ = 'base'

    __select__ = (match_kwargs('entity')

                  | (one_line_rset() & non_final_entity()))

    internal_fields = FieldsForm.internal_fields + ('__type', 'eid', '__maineid')

    domid = 'entityForm'

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

        self.edited_entity = kwargs.pop('entity', None)

        msg = kwargs.pop('submitmsg', None)

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

        if self.edited_entity is None:

            self.edited_entity = self.cw_rset.complete_entity(self.cw_row or 0, self.cw_col or 0)

        self.form_add_hidden('__type', eidparam=True)

        self.form_add_hidden('eid')

        if kwargs.get('mainform', True): # mainform default to true in parent

            self.form_add_hidden(u'__maineid', self.edited_entity.eid)

            # If we need to directly attach the new object to another one

            if self._cw.list_form_param('__linkto'):

                for linkto in self._cw.list_form_param('__linkto'):

                    self.form_add_hidden('__linkto', linkto)

                if msg:

                    msg = '%s %s' % (msg, self._cw._('and linked'))

                else:

                    msg = self._cw._('entity linked')

        if msg:

            self.form_add_hidden('__message', msg)

    def _field_has_error(self, field):

        """return true if the field has some error in given validation exception

        """

        return super(EntityFieldsForm, self)._field_has_error(field) \

               and self.form_valerror.eid == self.edited_entity.eid

    def _relation_vocabulary(self, rtype, targettype, role,

                            limit=None, done=None):

        """return unrelated entities for a given relation and target entity type

        for use in vocabulary

        """

        if done is None:

            done = set()

        rset = self.edited_entity.unrelated(rtype, targettype, role, limit)

        res = []

        for entity in rset.entities():

            if entity.eid in done:

                continue

            done.add(entity.eid)

            res.append((entity.view('combobox'), entity.eid))

        return res

    def _req_display_value(self, field):

        value = super(EntityFieldsForm, self)._req_display_value(field)

        if value is None:

            value = self.edited_entity.linked_to(field.name, field.role)

            if value:

                searchedvalues = ['%s:%s:%s' % (field.name, eid, field.role)

                                  for eid in value]

                # remove associated __linkto hidden fields

                for field in self.root_form.fields_by_name('__linkto'):

                    if field.initial in searchedvalues:

                        self.root_form.remove_field(field)

            else:

                value = None

        return value

    def _form_field_default_value(self, field, load_bytes):

        defaultattr = 'default_%s' % field.name

        if hasattr(self.edited_entity, defaultattr):

            # XXX bw compat, default_<field name> on the entity

            warn('found %s on %s, should be set on a specific form'

                 % (defaultattr, self.edited_entity.__regid__), DeprecationWarning)

            value = getattr(self.edited_entity, defaultattr)

            if callable(value):

                value = value()

        else:

            value = super(EntityFieldsForm, self).form_field_value(field,

                                                                   load_bytes)

        return value

    def form_default_renderer(self):

        return self._cw.vreg['formrenderers'].select(

            self.form_renderer_id, self._cw, rset=self.cw_rset, row=self.cw_row,

            col=self.cw_col, entity=self.edited_entity)

    def form_field_value(self, field, load_bytes=False):

        """return field's *typed* value

        overriden to deal with

        * special eid / __type

        * lookup for values on edited entities

        """

        attr = field.name

        entity = self.edited_entity

        if attr == 'eid':

            return entity.eid

        if not field.eidparam:

            return super(EntityFieldsForm, self).form_field_value(field, load_bytes)

        if attr == '__type':

            return entity.__regid__

        if self._cw.schema.rschema(attr).is_final():

            attrtype = entity.e_schema.destination(attr)

            if attrtype == 'Password':

                return entity.has_eid() and INTERNAL_FIELD_VALUE or ''

            if attrtype == 'Bytes':

                if entity.has_eid():

                    if load_bytes:

                        return getattr(entity, attr)

                    # XXX value should reflect if some file is already attached

                    return True

                return False

            if entity.has_eid() or attr in entity:

                value = getattr(entity, attr)

            else:

                value = self._form_field_default_value(field, load_bytes)

            return value

        # non final relation field

        if entity.has_eid() or entity.relation_cached(attr, field.role):

            value = [r[0] for r in entity.related(attr, field.role)]

        else:

            value = self._form_field_default_value(field, load_bytes)

        return value

    def form_field_format(self, field):

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

        entity = self.edited_entity

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

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

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

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

    def form_field_encoding(self, field):

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

        entity = self.edited_entity

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