"""Set of HTML automatic forms to create, delete, copy or edit a single entity

or a list of entities of the same type

:organization: Logilab

:copyright: 2001-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

"""

__docformat__ = "restructuredtext en"

from copy import copy

from simplejson import dumps

from logilab.mtconverter import html_escape

from logilab.common.decorators import cached

from cubicweb.selectors import (specified_etype_implements, accepts_etype_compat,

                                non_final_entity, match_kwargs, one_line_rset)

from cubicweb.view import View, EntityView

from cubicweb.web import INTERNAL_FIELD_VALUE, eid_param

from cubicweb.web.controller import NAV_FORM_PARAMETERS

from cubicweb.web.widgets import checkbox, InputWidget, ComboBoxWidget

from cubicweb.web.form import FormMixIn

from cubicweb.web.views.autoform import AutomaticEntityForm

_ = unicode

class EditionForm(FormMixIn, EntityView):

    """primary entity edition form

    When generating a new attribute_input, the editor will look for a method

    named 'default_ATTRNAME' on the entity instance, where ATTRNAME is the

    name of the attribute being edited. You may use this feature to compute

    dynamic default values such as the 'tomorrow' date or the user's login

    being connected

    """    

    id = 'edition'

    __select__ = one_line_rset() & non_final_entity()

    title = _('edition')

    controller = 'edit'

    skip_relations = set()

    EDITION_BODY = u'''\

 %(errormsg)s

<form id="%(formid)s" class="entityForm" cubicweb:target="eformframe"

      method="post" onsubmit="%(onsubmit)s" enctype="%(enctype)s" action="%(action)s">

 %(title)s

 <div id="progress">%(inprogress)s</div>

 <div class="iformTitle"><span>%(mainattrs_label)s</span></div>

 <div class="formBody"><fieldset>

 %(base)s

 %(attrform)s

 %(relattrform)s

</fieldset>

 %(relform)s

 </div>

 <table width="100%%">

  <tbody>

   <tr><td align="center">

     %(validate)s

   </td><td style="align: right; width: 50%%;">

     %(apply)s

     %(cancel)s

   </td></tr>

  </tbody>

 </table>

</form>

'''

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

        self.req.add_js( ('cubicweb.ajax.js', ) )

        entity = self.complete_entity(row, col)

        self.edit_form(entity, kwargs)

    def edit_form(self, entity, kwargs):

        varmaker = self.req.get_page_data('rql_varmaker')

        if varmaker is None:

            varmaker = self.req.varmaker

            self.req.set_page_data('rql_varmaker', varmaker)

        self.varmaker = varmaker

        self.w(self.EDITION_BODY % self.form_context(entity, kwargs))

    def form_context(self, entity, kwargs):

        """returns the dictionnary used to fill the EDITION_BODY template

        If you create your own edition form, you can probably just override

        `EDITION_BODY` and `form_context`

        """

        if self.need_multipart(entity):

            enctype = 'multipart/form-data'

        else:

            enctype = 'application/x-www-form-urlencoded'

        self._hiddens = []

        if entity.eid is None:

            entity.eid = self.varmaker.next()

        # XXX (hack) action_title might need __linkto req's original value

        #            and widgets such as DynamicComboWidget might change it

        #            so we need to compute title before calling atttributes_form

        formtitle = self.action_title(entity)

        # be sure to call .*_form first so tabindexes are correct and inlined

        # fields errors are consumed

        if not entity.has_eid() or entity.has_perm('update'):

            attrform = self.attributes_form(entity, kwargs)

        else:

            attrform = ''

        inlineform = self.inline_entities_form(entity, kwargs)

        relform = self.relations_form(entity, kwargs)

        vindex = self.req.next_tabindex()

        aindex = self.req.next_tabindex()

        cindex = self.req.next_tabindex()

        self.add_hidden_web_behaviour_params(entity)

        _ = self.req._

        return {

            'formid'   : self.domid,

            'onsubmit' : self.on_submit(entity),

            'enctype'  : enctype,

            'errormsg' : self.error_message(),

            'action'   : self.build_url('validateform'),

            'eids'     : entity.has_eid() and [entity.eid] or [],

            'inprogress': _('validating...'),

            'title'    : formtitle,

            'mainattrs_label' : _('main informations'),

            'reseturl' : self.redirect_url(entity),

            'attrform' : attrform,

            'relform'  : relform,

            'relattrform': inlineform,

            'base'     : self.base_form(entity, kwargs),

            'validate' : self.button_ok(tabindex=vindex),

            'apply'    : self.button_apply(tabindex=aindex),

            'cancel'   : self.button_cancel(tabindex=cindex),

            }

    @property

    def formid(self):

        return self.id

    def action_title(self, entity):

        """form's title"""

        ptitle = self.req._(self.title)

        return u'<div class="formTitle"><span>%s %s</span></div>' % (

            entity.dc_type(), ptitle and '(%s)' % ptitle)

    def base_form(self, entity, kwargs):

        output = []

        for name, value, iid in self._hiddens:

            if isinstance(value, basestring):

                value = html_escape(value)

            if iid:

                output.append(u'<input id="%s" type="hidden" name="%s" value="%s" />'

                              % (iid, name, value))

            else:

                output.append(u'<input type="hidden" name="%s" value="%s" />'

                              % (name, value))

        return u'\n'.join(output)

    def add_hidden_web_behaviour_params(self, entity):

        """inserts hidden params controlling how errors and redirection

        should be handled

        """

        req = self.req

        self._hiddens.append( (u'__maineid', entity.eid, u'') )

        self._hiddens.append( (u'__errorurl', req.url(), u'errorurl') )

        self._hiddens.append( (u'__form_id', self.formid, u'') )

        for param in NAV_FORM_PARAMETERS:

            value = req.form.get(param)

            if value:

                self._hiddens.append( (param, value, u'') )

        msg = self.submited_message()

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

        for linkto in req.list_form_param('__linkto'):

            self._hiddens.append( ('__linkto', linkto, '') )

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

        self._hiddens.append( ('__message', msg, '') )

    def attributes_form(self, entity, kwargs, include_eid=True):

        """create a form to edit entity's attributes"""

        html = []

        w = html.append

        eid = entity.eid

        wdg = entity.get_widget

        lines = (wdg(rschema, x) for rschema, x in self.editable_attributes(entity))

        if include_eid:

            self._hiddens.append( ('eid', entity.eid, '') )

        self._hiddens.append( (eid_param('__type', eid), entity.e_schema, '') )

        w(u'<table id="%s" class="%s" style="width:100%%;">' %

          (kwargs.get('tab_id', 'entityForm%s' % eid),

           kwargs.get('tab_class', 'attributeForm')))

        for widget in lines:

            w(u'<tr>\n<th class="labelCol">%s</th>' % widget.render_label(entity))

            error = widget.render_error(entity)

            if error:

                w(u'<td class="error" style="width:100%;">')

            else:

                w(u'<td style="width:100%;">')

            if error:

                w(error)

            w(widget.edit_render(entity))

            w(widget.render_help(entity))

            w(u'</td>\n</tr>')

        w(u'</table>')

        return u'\n'.join(html)

    def editable_attributes(self, entity):

        # XXX both (add, delete)

        return [(rschema, x) for rschema, _, x in entity.relations_by_category(('primary', 'secondary'), 'add')

                if rschema != 'eid']

    def relations_form(self, entity, kwargs):

        srels_by_cat = entity.srelations_by_category(('generic', 'metadata'), 'add')

        if not srels_by_cat:

            return u''

        req = self.req

        _ = self.req._

        label = u'%s :' % _('This %s' % entity.e_schema).capitalize()

        eid = entity.eid

        html = []

        w = html.append

        w(u'<fieldset class="subentity">')

        w(u'<legend class="iformTitle">%s</legend>' % label)

        w(u'<table id="relatedEntities">')

        for row in self.relations_table(entity):

            # already linked entities

            if row[2]:

                w(u'<tr><th class="labelCol">%s</th>' % row[0].display_name(req, row[1]))

                w(u'<td>')

                w(u'<ul>')

                for viewparams in row[2]:

                    w(u'<li class="invisible">%s<div id="span%s" class="%s">%s</div></li>'

                      % (viewparams[1], viewparams[0], viewparams[2], viewparams[3]))

                if not self.force_display and self.maxrelitems < len(row[2]):

                    w(u'<li class="invisible">%s</li>' % self.force_display_link())

                w(u'</ul>')

                w(u'</td>')

                w(u'</tr>')

        pendings = list(self.restore_pending_inserts(entity))

        if not pendings:

            w(u'<tr><th>&nbsp;</th><td>&nbsp;</td></tr>')

        else:

            for row in pendings:

                # soon to be linked to entities

                w(u'<tr id="tr%s">' % row[1])

                w(u'<th>%s</th>' % row[3])

                w(u'<td>')

                w(u'<a class="handle" title="%s" href="%s">[x]</a>' %

                  (_('cancel this insert'), row[2]))

                w(u'<a id="a%s" class="editionPending" href="%s">%s</a>'

                  % (row[1], row[4], html_escape(row[5])))

                w(u'</td>')

                w(u'</tr>')

        w(u'<tr id="relationSelectorRow_%s" class="separator">' % eid)

        w(u'<th class="labelCol">')

        w(u'<span>%s</span>' % _('add relation'))

        w(u'<select id="relationSelector_%s" tabindex="%s" onchange="javascript:showMatchingSelect(this.options[this.selectedIndex].value,%s);">'

          % (eid, req.next_tabindex(), html_escape(dumps(eid))))

        w(u'<option value="">%s</option>' % _('select a relation'))

        for i18nrtype, rschema, target in srels_by_cat:

            # more entities to link to

            w(u'<option value="%s_%s">%s</option>' % (rschema, target, i18nrtype))

        w(u'</select>')

        w(u'</th>')

        w(u'<td id="unrelatedDivs_%s"></td>' % eid)

        w(u'</tr>')

        w(u'</table>')

        w(u'</fieldset>')

        return '\n'.join(html)

    def inline_entities_form(self, entity, kwargs):

        """create a form to edit entity's inlined relations"""

        result = []

        _ = self.req._

        for rschema, targettypes, x in entity.relations_by_category('inlineview', 'add'):

            # show inline forms only if there's one possible target type

            # for rschema

            if len(targettypes) != 1:

                self.warning('entity related by the %s relation should have '

                             'inlined form but there is multiple target types, '

                             'dunno what to do', rschema)

                continue

            targettype = targettypes[0].type

            if self.should_inline_relation_form(entity, rschema, targettype, x):

                result.append(u'<div id="inline%sslot">' % rschema)

                existant = entity.has_eid() and entity.related(rschema)

                if existant:

                    # display inline-edition view for all existing related entities

                    result.append(self.view('inline-edition', existant, 

                                            ptype=entity.e_schema, peid=entity.eid,

                                            rtype=rschema, role=x, **kwargs))

                if x == 'subject':

                    card = rschema.rproperty(entity.e_schema, targettype, 'cardinality')[0]

                else:

                    card = rschema.rproperty(targettype, entity.e_schema, 'cardinality')[1]

                # there is no related entity and we need at least one : we need to

                # display one explicit inline-creation view

                if self.should_display_inline_relation_form(rschema, existant, card):

                    result.append(self.view('inline-creation', None, etype=targettype,

                                            peid=entity.eid, ptype=entity.e_schema,

                                            rtype=rschema, role=x, **kwargs))

                # we can create more than one related entity, we thus display a link

                # to add new related entities

                if self.should_display_add_inline_relation_link(rschema, existant, card):

                    divid = "addNew%s%s%s:%s" % (targettype, rschema, x, entity.eid)

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

                                  % divid)

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

                        entity.eid, entity.e_schema, targettype, rschema, x)

                    if card in '1?':

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

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

                                  % (rschema, entity.eid, js,

                                     self.req.__('add a %s' % targettype)))

                    result.append(u'</div>')

                    result.append(u'<div class="trame_grise">&nbsp;</div>')

                result.append(u'</div>')

        return '\n'.join(result)

    # should_* method extracted to allow overriding

    def should_inline_relation_form(self, entity, rschema, targettype, role):

        return AutomaticEntityForm.rinlined.etype_rtag(entity.id, rschema, role,

                                                       targettype)

    def should_display_inline_relation_form(self, rschema, existant, card):

        return not existant and card in '1+'

    def should_display_add_inline_relation_link(self, rschema, existant, card):

        return not existant or card in '+*'

    def reset_url(self, entity):

        return entity.absolute_url()

    def on_submit(self, entity):

        return u'return freezeFormButtons(\'%s\')' % (self.domid)

    def submited_message(self):

        return self.req._('element edited')

class CreationForm(EditionForm):

    __select__ = specified_etype_implements('Any')

    # XXX bw compat, use View.registered since we don't want accept_compat

    #    wrapper set in EntityView

    registered = accepts_etype_compat(View.registered)

    id = 'creation'

    title = _('creation')

    def call(self, **kwargs):

        """creation view for an entity"""

        self.req.add_js( ('cubicweb.ajax.js',) )

        self.initialize_varmaker()

        etype = kwargs.pop('etype', self.req.form.get('etype'))

        try:

            entity = self.vreg.etype_class(etype)(self.req, None, None)

        except:

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

        else:

            entity.eid = self.varmaker.next()

            self.edit_form(entity, kwargs)

    def action_title(self, entity):

        """custom form title if creating a entity with __linkto"""

        if '__linkto' in self.req.form:

            if isinstance(self.req.form['__linkto'], list):

                # XXX which one should be considered (case: add a ticket to a version in jpl)

                rtype, linkto_eid, role = self.req.form['__linkto'][0].split(':')

            else:

                rtype, linkto_eid, role = self.req.form['__linkto'].split(':')

            linkto_rset = self.req.eid_rset(linkto_eid)