# copyright 2003-2011 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/>.

"""an helper class to display CubicWeb schema using ureports"""

__docformat__ = "restructuredtext en"

_ = unicode

from logilab.common.ureports import Section, Title, Table, Link, Span, Text

from yams.schema2dot import CARD_MAP

from yams.schema import RelationDefinitionSchema

from operator import attrgetter

TYPE_GETTER = attrgetter('type')

I18NSTRINGS = [_('read'), _('add'), _('delete'), _('update'), _('order')]

class SchemaViewer(object):

    """return a ureport layout for some part of a schema"""

    def __init__(self, req=None, encoding=None):

        self.req = req

        if req is not None:

            req.add_css('cubicweb.schema.css')

            if encoding is None:

                encoding = req.encoding

            self._ = req._

        else:

            encoding = 'ascii'

            self._ = unicode

        self.encoding = encoding

    # no self.req managements

    def may_read(self, rdef, action='read'):

        """Return true if request user may read the given schema.

        Always return True when no request is provided.

        """

        if self.req is None:

            return True

        return rdef.may_have_permission(action, self.req)

    def format_eschema(self, eschema):

        text = eschema.type

        if self.req is None:

            return Text(text)

        return Link(self.req.build_url('cwetype/%s' % eschema), text)

    def format_rschema(self, rschema, label=None):

        if label is None:

            label = rschema.type

        if self.req is None:

            return Text(label)

        return Link(self.req.build_url('cwrtype/%s' % rschema), label)

    # end of no self.req managements

    def visit_schema(self, schema, display_relations=0, skiptypes=()):

        """get a layout for a whole schema"""

        title = Title(self._('Schema %s') % schema.name,

                      klass='titleUnderline')

        layout = Section(children=(title,))

        esection = Section(children=(Title(self._('Entities'),

                                           klass='titleUnderline'),))

        layout.append(esection)

        eschemas = [eschema for eschema in schema.entities()

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

        for eschema in sorted(eschemas, key=TYPE_GETTER):

            esection.append(self.visit_entityschema(eschema, skiptypes))

        if display_relations:

            title = Title(self._('Relations'), klass='titleUnderline')

            rsection = Section(children=(title,))

            layout.append(rsection)

            relations = [rschema for rschema in sorted(schema.relations(), key=TYPE_GETTER)

                         if not (rschema.final or rschema.type in skiptypes)]

            keys = [(rschema.type, rschema) for rschema in relations]

            for key, rschema in sorted(keys, cmp=(lambda x, y: cmp(x[1], y[1]))):

                relstr = self.visit_relationschema(rschema)

                rsection.append(relstr)

        return layout

    def _entity_attributes_data(self, eschema):

        _ = self._

        data = [_('attribute'), _('type'), _('default'), _('constraints')]

        attributes = sorted(eschema.attribute_definitions(), cmp=(lambda x, y: cmp(x[0].type, y[0].type)))

        for rschema, aschema in attributes:

            rdef = eschema.rdef(rschema)

            if not self.may_read(rdef):

                continue

            aname = rschema.type

            if aname == 'eid':

                continue

            data.append('%s (%s)' % (aname, _(aname)))

            data.append(_(aschema.type))

            defaultval = eschema.default(aname)

            if defaultval is not None:

                default = self.to_string(defaultval)

            elif rdef.cardinality[0] == '1':

                default = _('required field')

            else:

                default = ''

            data.append(default)

            constraints = rschema.rproperty(eschema.type, aschema.type,

                                            'constraints')

            data.append(', '.join(str(constr) for constr in constraints))

        return data

    def stereotype(self, name):

        return Span((' <<%s>>' % name,), klass='stereotype')

    def visit_entityschema(self, eschema, skiptypes=()):

        """get a layout for an entity schema"""

        etype = eschema.type

        layout = Section(children=' ', klass='clear')

        layout.append(Link(etype,' ' , id=etype)) # anchor

        title = self.format_eschema(eschema)

        boxchild = [Section(children=(title,), klass='title')]

        data = []

        data.append(Section(children=boxchild, klass='box'))

        data.append(Section(children='', klass='vl'))

        data.append(Section(children='', klass='hl'))

        t_vars = []

        rels = []

        first = True

        rel_defs = sorted(eschema.relation_definitions(),

                          cmp=(lambda x, y: cmp((x[0].type, x[0].cardinality),

                          (y[0].type, y[0].cardinality))))

        for rschema, targetschemas, role in rel_defs:

            if rschema.type in skiptypes:

                continue

            for oeschema in sorted(targetschemas, key=TYPE_GETTER):

                rdef = rschema.role_rdef(eschema, oeschema, role)

                if not self.may_read(rdef):

                    continue

                label = rschema.type

                if role == 'subject':

                    cards = rschema.rdef(eschema, oeschema).cardinality

                else:

                    cards = rschema.rdef(oeschema, eschema).cardinality

                    cards = cards[::-1]

                label = '%s %s %s' % (CARD_MAP[cards[1]], label,

                                      CARD_MAP[cards[0]])

                rlink = self.format_rschema(rschema, label)

                elink = self.format_eschema(oeschema)

                if first:

                    t_vars.append(Section(children=(elink,), klass='firstvar'))

                    rels.append(Section(children=(rlink,), klass='firstrel'))

                    first = False

                else:

                    t_vars.append(Section(children=(elink,), klass='var'))

                    rels.append(Section(children=(rlink,), klass='rel'))

        data.append(Section(children=rels, klass='rels'))

        data.append(Section(children=t_vars, klass='vars'))

        layout.append(Section(children=data, klass='entityAttributes'))

        return layout

    def visit_relationschema(self, rschema, title=True):

        """get a layout for a relation schema"""

        _ = self._

        if title:

            title = self.format_rschema(rschema)

            stereotypes = []

            if rschema.meta:

                stereotypes.append('meta')

            if rschema.symmetric:

                stereotypes.append('symmetric')

            if rschema.inlined:

                stereotypes.append('inlined')

            title = Section(children=(title,), klass='title')

            if stereotypes:

                title.append(self.stereotype(','.join(stereotypes)))

            layout = Section(children=(title,), klass='schema')

        else:

            layout = Section(klass='schema')

        data = [_('from'), _('to')]

        schema = rschema.schema

        rschema_objects = rschema.objects()

        if rschema_objects:

            # might be empty

            properties = [p for p in RelationDefinitionSchema.rproperty_defs(rschema_objects[0])

                          if not p in ('cardinality', 'composite', 'eid')]

        else:

            properties = []

        data += [_(prop) for prop in properties]

        cols = len(data)

        done = set()

        for subjtype, objtypes in sorted(rschema.associations()):

            for objtype in objtypes:

                if (subjtype, objtype) in done:

                    continue

                done.add((subjtype, objtype))

                if rschema.symmetric:

                    done.add((objtype, subjtype))

                data.append(self.format_eschema(schema[subjtype]))

                data.append(self.format_eschema(schema[objtype]))

                rdef = rschema.rdef(subjtype, objtype)

                for prop in properties:

                    val = getattr(rdef, prop)

                    if val is None:

                        val = ''

                    elif prop == 'constraints':

                        val = ', '.join([c.expression for c in val])

                    elif isinstance(val, dict):

                        for key, value in val.iteritems():

                            if isinstance(value, (list, tuple)):

                                val[key] = ', '.join(sorted( str(v) for v in value))

                        val = str(val)

                    elif isinstance(val, (list, tuple)):

                        val = sorted(val)

                        val = ', '.join(str(v) for v in val)

                    elif val and isinstance(val, basestring):

                        val = _(val)

                    else:

                        val = str(val)

                    data.append(Text(val))

        table = Table(cols=cols, rheaders=1, children=data, klass='listing')

        layout.append(Section(children=(table,), klass='relationDefinition'))

        layout.append(Section(children='', klass='clear'))

        return layout

    def to_string(self, value):

        """used to converte arbitrary values to encoded string"""

        if isinstance(value, unicode):

            return value.encode(self.encoding, 'replace')

        return str(value)