"""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.common.decorators import iclassmethod

from logilab.mtconverter import html_escape

from cubicweb import typed_eid

from cubicweb.selectors import (match_kwargs, one_line_rset, non_final_entity,

                                specified_etype_implements, yes)

from cubicweb.utils import make_uid

from cubicweb.view import EntityView

from cubicweb.common import tags

from cubicweb.web import INTERNAL_FIELD_VALUE, stdmsgs, uicfg

from cubicweb.web.form import (FieldNotFound, CompositeForm, EntityFieldsForm,

                               FormViewMixIn)

from cubicweb.web.formfields import guess_field

from cubicweb.web.formwidgets import Button, SubmitButton, ResetButton

from cubicweb.web.formrenderers import (FormRenderer, EntityFormRenderer,

                                        EntityCompositeFormRenderer,

                                        EntityInlinedFormRenderer)

_ = unicode

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 toggable_relation_link(eid, nodeid, label='x'):

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

    entities

    """

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

        nodeid, html_escape(dumps(eid)))

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

        js, nodeid, label)

class DeleteConfForm(FormViewMixIn, EntityView):

    """form used to confirm deletion of some entities"""

    id = 'deleteconf'

    title = _('delete')

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

        req, w = self.req, self.w

        _ = req._

        w(u'<script type="text/javascript">updateMessage(\'%s\');</script>\n'

          % _('this action is not reversible!'))

        # XXX above message should have style of a warning

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

        form = CompositeForm(req, domid='deleteconf', copy_nav_params=True,

                             action=self.build_url('edit'), onsubmit=None,

                             form_buttons=[Button(stdmsgs.YES, cwaction='delete'),

                                           Button(stdmsgs.NO, cwaction='cancel')])

        done = set()

        w(u'<ul>\n')

        for entity in self.rset.entities():

            if entity.eid in done:

                continue

            done.add(entity.eid)

            subform = EntityFieldsForm(req, entity=entity, set_error_url=False)

            form.form_add_subform(subform)

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

            w(u'<li>%s</li>' % tags.a(entity.view('textoutofcontext'),

                                      href=entity.absolute_url()))

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

        w(form.form_render())

class ClickAndEditFormView(FormViewMixIn, EntityView):

    """form used to permit ajax edition of an attribute of an entity in a view

    (double-click on the field to see an appropriate edition widget)

    """

    id = 'reledit'

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

    # FIXME editableField class could be toggleable from userprefs

    onsubmit = ("return inlineValidateForm('%(divid)s-form', '%(rtype)s', "

                "'%(eid)s', '%(divid)s', %(reload)s);")

    ondblclick = "showInlineEditionForm(%(eid)s, '%(rtype)s', '%(divid)s')"

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

        """display field to edit entity's `rtype` relation on double-click"""

        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

        eid = entity.eid

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

        divid = 'd%s' % edit_key

        reload = dumps(reload)

        buttons = [SubmitButton(stdmsgs.BUTTON_OK, cwaction='apply'),

                   Button(stdmsgs.BUTTON_CANCEL,

                          onclick="cancelInlineEdit(%s,\'%s\',\'%s\')" % (eid, rtype, divid))]

        form = self.vreg.select_object('forms', 'edition', self.req, self.rset,

                                       row=row, col=col, form_buttons=buttons,

                                       domid='%s-form' % divid, action='#',

                                       cssstyle='display: none',

                                       onsubmit=self.onsubmit % locals())

        renderer = FormRenderer(display_label=False, display_help=False,

                                display_fields=(rtype,), button_bar_class='buttonbar',

                                display_progress_div=False)

        self.w(tags.div(value, klass='editableField', id=divid,

                        ondblclick=self.ondblclick % locals()))

        self.w(form.form_render(renderer=renderer))

class AutomaticEntityForm(EntityFieldsForm):

    """base automatic form to edit any entity

    Designed to be flly generated from schema but highly configurable through:

    * rtags (rcategories, rfields, rwidgets, inlined, rpermissions)

    * various standard form parameters

    You can also easily customise it by adding/removing fields in

    AutomaticEntityForm instances.

    """

    id = 'edition'

    cwtarget = 'eformframe'

    cssclass = 'entityForm'

    copy_nav_params = True

    form_buttons = [SubmitButton(stdmsgs.BUTTON_OK),

                    Button(stdmsgs.BUTTON_APPLY, cwaction='apply'),

                    Button(stdmsgs.BUTTON_CANCEL, cwaction='cancel')]    

    attrcategories = ('primary', 'secondary')

    # class attributes below are actually stored in the uicfg module since we

    # don't want them to be reloaded

    rcategories = uicfg.rcategories

    rfields = uicfg.rfields

    rwidgets = uicfg.rwidgets

    rinlined = uicfg.rinlined

    rpermissions_overrides = uicfg.rpermissions_overrides

    @classmethod

    def vreg_initialization_completed(cls):

        """set default category tags for relations where it's not yet defined in

        the category relation tags

        """

        for eschema in cls.schema.entities():

            for rschema, tschemas, role in eschema.relation_definitions(True):

                for tschema in tschemas:

                    if role == 'subject':

                        X, Y = eschema, tschema

                        card = rschema.rproperty(X, Y, 'cardinality')[0]

                        composed = rschema.rproperty(X, Y, 'composite') == 'object'

                    else:

                        X, Y = tschema, eschema

                        card = rschema.rproperty(X, Y, 'cardinality')[1]

                        composed = rschema.rproperty(X, Y, 'composite') == 'subject'

                    if not cls.rcategories.rtag(rschema, role, X, Y):

                        if card in '1+':

                            if not rschema.is_final() and composed:

                                category = 'generated'

                            else:

                                category = 'primary'

                        elif rschema.is_final():

                            category = 'secondary'

                        else: 

                            category = 'generic'

                        cls.rcategories.set_rtag(category, rschema, role, X, Y)

    @classmethod

    def erelations_by_category(cls, entity, categories=None, permission=None, rtags=None):

        """return a list of (relation schema, target schemas, role) matching

        categories and permission

        """

        if categories is not None:

            if not isinstance(categories, (list, tuple, set, frozenset)):

                categories = (categories,)

            if not isinstance(categories, (set, frozenset)):

                categories = frozenset(categories)

        eschema  = entity.e_schema

        if rtags is None:

            rtags = cls.rcategories

        permsoverrides = cls.rpermissions_overrides

        if entity.has_eid():

            eid = entity.eid

        else:

            eid = None

        for rschema, targetschemas, role in eschema.relation_definitions(True):

            # check category first, potentially lower cost than checking

            # permission which may imply rql queries

            if categories is not None:

                targetschemas = [tschema for tschema in targetschemas

                                 if rtags.etype_rtag(eschema, rschema, role, tschema) in categories]

                if not targetschemas:

                    continue

            if permission is not None:

                # tag allowing to hijack the permission machinery when

                # permission is not verifiable until the entity is actually

                # created...

                if eid is None and '%s_on_new' % permission in permsoverrides.etype_rtags(eschema, rschema, role):

                    yield (rschema, targetschemas, role)

                    continue

                if rschema.is_final():

                    if not rschema.has_perm(entity.req, permission, eid):

                        continue

                elif role == 'subject':

                    if not ((eid is None and rschema.has_local_role(permission)) or

                            rschema.has_perm(entity.req, permission, fromeid=eid)):

                        continue

                    # on relation with cardinality 1 or ?, we need delete perm as well

                    # if the relation is already set

                    if (permission == 'add'

                        and rschema.cardinality(eschema, targetschemas[0], role) in '1?'

                        and eid and entity.related(rschema.type, role)

                        and not rschema.has_perm(entity.req, 'delete', fromeid=eid,

                                                 toeid=entity.related(rschema.type, role)[0][0])):

                        continue

                elif role == 'object':

                    if not ((eid is None and rschema.has_local_role(permission)) or

                            rschema.has_perm(entity.req, permission, toeid=eid)):

                        continue

                    # on relation with cardinality 1 or ?, we need delete perm as well

                    # if the relation is already set

                    if (permission == 'add'

                        and rschema.cardinality(targetschemas[0], eschema, role) in '1?'

                        and eid and entity.related(rschema.type, role)

                        and not rschema.has_perm(entity.req, 'delete', toeid=eid,

                                                 fromeid=entity.related(rschema.type, role)[0][0])):

                        continue

            yield (rschema, targetschemas, role)

    @classmethod

    def esrelations_by_category(cls, entity, categories=None, permission=None):

        """filter out result of relations_by_category(categories, permission) by

        removing final relations

        return a sorted list of (relation's label, relation'schema, role) 

        """

        result = []

        for rschema, ttypes, role in cls.erelations_by_category(

            entity, categories, permission):

            if rschema.is_final():

                continue

            result.append((rschema.display_name(entity.req, role), rschema, role))

        return sorted(result)

    @iclassmethod

    def field_by_name(cls_or_self, name, role='subject', eclass=None):

        """return field with the given name and role. If field is not explicitly

        defined for the form but `eclass` is specified, guess_field will be

        called.

        """

        try:

            return super(AutomaticEntityForm, cls_or_self).field_by_name(name, role)

        except FieldNotFound: # XXX should raise more explicit exception

            if eclass is None:

                raise

            field = guess_field(eclass, cls_or_self.schema.rschema(name), role,

                                eidparam=True)

            if field is None:

                raise

            return field

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

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

        if self.edited_entity.has_eid():

            self.edited_entity.complete()

        for rschema, role in self.editable_attributes():

            try:

                self.field_by_name(rschema.type, role)

                continue # explicitly specified

            except FieldNotFound:

                pass # has to be guessed

            fieldcls = self.rfields.etype_rtag(self.edited_entity.id, rschema,

                                               role)

            if fieldcls:

                field = fieldcls(name=rschema.type, role=role, eidparam=True)

                self.fields.append(field)

                continue

            widget = self.rwidgets.etype_rtag(self.edited_entity.id, rschema,

                                              role)

            if widget:

                field = guess_field(self.edited_entity.__class__, rschema, role,

                                    eidparam=True, widget=widget)

            else:

                field = guess_field(self.edited_entity.__class__, rschema, role,

                                    eidparam=True)

            if field is not None:

                self.fields.append(field)

        self.maxrelitems = self.req.property_value('navigation.related-limit')

        self.force_display = bool(self.req.form.get('__force_display'))

    @property

    def related_limit(self):

        if self.force_display:

            return None

        return self.maxrelitems + 1

    def relations_by_category(self, categories=None, permission=None):

        """return a list of (relation schema, target schemas, role) matching

        given category(ies) and permission

        """

        return self.erelations_by_category(self.edited_entity, categories,

                                           permission)

    def inlined_relations(self):

        """return a list of (relation schema, target schemas, role) matching

        given category(ies) and permission

        """

        # we'll need an initialized varmaker if there are some inlined relation

        self.initialize_varmaker()

        return self.erelations_by_category(self.edited_entity, True, 'add', self.rinlined)

    def srelations_by_category(self, categories=None, permission=None):

        """filter out result of relations_by_category(categories, permission) by

        removing final relations

        return a sorted list of (relation's label, relation'schema, role) 

        """

        return self.esrelations_by_category(self.edited_entity, categories,

                                           permission)

    def action(self):

        """return the form's action attribute. Default to validateform if not

        explicitly overriden.

        """

        try:

            return self._action

        except AttributeError:

            return self.build_url('validateform')

    def set_action(self, value):

        """override default action"""

        self._action = value

    action = property(action, set_action)

    def editable_attributes(self):

        """return a list of (relation schema, role) to edit for the entity"""

        return [(rschema, x) for rschema, _, x in self.relations_by_category(

            self.attrcategories, 'add') if rschema != 'eid']

    def relations_table(self):

        """yiels 3-tuples (rtype, target, related_list)

        where <related_list> itself a list of :

          - node_id (will be the entity element's DOM id)

          - appropriate javascript's togglePendingDelete() function call

          - status 'pendingdelete' or ''

          - oneline view of related entity

        """

        entity = self.edited_entity

        pending_deletes = self.req.get_pending_deletes(entity.eid)        

        for label, rschema, role in self.srelations_by_category('generic', 'add'):