"""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.interfaces import IWorkflowable

from cubicweb.common.utils import make_uid

from cubicweb.common.uilib import cut

from cubicweb.common.selectors import (accept_etype, match_kwargs,

                                    one_line_rset, implement_interface,

                                    match_form_params, accept)

from cubicweb.common.view import EntityView

from cubicweb.web import INTERNAL_FIELD_VALUE, stdmsgs, eid_param

from cubicweb.web.controller import NAV_FORM_PARAMETERS

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

from cubicweb.web.form import EntityForm, relation_id

_ = unicode

class DeleteConfForm(EntityForm):

    id = 'deleteconf'

    title = _('delete')

    domid = 'deleteconf'

    onsubmit = None

    # don't use navigation, all entities asked to be deleted should be displayed

    # else we will only delete the displayed page

    need_navigation = False

    def call(self):

        """ask for confirmation before real deletion"""

        _ = self.req._

        self.req.add_js('cubicweb.edition.js')

        self.w(u'<script type="text/javascript">updateMessage(\'%s\');</script>\n' % _('this action is not reversible!'))

        # XXX above message should have style of a warning

        self.w(u'<h4>%s</h4>\n' % _('Do you want to delete the following element(s) ?'))

        if self.onsubmit:

            self.w(u'<form id="deleteconf" action="%s" onsubmit="%s" method="post">'

                   % (self.build_url(), self.onsubmit))

        else:

            self.w(u'<form id="deleteconf" action="%s" method="post">'

                   % (self.build_url()))

        self.w(u'<fieldset>\n')

        self.display_rset()

        #self.w(u'<input type="hidden" name="rql" value="%s"/>' % self.req.form['rql'])

        self.w(u'<input type="hidden" name="__form_id" value="%s"/>' % self.id)

        self.w(self.button_delete(label=stdmsgs.YES))

        self.w(self.button_cancel(label=stdmsgs.NO))

        for param in NAV_FORM_PARAMETERS:

            value = self.req.form.get(param)

            if value:

                self.w(u'<input type="hidden" name="%s" value="%s"/>' % (param, value))

        self.w(u'</fieldset></form>\n')

    def display_rset(self):

        self.w(u'<ul>\n')

        done = set()

        for i in xrange(self.rset.rowcount):

            if self.rset[i][0] in done:

                continue

            done.add(self.rset[i][0])

            self.cell_call(i, 0)

        self.w(u'</ul>\n')

    def cell_call(self, row, col):

        entity = self.entity(row, col)

        self.w(u'<li>')

        self.w(u'<input type="hidden" name="eid" value="%s" />' % entity.eid)

        self.w(u'<input type="hidden" name="%s" value="%s"/>\n'

               % (eid_param('__type', entity.eid), self.rset.description[row][0]))

        self.w(u'<a href="%s">' % html_escape(entity.absolute_url()))

        # don't use outofcontext view or any other that may contain inline edition form

        self.w(html_escape(entity.view('textoutofcontext')))

        self.w(u'</a>')

        self.w(u'</li>')

class ChangeStateForm(EntityForm):

    id = 'statuschange'

    title = _('status change')

    __selectors__ = (implement_interface, match_form_params)

    accepts_interfaces = (IWorkflowable,)

    form_params = ('treid',)

    def cell_call(self, row, col, vid='secondary'):

        entity = self.entity(row, col)

        eid = entity.eid

        state = entity.in_state[0]

        transition = self.req.eid_rset(self.req.form['treid']).get_entity(0, 0)

        dest = transition.destination()

        self.req.add_js('cubicweb.edition.js')

        _ = self.req._

        self.w(self.error_message())

        self.w(u'<h4>%s %s</h4>\n' % (_(transition.name), entity.view('oneline')))

        msg = _('status will change from %(st1)s to %(st2)s') % {

            'st1': _(state.name),

            'st2': _(dest.name)}

        self.w(u'<p>%s</p>\n' % msg)

        self.w(u'<form action="%s" onsubmit="return freezeFormButtons(\'entityForm\');" method="post" id="entityForm">\n'

               % self.build_url('edit'))

        self.w(u'<div id="progress">%s</div>' % _('validating...'))

        self.w(u'<fieldset>\n')

        #self.w(u'<input id="errorurl" type="hidden" name="__errorurl" value="%s"/>\n'

        #       % html_escape(self.req.url()))

        self.w(u'<input type="hidden" name="__form_id" value="%s"/>\n' % self.id)

        self.w(u'<input type="hidden" name="eid" value="%s" />' % eid)

        self.w(u'<input type="hidden" name="%s" value="%s"/>\n'

               % (eid_param('__type', eid), entity.e_schema))

        self.w(u'<input type="hidden" name="%s" value="%s"/>\n'

               % (eid_param('state', eid), dest.eid))

        self.w(u'<input type="hidden" name="__redirectpath" value="%s"/>\n'

               % html_escape(self.redirectpath(entity)))

        self.fill_form(entity, state, dest)

        self.w(u'<input type="hidden" name="__method" value="set_state"/>\n')

        self.w(self.button_ok(label=stdmsgs.YES, tabindex=self.req.next_tabindex()))

        self.w(self.button_cancel(label=stdmsgs.NO, tabindex=self.req.next_tabindex()))

        self.w(u'</fieldset>\n')

        self.w(u'</form>')

    def fill_form(self, entity, state, dest):

        # hack to use the widget for comment_format

        trinfo = self.vreg.etype_class('TrInfo')(self.req, None)

        # widget are cached, copy it since we want to modify its name attribute

        wdg = trinfo.get_widget('comment_format')

        wdg.name = 'trcommentformat'

        # set a value in entity to avoid lookup for a non existant attribute...

        trinfo['trcommentformat'] = u''

        # comment format/content have to be grouped using the original entity eid

        wdg.rname = eid_param('trcommentformat', entity.eid)

        self.w(wdg.render_label(trinfo))

        self.w(wdg._edit_render(trinfo))

        self.w(u'<br/>\n')

        cformname = eid_param('trcomment', entity.eid)

        self.w(u'<label for="%s">%s</label>\n' % (cformname, self.req._('comment:')))

        self.w(u'<textarea rows="10" cols="80" name="%s" tabindex="%s"></textarea><br/>\n'

               % (cformname, self.req.next_tabindex()))

    def redirectpath(self, entity):

        return entity.rest_path()

class ClickAndEditForm(EntityForm):

    id = 'reledit'

    __selectors__ = (match_kwargs, )

    expected_kwargs = ('rtype',)

    #FIXME editableField class could be toggleable from userprefs

    EDITION_BODY = '''

<div class="editableField" id="%(divid)s"

      ondblclick="showInlineEditionForm(%(eid)s, '%(rtype)s', '%(divid)s')">%(value)s</div>

<form style="display: none;" onsubmit="return inlineValidateForm('%(divid)s-form', '%(rtype)s', '%(eid)s', '%(divid)s', %(reload)s);" id="%(divid)s-form" action="#">

<fieldset>

<input type="hidden" name="eid" value="%(eid)s" />

<input type="hidden" name="__maineid" value="%(eid)s" />

<input type="hidden" name="__type:%(eid)s" value="%(etype)s" />

%(attrform)s

</fieldset>

<div class="buttonbar">

%(ok)s

%(cancel)s

</div>

</form>

'''

    def cell_call(self, row, col, rtype=None, role='subject', reload=False):

        entity = self.entity(row, col)

        if getattr(entity, rtype) is None:

            value = self.req._('not specified')

        else:

            value = entity.printable_value(rtype)

        if not entity.has_perm('update'):

            self.w(value)

            return

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

        eid = entity.eid

        edit_key = make_uid('%s-%s' % (rtype, eid))

        divid = 'd%s' % edit_key

        widget = entity.get_widget(rtype, 'subject')

        eschema = entity.e_schema

        attrform = widget.edit_render(entity, useid='i%s' % edit_key)

        ok = (u'<input class="validateButton" type="submit" name="__action_apply" value="%s" tabindex="%s" />'

              % (self.req._(stdmsgs.BUTTON_OK), self.req.next_tabindex()))

        cancel = (u'<input class="validateButton" type="button" '

                  'value="%s" onclick="cancelInlineEdit(%s, \'%s\', \'%s\')"  tabindex="%s" />'

                  % (self.req._(stdmsgs.BUTTON_CANCEL), eid, rtype, divid,

                     self.req.next_tabindex()))

        self.w(self.EDITION_BODY % {

                'eid': eid,

                'rtype': rtype,

                'etype': entity.e_schema,

                'attrform': attrform,

                'action' : self.build_url('edit'), # NOTE: actually never gets called

                'ok': ok,

                'cancel': cancel,

                'value': value,

                'reload': dumps(reload),

                'divid': divid,

                })

class EditionForm(EntityForm):

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

    """    

    __selectors__ = (one_line_rset, accept)

    id = 'edition'

    title = _('edition')

    controller = 'edit'

    skip_relations = EntityForm.skip_relations.copy()

    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', 'cubicweb.edition.js') )

        self.req.add_css('cubicweb.form.css')

        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%%;">' %