from copy import copy

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.rtags import RelationTags

from cubicweb.web import INTERNAL_FIELD_VALUE, stdmsgs, formwidgets

from cubicweb.web.form import CompositeForm, EntityFieldsForm, FormMixIn

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)

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

        form = CompositeForm(req, domid='deleteconf', action=self.build_url('edit'),

        # XXX tabindex

        for entity in self.rset.entities():

            if entity.eid in done:

            done.add(entity.eid)

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

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

    """

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

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

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

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

        # XXX tab index

        buttons = [tags.input(klass="validateButton", type="submit",

                              name="__action_apply",

                              value=self.req._(stdmsgs.BUTTON_OK),

                              tabindex=self.req.next_tabindex()),

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

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

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

                                       cssstyle='display: none',

                                       onsubmit=self.onsubmit % locals())

                        ondblclick=self.ondblclick % locals()))

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

    """base automatic form to edit any entity

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

    * rtags (rcategories, rwidgets, inlined, rpermissions)

    * various standard form parameters

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

    AutomaticEntityForm instances.

    """

    cwtarget = 'eformframe'

    cssclass = 'entityForm'

    copy_nav_params = True

    attrcategories = ('primary', 'secondary')

    # relations'category (eg primary/secondary/generic/metadata/generated)

    rcategories = RelationTags()

    # use primary and not generated for eid since it has to be an hidden

    rcategories.set_rtag('primary', 'subject', 'eid')

    rcategories.set_rtag('metadata', 'subject', 'creation_date')

    rcategories.set_rtag('metadata', 'subject', 'modification_date')

    rcategories.set_rtag('generated', 'subject', 'has_text')        

    # relations'widget (eg one of available class name in cubicweb.web.formwidgets)

    rwidgets = RelationTags()

    # inlined view flag for non final relations

    inlined = RelationTags()

    # set of tags of the form <action>_on_new on relations. <action> is a

    # schema action (add/update/delete/read), and when such a tag is found

    # permissions checking is by-passed and supposed to be ok

    rpermissions_overrides = RelationTags(use_set=True)

    @classmethod

    def registered(cls, registry):

        """build class using descriptor at registration time"""

        super(AutomaticEntityForm, cls).registered(registry)

        cls.init_rtags_category()

        return cls

    @classmethod

    def init_rtags_category(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(role, rschema, 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, role, rschema, X, Y)

        if self.edited_entity.has_eid():

            self.edited_entity.complete()

        for rschema, role in self.editable_attributes():

            wdgname = self.rwidgets.etype_rtag(self.edited_entity.id, role, rschema)

            if wdgname:

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

                                    eidparam=True, widget=getattr(formwidgets, wdgname))

            else:

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

                                    eidparam=True)

    def action(self):

        """return the form's action attribute"""

        try:

            return self._action

        except AttributeError:

            return self.build_url('validateform')

    def set_action(self, value):

        self._action = value

    action = property(action, set_action)

        """return the form's buttons (as string)"""

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

    def relations_by_category(self, categories=None, permission=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  = self.edited_entity.e_schema

        rtags = self.rcategories

        permsoverrides = self.rpermissions_overrides

        if self.edited_entity.has_eid():

            eid = self.edited_entity.eid

        else:

            eid = None

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

            if rschema in ('identity', 'has_text'):

                continue

            # 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, role, rschema, 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, role, rschema):

                    yield (rschema, targetschemas, role)

                    continue

                if rschema.is_final():

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

                        continue

                elif role == 'subject':

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

                            rschema.has_perm(self.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 self.edited_entity.related(rschema.type, role)

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

                                                 toeid=self.edited_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(self.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 self.edited_entity.related(rschema.type, role)

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

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

                        continue

            yield (rschema, targetschemas, role)

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

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

        removing final relations

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

        """

        result = []

        for rschema, ttypes, role in self.relations_by_category(categories,

                                                                permission):

            if rschema.is_final():

                continue

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

        return sorted(result)

    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)

        # XXX add metadata category quick fix to get Folder relations

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

            relatedrset = entity.related(rschema, role, limit=self.limit)

            if rschema.has_perm(self.req, 'delete'):

                toggable_rel_link_func = toggable_relation_link

            else:

                toggable_rel_link_func = lambda x, y, z: u''

            related = []

            for row in xrange(relatedrset.rowcount):

                nodeid = relation_id(entity.eid, rschema, role,

                                     relatedrset[row][0])

                if nodeid in pending_deletes:

                    status = u'pendingDelete'

                    label = '+'

                else:

                    status = u''

                    label = 'x'

                dellink = toggable_rel_link_func(entity.eid, nodeid, label)

                eview = self.view('oneline', relatedrset, row=row)

                related.append((nodeid, dellink, status, eview))

            yield (rschema, role, related)

    def restore_pending_inserts(self, cell=False):

        """used to restore edition page as it was before clicking on

        'search for <some entity type>'

        """

        eid = self.edited_entity.eid

        cell = cell and "div_insert_" or "tr"

        pending_inserts = set(self.req.get_pending_inserts(eid))

        for pendingid in pending_inserts:

            eidfrom, rtype, eidto = pendingid.split(':')

            if typed_eid(eidfrom) == eid: # subject

                label = display_name(self.req, rtype, 'subject')

                reid = eidto

            else:

                label = display_name(self.req, rtype, 'object')