# copyright 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 data sources"""

__docformat__ = "restructuredtext en"
_ = unicode

from itertools import repeat, chain

from cubicweb.selectors import is_instance, score_entity
from cubicweb.view import EntityView
from cubicweb.schema import META_RTYPES, VIRTUAL_RTYPES, display_name
from cubicweb.web import uicfg
from cubicweb.web.views import tabs

for rtype in ('cw_support', 'cw_may_cross', 'cw_dont_cross'):
    uicfg.primaryview_section.tag_subject_of(('CWSource', rtype, '*'),
                                             'hidden')

class CWSourcePrimaryView(tabs.TabbedPrimaryView):
    __select__ = is_instance('CWSource')
    tabs = [_('cwsource-main'), _('cwsource-mapping')]
    default_tab = 'cwsource-main'


class CWSourceMainTab(tabs.PrimaryTab):
    __regid__ = 'cwsource-main'
    __select__ = tabs.PrimaryTab.__select__ & is_instance('CWSource')


class CWSourceMappingTab(EntityView):
    __regid__ = 'cwsource-mapping'
    __select__ = (tabs.PrimaryTab.__select__ & is_instance('CWSource')
                  & score_entity(lambda x:x.type == 'pyrorql'))

    def entity_call(self, entity):
        _ = self._cw._
        self.w('<h3>%s</h3>' % _('Entity and relation types supported by this source'))
        self.wview('list', entity.related('cw_support'), 'noresult')
        self.w('<h3>%s</h3>' % _('Relations that should not be crossed'))
        self.w('<p>%s</p>' % _(
            'By default, when a relation is not supported by a source, it is '
            'supposed that a local relation may point to an entity from the '
            'external source. Relations listed here won\'t have this '
            '"crossing" behaviour.'))
        self.wview('list', entity.related('cw_dont_cross'), 'noresult')
        self.w('<h3>%s</h3>' % _('Relations that can be crossed'))
        self.w('<p>%s</p>' % _(
            'By default, when a relation is supported by a source, it is '
            'supposed that a local relation can\'t point to an entity from the '
            'external source. Relations listed here may have this '
            '"crossing" behaviour anyway.'))
        self.wview('list', entity.related('cw_may_cross'), 'noresult')
        if self._cw.user.is_in_group('managers'):
            errors, warnings, infos = check_mapping(entity)
            if (errors or warnings or infos):
                self.w('<h2>%s</h2>' % _('Detected problems'))
                errors = zip(repeat(_('error'), errors))
                warnings = zip(repeat(_('warning'), warnings))
                infos = zip(repeat(_('warning'), infos))
                self.wview('pyvaltable', pyvalue=chain(errors, warnings, infos))

def check_mapping(cwsource):
    req = cwsource._cw
    _ = req._
    errors = []
    error = errors.append
    warnings = []
    warning = warnings.append
    infos = []
    info = infos.append
    srelations = set()
    sentities = set()
    maycross = set()
    dontcross = set()
    # first check supported stuff / meta & virtual types and get mapping as sets
    for cwertype in cwsource.cw_support:
        if cwertype.name in META_RTYPES:
            error(_('meta relation %s can not be supported') % cwertype.name)
        else:
            if cwertype.__regid__ == 'CWEType':
                sentities.add(cwertype.name)
            else:
                srelations.add(cwertype.name)
    for attr, attrset in (('cw_may_cross', maycross),
                          ('cw_dont_cross', dontcross)):
        for cwrtype in getattr(cwsource, attr):
            if cwrtype.name in VIRTUAL_RTYPES:
                error(_('virtual relation %(rtype)s can not be referenced by '
                        'the "%(srel)s" relation') %
                      {'rtype': cwrtype.name,
                       'srel': display_name(req, attr, context='CWSource')})
            else:
                attrset.add(cwrtype.name)
    # check relation in dont_cross_relations aren't in support_relations
    for rtype in dontcross & maycross:
        info(_('relation %(rtype)s is supported but in %(dontcross)s') %
             {'rtype': rtype,
              'dontcross': display_name(req, 'cw_dont_cross',
                                        context='CWSource')})
    # check relation in cross_relations are in support_relations
    for rtype in maycross & srelations:
        info(_('relation %(rtype)s isn\'t supported but in %(maycross)s') %
             {'rtype': rtype,
              'dontcross': display_name(req, 'cw_may_cross',
                                        context='CWSource')})
    # now check for more handy things
    seen = set()
    for etype in sentities:
        eschema = req.vreg.schema[etype]
        for rschema, ttypes, role in eschema.relation_definitions():
            if rschema in META_RTYPES:
                continue
            ttypes = [ttype for ttype in ttypes if ttype in sentities]
            if not rschema in srelations:
                somethingprinted = False
                for ttype in ttypes:
                    rdef = rschema.role_rdef(etype, ttype, role)
                    seen.add(rdef)
                    if rdef.role_cardinality(role) in '1+':
                        error(_('relation %(type)s with %(etype)s as %(role)s '
                                'and target type %(target)s is mandatory but '
                                'not supported') %
                              {'rtype': rschema, 'etype': etype, 'role': role,
                               'target': ttype})
                        somethingprinted = True
                    elif ttype in sentities:
                        if rdef not in seen:
                            warning(_('%s could be supported') % rdef)
                        somethingprinted = True
                if rschema not in dontcross:
                    if role == 'subject' and rschema.inlined:
                        error(_('inlined relation %(rtype)s of %(etype)s '
                                'should be supported') %
                              {'rtype': rschema, 'etype': etype})
                    elif (not somethingprinted and rschema not in seen
                          and rschema not in maycross):
                        info(_('you may want to specify something for %s') %
                             rschema)
                        seen.add(rschema)
            else:
                if not ttypes:
                    warning(_('relation %(rtype)s with %(etype)s as %(role)s '
                              'is supported but no target type supported') %
                            {'rtype': rschema, 'role': role, 'etype': etype})
                if rschema in maycross and rschema.inlined:
                    error(_('you should un-inline relation %s which is '
                            'supported and may be crossed ') % rschema)
    for rschema in srelations:
        for subj, obj in rschema.rdefs:
            if subj in sentities and obj in sentities:
                break
        else:
            error(_('relation %s is supported but none if its definitions '
                    'matches supported entities') % rschema)
    return errors, warnings, infos