"""The automatic entity form.

:organization: Logilab

:copyright: 2001-2010 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"

_ = unicode

from simplejson import dumps

from logilab.mtconverter import xml_escape

from logilab.common.decorators import iclassmethod, cached

from cubicweb import typed_eid, neg_role, uilib

from cubicweb.schema import display_name

from cubicweb.view import EntityView

from cubicweb.selectors import (

    match_kwargs, match_form_params, non_final_entity,

    specified_etype_implements)

from cubicweb.web import stdmsgs, uicfg, eid_param, \

     form as f, formwidgets as fw, formfields as ff

from cubicweb.web.views import forms

_AFS = uicfg.autoform_section

_AFFK = uicfg.autoform_field_kwargs

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

class InlinedFormField(ff.Field):

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

        kwargs.setdefault('label', None)

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

                                               eidparam=True, **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')"

    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

    @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 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.removejs and self.removejs % (

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

        countkey = '%s_count' % self.rtype

        try:

            self._cw.data[countkey] += 1

        except KeyError:

            self._cw.data[countkey] = 1

        self.w(self.form.render(

            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.__regid__)

    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',)

    @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 not in '?1':

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

        divid = "addNew%s%s%s:%s" % (

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

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

            self.role, divid)

    @cached

    def _entity(self):

        try:

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

        except:

            self.w(self._cw._('no such entity type %s') % 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',)

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

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

# generic relations handling ##################################################

def relation_id(eid, rtype, role, reid):

    """return an identifier for a relation between two entities"""

    if role == 'subject':

        return u'%s:%s:%s' % (eid, rtype, reid)

    return u'%s:%s:%s' % (reid, rtype, eid)

def toggleable_relation_link(eid, nodeid, label='x'):

    """return javascript snippet to delete/undelete a relation between two

    entities

    """

    js = u"javascript: togglePendingDelete('%s', %s);" % (

        nodeid, xml_escape(dumps(eid)))

    return u'[<a class="handle" href="%s" id="handle%s">%s</a>]' % (

        js, nodeid, label)

def get_pending_inserts(req, eid=None):

    """shortcut to access req's pending_insert entry

    This is where are stored relations being added while editing

    an entity. This used to be stored in a temporary cookie.

    """

    pending = req.get_session_data('pending_insert') or ()

    return ['%s:%s:%s' % (subj, rel, obj) for subj, rel, obj in pending

            if eid is None or eid in (subj, obj)]

def get_pending_deletes(req, eid=None):

    """shortcut to access req's pending_delete entry

    This is where are stored relations being removed while editing

    an entity. This used to be stored in a temporary cookie.

    """

    pending = req.get_session_data('pending_delete') or ()

    return ['%s:%s:%s' % (subj, rel, obj) for subj, rel, obj in pending

            if eid is None or eid in (subj, obj)]

def parse_relations_descr(rdescr):

    """parse a string describing some relations, in the form

    subjeids:rtype:objeids

    where subjeids and objeids are eids separeted by a underscore

    return an iterator on (subject eid, relation type, object eid) found

    """

    for rstr in rdescr:

        subjs, rtype, objs = rstr.split(':')

        for subj in subjs.split('_'):

            for obj in objs.split('_'):

                yield typed_eid(subj), rtype, typed_eid(obj)

def delete_relations(req, rdefs):

    """delete relations from the repository"""

    # FIXME convert to using the syntax subject:relation:eids

    execute = req.execute

    for subj, rtype, obj in parse_relations_descr(rdefs):

        rql = 'DELETE X %s Y where X eid %%(x)s, Y eid %%(y)s' % rtype

        execute(rql, {'x': subj, 'y': obj}, ('x', 'y'))

    req.set_message(req._('relations deleted'))

def insert_relations(req, rdefs):

    """insert relations into the repository"""

    execute = req.execute

    for subj, rtype, obj in parse_relations_descr(rdefs):

        rql = 'SET X %s Y where X eid %%(x)s, Y eid %%(y)s' % rtype

        execute(rql, {'x': subj, 'y': obj}, ('x', 'y'))

class GenericRelationsWidget(fw.FieldWidget):

    def render(self, form, field, renderer):

        stream = []

        w = stream.append

        req = form._cw

        _ = req._

        __ = _

        eid = form.edited_entity.eid

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

        for rschema, role, related in field.relations_table(form):

            # already linked entities

            if related:

                w(u'<tr><th class="labelCol">%s</th>' % rschema.display_name(req, role))

                w(u'<td>')

                w(u'<ul>')

                for viewparams in related:

                    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 form.force_display and form.maxrelitems < len(related):

                    link = (u'<span class="invisible">'

                            '[<a href="javascript: window.location.href+=\'&amp;__force_display=1\'">%s</a>]'

                            '</span>' % _('view all'))

                    w(u'<li class="invisible">%s</li>' % link)

                w(u'</ul>')

                w(u'</td>')

                w(u'</tr>')

        pendings = list(field.restore_pending_inserts(form))

        if not pendings:

            w(u'<tr><th>&#160;</th><td>&#160;</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], xml_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'<select id="relationSelector_%s" tabindex="%s" '

          'onchange="javascript:showMatchingSelect(this.options[this.selectedIndex].value,%s);">'

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

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

        for i18nrtype, rschema, role in field.relations:

            # more entities to link to

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

        w(u'</select>')

        w(u'</th>')

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

        w(u'</tr>')

        w(u'</table>')

        return '\n'.join(stream)

class GenericRelationsField(ff.Field):