"""SPARQL -> RQL translator

:organization: Logilab

:copyright: 2009 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

"""

from logilab.common import make_domains

from rql import TypeResolverException

from fyzz.yappsparser import parse

from fyzz import ast

from cubicweb.xy import xy

class UnsupportedQuery(Exception): pass

class QueryInfo(object):

    def __init__(self, sparqlst):

        self.sparqlst = sparqlst

        if sparqlst.selected == ['*']:

            self.selection = [var.upper() for var in sparqlst.variables]

        else:

            self.selection = [var.name.upper() for var in sparqlst.selected]

        self.possible_types = {}

        self.union_params = []

        self.restrictions = []

    def finalize(self):

        for varname, ptypes in self.possible_types.iteritems():

            if len(ptypes) == 1:

                self.restrictions.append('%s is %s' % (varname, iter(ptypes).next()))

        unions = []

        for releq, subjvar, objvar in self.union_params:

            thisunions = []

            for st, rt, ot in releq:

                thisunions.append(['%s %s %s' % (subjvar, rt, objvar)])

                if st != '*':

                    thisunions[-1].append('%s is %s' % (subjvar, st))

                if ot != '*':

                    thisunions[-1].append('%s is %s' % (objvar, ot))

            if not unions:

                unions = thisunions

            else:

                unions = zip(*make_domains([unions, thisunions]))

        baserql = 'Any %s WHERE %s' % (', '.join(self.selection),

                                       ', '.join(self.restrictions))

        if not unions:

            return baserql

        rqls = ['(%s, %s)' % (baserql, ', '.join(unionrestrs))

                for unionrestrs in unions]

        return ' UNION '.join(rqls)

    def set_possible_types(self, var, varpossibletypes):

        varpossibletypes = set(varpossibletypes)

        try:

            self.possible_types[var] &= varpossibletypes

            if not self.possible_types[var]:

                raise TypeResolverException()

        except KeyError:

            self.possible_types[var] = varpossibletypes

class Sparql2rqlTranslator(object):

    def __init__(self, yschema):

        self.yschema = yschema

    def translate(self, sparql):

        sparqlst = parse(sparql)

        if sparqlst.type != 'select':

            raise UnsupportedQuery()

        qi = QueryInfo(sparqlst)

        for subj, predicate, obj in sparqlst.where:

            if not isinstance(subj, ast.SparqlVar):

                raise UnsupportedQuery()

            subjvar = subj.name.upper()

            if predicate == ('', 'a'): # special 'is' relation

                if not isinstance(obj, tuple):

                    raise UnsupportedQuery()

                qi.set_possible_types(

                    subjvar, xy.yeq(':'.join(obj), isentity=True))

            else:

                if not isinstance(predicate, tuple):

                    raise UnsupportedQuery()

                releq = xy.yeq(':'.join(predicate))

                svptypes = set(s for s, r, o in releq)

                if not '*' in svptypes:

                    qi.set_possible_types(subjvar, svptypes)

                if subjvar in qi.possible_types:

                    releq = [(s, r, o) for s, r, o in releq

                             if s == '*' or s in qi.possible_types[subjvar]]

                if isinstance(obj, ast.SparqlVar):

                    objvar = obj.name.upper()

                    ovptypes = set(o for s, r, o in releq)

                    if not '*' in ovptypes:

                        qi.set_possible_types(objvar, ovptypes)

                    if objvar in qi.possible_types:

                        releq = [(s, r, o) for s, r, o in releq

                                 if o == '*' or o in qi.possible_types[objvar]]

                else:

                    raise UnsupportedQuery()

                rel = releq[0]

                for s, r, o in releq[1:]:

                    if r != rel[1]:

                        qi.union_params.append((releq, subjvar, objvar))

                        break

                else:

                    qi.restrictions.append('%s %s %s' % (subj.name.upper(),

                                                         rel[1],

                                                         obj.name.upper()))

        return qi