# copyright 2003-2013 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""

.. autodocstring:: cubicweb.web.views.autoform::AutomaticEntityForm

Configuration through uicfg

```````````````````````````

It is possible to manage which and how an entity's attributes and relations

will be edited in the various contexts where the automatic entity form is used

by using proper uicfg tags.

The details of the uicfg syntax can be found in the :ref:`uicfg` chapter.

Possible relation tags that apply to entity forms are detailled below.

They are all in the :mod:`cubicweb.web.uicfg` module.

Attributes/relations display location

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

``autoform_section`` specifies where to display a relation in form for a given

form type.  :meth:`tag_attribute`, :meth:`tag_subject_of` and

:meth:`tag_object_of` methods for this relation tag expect two arguments

additionally to the relation key: a `formtype` and a `section`.

`formtype` may be one of:

* 'main', the main entity form (e.g. the one you get when creating or editing an

  entity)

* 'inlined', the form for an entity inlined into another form

* 'muledit', the table form when editing multiple entities of the same type

section may be one of:

* 'hidden', don't display (not even in a hidden input)

* 'attributes', display in the attributes section

* 'relations', display in the relations section, using the generic relation

  selector combobox (available in main form only, and not usable for attributes)

* 'inlined', display target entity of the relation into an inlined form

  (available in main form only, and not for attributes)

By default, mandatory relations are displayed in the 'attributes' section,

others in 'relations' section.

Change default fields

^^^^^^^^^^^^^^^^^^^^^

Use ``autoform_field`` to replace the default field class to use for a relation

or attribute. You can put either a field class or instance as value (put a class

whenether it's possible).

.. Warning::

   `autoform_field_kwargs` should usually be used instead of

   `autoform_field`. If you put a field instance into `autoform_field`,

   `autoform_field_kwargs` values for this relation will be ignored.

Customize field options

^^^^^^^^^^^^^^^^^^^^^^^

In order to customize field options (see :class:`~cubicweb.web.formfields.Field`

for a detailed list of options), use `autoform_field_kwargs`. This rtag takes

a dictionary as arguments, that will be given to the field's contructor.

You can then put in that dictionary any arguments supported by the field

class. For instance:

.. sourcecode:: python

   # Change the content of the combobox. Here `ticket_done_in_choices` is a

   # function which returns a list of elements to populate the combobox

   autoform_field_kwargs.tag_subject_of(('Ticket', 'done_in', '*'),

                                        {'sort': False,

                                         'choices': ticket_done_in_choices})

   # Force usage of a TextInput widget for the expression attribute of

   # RQLExpression entities

   autoform_field_kwargs.tag_attribute(('RQLExpression', 'expression'),

                                       {'widget': fw.TextInput})

.. note::

   the widget argument can be either a class or an instance (the later

   case being convenient to pass the Widget specific initialisation

   options)

Overriding permissions

^^^^^^^^^^^^^^^^^^^^^^

The `autoform_permissions_overrides` rtag provides a way to by-pass security

checking for dark-corner case where it can't be verified properly.

.. More about inlined forms

.. Controlling the generic relation fields

"""

__docformat__ = "restructuredtext en"

_ = unicode

from warnings import warn

from six.moves import range

from logilab.mtconverter import xml_escape

from logilab.common.decorators import iclassmethod, cached

from logilab.common.deprecation import deprecated

from logilab.common.registry import NoSelectableObject

from cubicweb import neg_role, uilib

from cubicweb.schema import display_name

from cubicweb.view import EntityView

from cubicweb.predicates import (

    match_kwargs, match_form_params, non_final_entity,

    specified_etype_implements)

from cubicweb.utils import json_dumps

from cubicweb.web import (stdmsgs, eid_param,

                          form as f, formwidgets as fw, formfields as ff)

from cubicweb.web.views import uicfg, forms

from cubicweb.web.views.ajaxcontroller import ajaxfunc

# inlined form handling ########################################################

class InlinedFormField(ff.Field):

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

        kwargs.setdefault('label', None)

        # don't add eidparam=True since this field doesn't actually hold the

        # relation value (the subform does) hence should not be listed in

        # _cw_entity_fields

        super(InlinedFormField, self).__init__(name=view.rtype, role=view.role,

                                               **kwargs)

        self.view = view

    def render(self, form, renderer):

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

        renderer

        """

        view = self.view

        i18nctx = 'inlined:%s.%s.%s' % (form.edited_entity.e_schema,

                                        view.rtype, view.role)

        return u'<div class="inline-%s-%s-slot">%s</div>' % (

            view.rtype, view.role,

            view.render(i18nctx=i18nctx, row=view.cw_row, col=view.cw_col))

    def form_init(self, form):

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

        initialization requiring the form instance

        """

        if self.view.form:

            self.view.form.build_context(form.formvalues)

    @property

    def needs_multipart(self):

        if self.view.form:

            # take a look at inlined forms to check (recursively) if they need

            # multipart handling.

            return self.view.form.needs_multipart

        return False

    def has_been_modified(self, form):

        return False

    def process_posted(self, form):

        pass # handled by the subform

class InlineEntityEditionFormView(f.FormViewMixIn, EntityView):

    """

    :attr peid: the parent entity's eid hosting the inline form

    :attr rtype: the relation bridging `etype` and `peid`

    :attr role: the role played by the `peid` in the relation

    :attr pform: the parent form where this inlined form is being displayed

    """

    __regid__ = 'inline-edition'

    __select__ = non_final_entity() & match_kwargs('peid', 'rtype')

    _select_attrs = ('peid', 'rtype', 'role', 'pform', 'etype')

    removejs = "removeInlinedEntity('%s', '%s', '%s')"

    # make pylint happy

    peid = rtype = role = pform = etype = None

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

        for attr in self._select_attrs:

            # don't pop attributes from kwargs, so the end-up in

            # self.cw_extra_kwargs which is then passed to the edition form (see

            # the .form method)

            setattr(self, attr, kwargs.get(attr))

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

    def _entity(self):

        assert self.cw_row is not None, self

        return self.cw_rset.get_entity(self.cw_row, self.cw_col)

    @property

    def petype(self):

        assert isinstance(self.peid, int)

        pentity = self._cw.entity_from_eid(self.peid)

        return pentity.e_schema.type

    @property

    @cached

    def form(self):

        entity = self._entity()

        form = self._cw.vreg['forms'].select('edition', self._cw,

                                             entity=entity,

                                             formtype='inlined',

                                             form_renderer_id='inline',

                                             copy_nav_params=False,

                                             mainform=False,

                                             parent_form=self.pform,

                                             **self.cw_extra_kwargs)

        if self.pform is None:

            form.restore_previous_post(form.session_key())

        #assert form.parent_form

        self.add_hiddens(form, entity)

        return form

    def cell_call(self, row, col, i18nctx, **kwargs):

        """

        :param peid: the parent entity's eid hosting the inline form

        :param rtype: the relation bridging `etype` and `peid`

        :param role: the role played by the `peid` in the relation

        """

        entity = self._entity()

        divonclick = "restoreInlinedEntity('%s', '%s', '%s')" % (

            self.peid, self.rtype, entity.eid)

        self.render_form(i18nctx, divonclick=divonclick, **kwargs)

    def _get_removejs(self):

        """

        Don't display the remove link in edition form if the

        cardinality is 1. Handled in InlineEntityCreationFormView for

        creation form.

        """

        entity = self._entity()

        rdef = entity.e_schema.rdef(self.rtype, neg_role(self.role), self.petype)

        card = rdef.role_cardinality(self.role)

        if card == '1': # don't display remove link

            return None

        # if cardinality is 1..n (+), dont display link to remove an inlined form for the first form

        # allowing to edit the relation. To detect so:

        #

        # * if parent form (pform) is None, we're generated through an ajax call and so we know this

        #   is not the first form

        #

        # * if parent form is not None, look for previous InlinedFormField in the parent's form

        #   fields

        if card == '+' and self.pform is not None:

            # retrieve all field'views handling this relation and return None if we're the first of

            # them

            first_view = next(iter((f.view for f in self.pform.fields

                                    if isinstance(f, InlinedFormField)

                                    and f.view.rtype == self.rtype and f.view.role == self.role)))

            if self == first_view:

                return None

        return self.removejs and self.removejs % (

            self.peid, self.rtype, entity.eid)

    def render_form(self, i18nctx, **kwargs):

        """fetch and render the form"""

        entity = self._entity()

        divid = '%s-%s-%s' % (self.peid, self.rtype, entity.eid)

        title = self.form_title(entity, i18nctx)

        removejs = self._get_removejs()

        countkey = '%s_count' % self.rtype

        try:

            self._cw.data[countkey] += 1

        except KeyError:

            self._cw.data[countkey] = 1

        self.form.render(w=self.w, divid=divid, title=title, removejs=removejs,

                         i18nctx=i18nctx, counter=self._cw.data[countkey] ,

                         **kwargs)

    def form_title(self, entity, i18nctx):

        return self._cw.pgettext(i18nctx, entity.cw_etype)

    def add_hiddens(self, form, entity):

        """to ease overriding (see cubes.vcsfile.views.forms for instance)"""

        iid = 'rel-%s-%s-%s' % (self.peid, self.rtype, entity.eid)

        #  * str(self.rtype) in case it's a schema object

        #  * neged_role() since role is the for parent entity, we want the role

        #    of the inlined entity

        form.add_hidden(name=str(self.rtype), value=self.peid,

                        role=neg_role(self.role), eidparam=True, id=iid)

    def keep_entity(self, form, entity):

        if not entity.has_eid():

            return True

        # are we regenerating form because of a validation error?

        if form.form_previous_values:

            cdvalues = self._cw.list_form_param(eid_param(self.rtype, self.peid),

                                                form.form_previous_values)

            if unicode(entity.eid) not in cdvalues:

                return False

        return True

class InlineEntityCreationFormView(InlineEntityEditionFormView):

    """

    :attr etype: the entity type being created in the inline form

    """

    __regid__ = 'inline-creation'

    __select__ = (match_kwargs('peid', 'petype', 'rtype')

                  & specified_etype_implements('Any'))

    _select_attrs = InlineEntityEditionFormView._select_attrs + ('petype',)

    # make pylint happy

    petype = None

    @property

    def removejs(self):

        entity = self._entity()

        rdef = entity.e_schema.rdef(self.rtype, neg_role(self.role), self.petype)

        card = rdef.role_cardinality(self.role)

        # when one is adding an inline entity for a relation of a single card,

        # the 'add a new xxx' link disappears. If the user then cancel the addition,

        # we have to make this link appears back. This is done by giving add new link

        # id to removeInlineForm.

        if card == '?':

            divid = "addNew%s%s%s:%s" % (self.etype, self.rtype, self.role, self.peid)

            return "removeInlineForm('%%s', '%%s', '%s', '%%s', '%s')" % (

                self.role, divid)

        elif card in '+*':

            return "removeInlineForm('%%s', '%%s', '%s', '%%s')" % self.role

        # don't do anything for card == '1'

    @cached

    def _entity(self):

        try:

            cls = self._cw.vreg['etypes'].etype_class(self.etype)

        except Exception:

            self.w(self._cw._('no such entity type %s') % self.etype)

            return

        entity = cls(self._cw)

        entity.eid = self._cw.varmaker.next()

        return entity

    def call(self, i18nctx, **kwargs):

        self.render_form(i18nctx, **kwargs)

class InlineAddNewLinkView(InlineEntityCreationFormView):

    """

    :attr card: the cardinality of the relation according to role of `peid`

    """

    __regid__ = 'inline-addnew-link'

    __select__ = (match_kwargs('peid', 'petype', 'rtype')

                  & specified_etype_implements('Any'))

    _select_attrs = InlineEntityCreationFormView._select_attrs + ('card',)

    card = None # make pylint happy

    form = None # no actual form wrapped

    def call(self, i18nctx, **kwargs):

        self._cw.set_varmaker()

        divid = "addNew%s%s%s:%s" % (self.etype, self.rtype, self.role, self.peid)

        self.w(u'<div class="inlinedform" id="%s" cubicweb:limit="true">'

          % divid)

        js = "addInlineCreationForm('%s', '%s', '%s', '%s', '%s', '%s')" % (

            self.peid, self.petype, self.etype, self.rtype, self.role, i18nctx)

        if self.pform.should_hide_add_new_relation_link(self.rtype, self.card):

            js = "toggleVisibility('%s'); %s" % (divid, js)

        __ = self._cw.pgettext

        self.w(u'<a class="addEntity" id="add%s:%slink" href="javascript: %s" >+ %s.</a>'

          % (self.rtype, self.peid, js, __(i18nctx, 'add a %s' % self.etype)))