# copyright 2003-2010 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

# contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

#

# This file is part of CubicWeb.

#

# CubicWeb is free software: you can redistribute it and/or modify it under the

# terms of the GNU Lesser General Public License as published by the Free

# Software Foundation, either version 2.1 of the License, or (at your option)

# any later version.

#

# CubicWeb is distributed in the hope that it will be useful, but WITHOUT

# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

# FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

# details.

#

# You should have received a copy of the GNU Lesser General Public License along

# with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

"""Specific views for schema related entities

"""

__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.view import EntityView, StartupView

from cubicweb import tags, uilib

from cubicweb.web import action, facet, uicfg, schemaviewer

from cubicweb.web.views import TmpFileViewMixin

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

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

_pvdc = uicfg.primaryview_display_ctrl

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

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

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

for _etype in ('CWEType', 'CWRType', 'CWAttribute', 'CWRelation'):

    _pvdc.tag_attribute((_etype, 'description'), {'showlabel': False})

_pvs.tag_attribute(('CWEType', 'name'), 'hidden')

_pvs.tag_attribute(('CWEType', 'final'), 'hidden')

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

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

_pvs.tag_object_of(('*', 'specializes', 'CWEType'), 'hidden')

_pvs.tag_subject_of(('CWEType', 'specializes', '*'), 'hidden')

_pvs.tag_object_of(('*', 'from_entity', 'CWEType'), 'hidden')

_pvs.tag_object_of(('*', 'to_entity', 'CWEType'), 'hidden')

_pvs.tag_attribute(('CWRType', 'name'), 'hidden')

_pvs.tag_attribute(('CWRType', 'final'), 'hidden')

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

_pvs.tag_subject_of(('CWAttribute', 'constrained_by', '*'), 'hidden')

_pvs.tag_subject_of(('CWRelation', 'constrained_by', '*'), '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)

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

            else:

                groups = permissions[action][0]

                rqlexprs = permissions[action][1]

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

                      for group, label in sorted((_(g), g) for g in groups)]

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

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

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

        tmpl = u'<strong>%s</strong> %s <strong>%s</strong>'

        for perm, rdefs in perms.iteritems():

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

    """display schema information (graphically, listing tables...) in tabs"""

    __regid__ = 'schema'

    title = _('instance schema')

    tabs = [_('schema-diagram'), _('schema-entity-types'),

            _('schema-relation-types'), _('schema-security')]

    default_tab = 'schema-diagram'

    def call(self):

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

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

class SchemaImageTab(StartupView):

    __regid__ = 'schema-diagram'

    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'<div><a href="%s">%s</a></div>' %

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

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

        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 SchemaETypeTab(StartupView):

    __regid__ = 'schema-entity-types'

    def call(self):

        self.wview('table', self._cw.execute(

            'Any X ORDERBY N WHERE X is CWEType, X name N, X final FALSE'))

class SchemaRTypeTab(StartupView):

    __regid__ = 'schema-relation-types'

    def call(self):

        self.wview('table', self._cw.execute(

            'Any X ORDERBY N WHERE X is CWRType, X name N, X final FALSE'))

class SchemaPermissionsTab(SecurityViewMixIn, StartupView):

    __regid__ = 'schema-security'

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

    def call(self, display_relations=True):

        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.uiprops['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.uiprops['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):

        super(CWETypeDescriptionTab, self).render_entity_attributes(entity)

        _ = self._cw._

        # inheritance

        if entity.specializes:

            self.w(u'<div>%s' % _('Parent classes:'))

            self.wview('csv', entity.related('specializes', 'subject'))

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

        if entity.reverse_specializes:

            self.w(u'<div>%s' % _('Sub-classes:'))

            self.wview('csv', entity.related('specializes', 'object'))

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

        # entity schema image

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

            xml_escape(entity.absolute_url(vid='schemagraph')),

            xml_escape(_('graphical schema for %s') % entity.name)))

        # entity schema attributes

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

        rset = self._cw.execute(

            'Any A,ON,D,C,A,DE,A, IDX,FTI,I18N,R,O,RN,S ORDERBY AA '

            'WHERE A is CWAttribute, A from_entity S, S eid %(x)s, '

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

            'A fulltextindexed FTI, A internationalizable I18N, A indexed IDX, '

            'A relation_type R, R name RN, A to_entity O, O name ON',

            {'x': entity.eid})

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

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

                             3: 'etype-attr-cardinality-cell',

                             4: 'rdef-constraints-cell',

                             6: 'rdef-options-cell'},

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

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

                            _(u'constraints'), _(u'description'), _('options')))

        # entity schema relations

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

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

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

                    3: 'rdef-constraints-cell',

                    4: 'rdef-options-cell'}

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

                  _(u'constraints'), _(u'options')]

        rset = self._cw.execute(

            'Any A,TT,"i18ncard_"+SUBSTRING(C,1,1),A,A, K,TTN,R,RN ORDERBY RN '

            'WHERE A is CWRelation, A from_entity S, S eid %(x)s, '

            'A composite K, A cardinality C, '

            'A relation_type R, R name RN, A to_entity TT, TT name TTN',

            {'x': entity.eid})