"""Specific views for schema related entities

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

from itertools import cycle

from logilab.common.ureports import Section, Table

from logilab.mtconverter import xml_escape

from yams import BASE_TYPES, schema2dot as s2d

from yams.buildobjs import DEFAULT_ATTRPERMS

from cubicweb.selectors import (implements, yes, match_user_groups,

                                has_related_entities, authenticated_user)

from cubicweb.schema import (META_RTYPES, SCHEMA_TYPES, SYSTEM_RTYPES,

                             WORKFLOW_TYPES, INTERNAL_TYPES)

from cubicweb.schemaviewer import SchemaViewer

from cubicweb.view import EntityView, StartupView

from cubicweb import tags, uilib

from cubicweb.web import action, facet, uicfg

from cubicweb.web.views import TmpFileViewMixin

from cubicweb.web.views import primary, baseviews, tabs, tableview, iprogress

ALWAYS_SKIP_TYPES = BASE_TYPES | SCHEMA_TYPES

SKIP_TYPES  = (ALWAYS_SKIP_TYPES | META_RTYPES | SYSTEM_RTYPES | WORKFLOW_TYPES

               | INTERNAL_TYPES)

SKIP_TYPES.update(set(('CWUser', 'CWGroup')))

def skip_types(req):

    if int(req.form.get('skipmeta', True)):

        return SKIP_TYPES

    return ALWAYS_SKIP_TYPES

_pvs = uicfg.primaryview_section

for _action in ('read', 'add', 'update', 'delete'):

    _pvs.tag_subject_of(('*', '%s_permission' % _action, '*'), 'hidden')

    _pvs.tag_object_of(('*', '%s_permission' % _action, '*'), 'hidden')

_pvs.tag_object_of(('Workflow', 'workflow_of', 'CWEType'), 'hidden')

_pvs.tag_subject_of(('CWEType', 'default_workflow', 'Workflow'), 'hidden')

_pvs.tag_object_of(('*', 'relation_type', 'CWRType'), 'hidden')

class SecurityViewMixIn(object):

    """mixin providing methods to display security information for a entity,

    relation or relation definition schema

    """

    def permissions_table(self, erschema, permissions=None):

        self._cw.add_css('cubicweb.acl.css')

        w = self.w

        _ = self._cw._

        w(u'<table class="schemaInfo">')

        w(u'<tr><th>%s</th><th>%s</th><th>%s</th></tr>' % (

            _("permission"), _('granted to groups'), _('rql expressions')))

        for action in erschema.ACTIONS:

            w(u'<tr><td>%s</td><td>' % _(action))

            if permissions is None:

                groups = erschema.get_groups(action)

            else:

            # XXX get group entity and call it's incontext view

            groups = [u'<a class="%s" href="%s">%s</a>' % (

                group, self._cw.build_url('cwgroup/%s' % group), label)

            w(u'<br/>'.join(groups))

            w(u'</td><td>')

            if permissions is None:

                rqlexprs = sorted(e.expression for e in erschema.get_rqlexprs(action))

            else:

                rqlexprs = permissions[action][1]

            w(u'<br/>'.join(rqlexprs))

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

        w(u'</table>')

    def grouped_permissions_table(self, rschema):

        # group relation definitions with identical permissions

        perms = {}

        for rdef in rschema.rdefs.itervalues():

            rdef_perms = []

            for action in ('read', 'add', 'delete'):

                groups = sorted(rdef.get_groups(action))

                exprs = sorted(e.expression for e in rdef.get_rqlexprs(action))

                rdef_perms.append( (action, (tuple(groups), tuple(exprs))) )

            rdef_perms = tuple(rdef_perms)

            if rdef_perms in perms:

                perms[rdef_perms].append( (rdef.subject, rdef.object) )

            else:

                perms[rdef_perms] = [(rdef.subject, rdef.object)]

        # set layout permissions in a table for each group of relation

        # definition

        w = self.w

        w(u'<div style="margin: 0px 1.5em">')

            w(u'<div>%s</div>' % u', '.join(

                tmpl % (_(s.type), _(rschema.type), _(o.type)) for s, o in rdefs))

            # accessing rdef from previous loop by design: only used to get

            # ACTIONS

            self.permissions_table(rdef, dict(perm))

        w(u'</div>')

# global schema view ###########################################################

class SchemaView(tabs.TabsMixin, StartupView):

    __regid__ = 'schema'

    title = _('instance schema')

    tabs = [_('schema-description'), _('schema-image'), _('schema-security')]

    default_tab = 'schema-description'

    def call(self):

        """display schema information"""

        self.w(u'<h1>%s</h1>' % _('Schema of the data model'))

        self.render_tabs(self.tabs, self.default_tab)

class SchemaImageTab(StartupView):

    __regid__ = 'schema-image'

    def call(self):

        self.w(_(u'<div>This schema of the data model <em>excludes</em> the '

                 u'meta-data, but you can also display a <a href="%s">complete '

                 u'schema with meta-data</a>.</div>')

               % xml_escape(self._cw.build_url('view', vid='schemagraph', skipmeta=0)))

        self.w(u'<img src="%s" alt="%s"/>\n' % (

            xml_escape(self._cw.build_url('view', vid='schemagraph', skipmeta=1)),

            self._cw._("graphical representation of the instance'schema")))

class SchemaDescriptionTab(StartupView):

    __regid__ = 'schema-description'

    def call(self):

        rset = self._cw.execute('Any X ORDERBY N WHERE X is CWEType, X name N, '

                                'X final FALSE')

        self.wview('table', rset, displayfilter=True)

        rset = self._cw.execute('Any X ORDERBY N WHERE X is CWRType, X name N, '

                                'X final FALSE')

        self.wview('table', rset, displayfilter=True)

        owl_downloadurl = self._cw.build_url('view', vid='owl')

        self.w(u'<div><a href="%s">%s</a></div>' %

               (owl_downloadurl, self._cw._(u'Download schema as OWL')))

class SchemaPermissionsTab(SecurityViewMixIn, StartupView):

    __regid__ = 'schema-security'

    __select__ = StartupView.__select__ & match_user_groups('managers')

    def call(self, display_relations=True):

        self._cw.add_css('cubicweb.acl.css')

        skiptypes = skip_types(self._cw)

        schema = self._cw.vreg.schema

        # compute entities

        entities = sorted(eschema for eschema in schema.entities()

                          if not (eschema.final or eschema in skiptypes))

        # compute relations

        if display_relations:

            relations = sorted(rschema for rschema in schema.relations()

                               if not (rschema.final

                                       or rschema in skiptypes

                                       or rschema in META_RTYPES))

        else:

            relations = []

        # index

        _ = self._cw._

        url = xml_escape(self._cw.build_url('schema'))

        self.w(u'<div id="schema_security">')

        self.w(u'<h2 class="schema">%s</h2>' % _('Index'))

        self.w(u'<h4 id="entities">%s</h4>' % _('Entity types'))

        ents = []

        for eschema in sorted(entities):

            ents.append(u'<a class="grey" href="%s#%s">%s</a>' % (

                url,  eschema.type, eschema.type))

        self.w(u', '.join(ents))

        self.w(u'<h4 id="relations">%s</h4>' % _('Relation types'))

        rels = []

        for rschema in sorted(relations):

            rels.append(u'<a class="grey" href="%s#%s">%s</a>' %  (

                url , rschema.type, rschema.type))

        self.w(u', '.join(rels))

        # permissions tables

        self.display_entities(entities)

        if relations:

            self.display_relations(relations)

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

    def has_non_default_perms(self, rdef):

        """return true if the given *attribute* relation definition has custom

        permission

        """

        for action in rdef.ACTIONS:

            def_rqlexprs = []

            def_groups = []

            for perm in DEFAULT_ATTRPERMS[action]:

                if not isinstance(perm, basestring):

                    def_rqlexprs.append(perm.expression)

                else:

                    def_groups.append(perm)

            rqlexprs = [rql.expression for rql in rdef.get_rqlexprs(action)]

            groups = rdef.get_groups(action)

            if groups != frozenset(def_groups) or \

                frozenset(rqlexprs) != frozenset(def_rqlexprs):

                return True

        return False

    def display_entities(self, entities):

        _ = self._cw._

        url = xml_escape(self._cw.build_url('schema'))

        self.w(u'<h2 id="entities" class="schema">%s</h2>' % _('Permissions for entity types'))

        for eschema in entities:

            self.w(u'<h3 id="%s" class="schema"><a href="%s">%s (%s)</a> ' % (

                eschema.type, self._cw.build_url('cwetype/%s' % eschema.type),

                eschema.type, _(eschema.type)))

            self.w(u'<a href="%s#schema_security"><img src="%s" alt="%s"/></a>' % (

                url,  self._cw.external_resource('UP_ICON'), _('up')))

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

            self.w(u'<div style="margin: 0px 1.5em">')

            self.permissions_table(eschema)

            # display entity attributes only if they have some permissions modified

            modified_attrs = []

            for attr, etype in  eschema.attribute_definitions():

                rdef = eschema.rdef(attr)

                if attr not in META_RTYPES and self.has_non_default_perms(rdef):

                    modified_attrs.append(rdef)

            if modified_attrs:

                self.w(u'<h4>%s</h4>' % _('Attributes with non default permissions:'))

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

                self.w(u'<div style="margin: 0px 6em">')

                for rdef in modified_attrs:

                    attrtype = str(rdef.rtype)

                    self.w(u'<h4 class="schema">%s (%s)</h4> ' % (attrtype, _(attrtype)))

                    self.permissions_table(rdef)

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

    def display_relations(self, relations):

        _ = self._cw._

        url = xml_escape(self._cw.build_url('schema'))

        self.w(u'<h2 id="relations" class="schema">%s</h2>' % _('Permissions for relations'))

        for rschema in relations:

            self.w(u'<h3 id="%s" class="schema"><a href="%s">%s (%s)</a> ' % (

                rschema.type, self._cw.build_url('cwrtype/%s' % rschema.type),

                rschema.type, _(rschema.type)))

            self.w(u'<a href="%s#schema_security"><img src="%s" alt="%s"/></a>' % (

                url,  self._cw.external_resource('UP_ICON'), _('up')))

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

            self.grouped_permissions_table(rschema)

# CWEType ######################################################################

# register msgid generated in entity relations tables

_('i18ncard_1'), _('i18ncard_?'), _('i18ncard_+'), _('i18ncard_*')

class CWETypePrimaryView(tabs.TabbedPrimaryView):

    __select__ = implements('CWEType')

    tabs = [_('cwetype-description'), _('cwetype-box'), _('cwetype-workflow'),

            _('cwetype-views'), _('cwetype-permissions')]

    default_tab = 'cwetype-description'

class CWETypeDescriptionTab(tabs.PrimaryTab):

    __regid__ = 'cwetype-description'

    __select__ = tabs.PrimaryTab.__select__ & implements('CWEType')

    def render_entity_attributes(self, entity, siderelations=None):

        self.w(u'<div>%s</div>' % xml_escape(entity.description or u''))

        # entity schema image

        url = entity.absolute_url(vid='schemagraph')

        self.w(u'<img src="%s" alt="%s"/>' % (

            xml_escape(url),

        # entity schema attributes

        self.w(u'<h2>%s</h2>' % _('Attributes'))

        rset = self._cw.execute(

            'A ordernum AA, A defaultval D, A description DE, A cardinality C, '

            'A fulltextindexed I, A internationalizable J, '

            'A relation_type R, R name N, A to_entity O, O name F, '

            'A from_entity S, S eid %(x)s',

            {'x': entity.eid})

        self.wview('table', rset, 'null',

                   cellvids={0: 'rdef-name-cell',

                            _(u'default value'), _(u'required'),

                            _(u'fulltext indexed'), _(u'internationalizable'),

                   mainindex=0)

        # entity schema relations

        self.w(u'<h2>%s</h2>' % _('Relations'))

        rset = self._cw.execute(

            {'x': entity.eid})

        if rset:

            self.w(u'<h5>%s %s</h5>' % (entity.name, _('is subject of:')))

        self.wview('table', rset, 'null',

                   cellvids={0: 'rdef-name-cell',

                             2: 'etype-rel-cardinality-cell',

                   headers=(_(u'name'), _(u'object type'), _(u'cardinality'),

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

        rset = self._cw.execute(

            {'x': entity.eid})

        if rset:

            self.w(u'<h5>%s %s</h5>' % (entity.name, _('is object of:')))

        self.wview('table', rset, 'null',

                   cellvids={0: 'rdef-object-name-cell',

                             2: 'etype-rel-cardinality-cell',

                   headers=(_(u'name'), _(u'subject type'), _(u'cardinality'),

class CWETypeAttributeCardinalityCell(baseviews.FinalView):

    __regid__ = 'etype-attr-cardinality-cell'

    def cell_call(self, row, col):

        if self.cw_rset.rows[row][col][0] == '1':

class CWETypeRelationCardinalityCell(baseviews.FinalView):

    __regid__ = 'etype-rel-cardinality-cell'

    def cell_call(self, row, col):