"""provide a minimal RQL support for google appengine dbmodel

:organization: Logilab

:copyright: 2008-2009 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

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

"""

__docformat__ = "restructuredtext en"

from datetime import datetime

from rql import RQLHelper, nodes

from cubicweb import Binary

from cubicweb.rset import ResultSet

from cubicweb.server import SQL_CONNECT_HOOKS

from google.appengine.api.datastore import Key, Get, Query, Entity

from google.appengine.api.datastore_types import Text, Blob

from google.appengine.api.datastore_errors import EntityNotFoundError, BadKeyError

def etype_from_key(key):

    return Key(key).kind()

def poss_var_types(myvar, ovar, kind, solutions):

    return frozenset(etypes[myvar] for etypes in solutions

                     if etypes[ovar] == kind)

def expand_result(results, result, myvar, values, dsget=None):

    values = map(dsget, values)

    if values:

        result[myvar] = values.pop(0)

        for value in values:

            newresult = result.copy()

            newresult[myvar] = value

            results.append(newresult)

    else:

        results.remove(result)

def _resolve(restrictions, solutions, fixed):

    varname = restrictions[0].searched_var

    objs = []

    for etype in frozenset(etypes[varname] for etypes in solutions):

        gqlargs = {}

        query = Query(etype)

        for restriction in restrictions:

            restriction.fill_query(fixed, query)

        pobjs = query.Run()

        if varname in fixed:

            value = fixed[varname]

            objs += (x for x in pobjs if x == value)

        else:

            objs += pobjs

    if varname in fixed and not objs:

        raise EidMismatch(varname, value)

    return objs

def _resolve_not(restrictions, solutions, fixed):

    restr = restrictions[0]

    constrvarname = restr.constraint_var

    if len(restrictions) > 1 or not constrvarname in fixed:

        raise NotImplementedError()

    varname = restr.searched_var

    objs = []

    for etype in frozenset(etypes[varname] for etypes in solutions):

        gqlargs = {}

        for operator in ('<', '>'):

            query = Query(etype)

            restr.fill_query(fixed, query, operator)

            objs += query.Run()

    return objs

def _print_results(rlist):

    return '[%s]' % ', '.join(_print_result(r) for r in rlist)

def _print_result(rdict):

    string = []

    for k, v in rdict.iteritems():

        if isinstance(v, Entity):

            string.append('%s: %s' % (k, v.key()))#_print_result(v)))

        elif isinstance(v, list):

            string.append('%s: [%s]' % (k, ', '.join(str(i) for i in v)))

        else:

            string.append('%s: %s' % (k, v))

    return '{%s}' % ', '.join(string)

class EidMismatch(Exception):

    def __init__(self, varname, value):

        self.varname = varname

        self.value = value

class Restriction(object):

    supported_operators = ('=',)

    def __init__(self, rel):

        operator = rel.children[1].operator

        if not operator in self.supported_operators:

            raise NotImplementedError('unsupported operator')

        self.rel = rel

        self.operator = operator

        self.rtype = rel.r_type

        self.var = rel.children[0]

    def __repr__(self):

        return '<%s for %s>' % (self.__class__.__name__, self.rel)

    @property

    def rhs(self):

        return self.rel.children[1].children[0]

class MultipleRestriction(object):

    def __init__(self, restrictions):

        self.restrictions = restrictions

    def resolve(self, solutions, fixed):

        return _resolve(self.restrictions, solutions, fixed)

class VariableSelection(Restriction):

    def __init__(self, rel, dsget, prefix='s'):

        Restriction.__init__(self, rel)

        self._dsget = dsget

        self._not = self.rel.neged(strict=True)

        self._prefix = prefix + '_'

    def __repr__(self):

        return '<%s%s for %s>' % (self._prefix[0], self.__class__.__name__, self.rel)

    @property

    def searched_var(self):

        if self._prefix == 's_':

            return self.var.name

        return self.rhs.name

    @property

    def constraint_var(self):

        if self._prefix == 's_':

            return self.rhs.name

        return self.var.name

    def _possible_values(self, myvar, ovar, entity, solutions, dsprefix):

        if self.rtype == 'identity':

            return (entity.key(),)

        value = entity.get(dsprefix + self.rtype)

        if value is None:

            return []

        if not isinstance(value, list):

            value = [value]

        vartypes = poss_var_types(myvar, ovar, entity.kind(), solutions)

        return (v for v in value if v.kind() in vartypes)

    def complete_and_filter(self, solutions, results):

        myvar = self.rhs.name

        ovar = self.var.name

        rtype = self.rtype

        if self.schema.rschema(rtype).is_final():

            # should be detected by rql.stcheck: "Any C WHERE NOT X attr C" doesn't make sense

            #if self._not:

            #    raise NotImplementedError()

            for result in results:

                result[myvar] = result[ovar].get('s_'+rtype)

        elif self.var.name in results[0]:

            if self.rhs.name in results[0]:

                self.filter(solutions, results)

            else:

                if self._not:

                    raise NotImplementedError()

                for result in results[:]:

                    values = self._possible_values(myvar, ovar, result[ovar],

                                                   solutions, 's_')

                    expand_result(results, result, myvar, values, self._dsget)

        else:

            assert self.rhs.name in results[0]

            self.object_complete_and_filter(solutions, results)

    def filter(self, solutions, results):

        myvar = self.rhs.name

        ovar = self.var.name

        newsols = {}

        for result in results[:]:

            entity = result[ovar]

            key = entity.key()

            if not key in newsols:

                values = self._possible_values(myvar, ovar, entity, solutions, 's_')

                newsols[key] = frozenset(v for v in values)

            if self._not:

                if result[myvar].key() in newsols[key]:

                    results.remove(result)

            elif not result[myvar].key() in newsols[key]:

                results.remove(result)

    def object_complete_and_filter(self, solutions, results):

        if self._not:

            raise NotImplementedError()

        myvar = self.var.name

        ovar = self.rhs.name

        for result in results[:]:

            values = self._possible_values(myvar, ovar, result[ovar],

                                           solutions, 'o_')

            expand_result(results, result, myvar, values, self._dsget)

class EidRestriction(Restriction):

    def __init__(self, rel, dsget):

        Restriction.__init__(self, rel)

        self._dsget = dsget

    def resolve(self, kwargs):

        value = self.rel.children[1].children[0].eval(kwargs)

        return self._dsget(value)

class RelationRestriction(VariableSelection):

    def _get_value(self, fixed):

        return fixed[self.constraint_var].key()

    def fill_query(self, fixed, query, operator=None):

        restr = '%s%s %s' % (self._prefix, self.rtype, operator or self.operator)

        query[restr] = self._get_value(fixed)

    def resolve(self, solutions, fixed):

        if self.rtype == 'identity':

            if self._not:

                raise NotImplementedError()

            return [fixed[self.constraint_var]]

        if self._not:

            return _resolve_not([self], solutions, fixed)

        return _resolve([self], solutions, fixed)

class NotRelationRestriction(RelationRestriction):

    def _get_value(self, fixed):

        return None

    def resolve(self, solutions, fixed):

        if self.rtype == 'identity':

            raise NotImplementedError()

        return _resolve([self], solutions, fixed)

class AttributeRestriction(RelationRestriction):

    supported_operators = ('=', '>', '>=', '<', '<=', 'ILIKE')

    def __init__(self, rel, kwargs):

        RelationRestriction.__init__(self, rel, None)

        value = self.rhs.eval(kwargs)

        self.value = value

        if self.operator == 'ILIKE':

            if value.startswith('%'):

                raise NotImplementedError('LIKE is only supported for prefix search')

            if not value.endswith('%'):

                raise NotImplementedError('LIKE is only supported for prefix search')

            self.operator = '>'

            self.value = value[:-1]

    def complete_and_filter(self, solutions, results):

        # check lhs var first in case this is a restriction

        assert self._not

        myvar, rtype, value = self.var.name, self.rtype, self.value

        for result in results[:]:

            if result[myvar].get('s_'+rtype) == value:

                results.remove(result)

    def _get_value(self, fixed):

        return self.value

class DateAttributeRestriction(AttributeRestriction):

    """just a thin layer on top af `AttributeRestriction` that

    tries to convert date strings such as in :

    Any X WHERE X creation_date >= '2008-03-04'

    """

    def __init__(self, rel, kwargs):

        super(DateAttributeRestriction, self).__init__(rel, kwargs)

        if isinstance(self.value, basestring):

#             try:

            self.value = datetime.strptime(self.value, '%Y-%m-%d')

#             except Exception, exc:

#                 from logging import error

#                 error('unable to parse date %s with format %%Y-%%m-%%d (exc=%s)', value, exc)

class AttributeInRestriction(AttributeRestriction):

    def __init__(self, rel, kwargs):

        RelationRestriction.__init__(self, rel, None)

        values = []

        for c in self.rel.children[1].iget_nodes(nodes.Constant):

            values.append(c.eval(kwargs))

        self.value = values

    @property

    def operator(self):

        return 'in'

class TypeRestriction(AttributeRestriction):

    def __init__(self, var):

        self.var = var

    def __repr__(self):

        return '<%s for %s>' % (self.__class__.__name__, self.var)

    def resolve(self, solutions, fixed):

        objs = []

        for etype in frozenset(etypes[self.var.name] for etypes in solutions):

            objs += Query(etype).Run()

        return objs

def append_result(res, descr, i, j, value, etype):

    if value is not None:

        if isinstance(value, Text):

            value = unicode(value)

        elif isinstance(value, Blob):

            value = Binary(str(value))

    if j == 0:

        res.append([value])

        descr.append([etype])

    else:

        res[i].append(value)

        descr[i].append(etype)

class ValueResolver(object):

    def __init__(self, functions, args, term):

        self.functions = functions

        self.args = args

        self.term = term

        self._solution = self.term.stmt.solutions[0]

    def compute(self, result):

        """return (entity type, value) to which self.term is evaluated according

        to the given result dictionnary and to query arguments (self.args)

        """

        return self.term.accept(self, result)

    def visit_function(self, node, result):

        args = tuple(n.accept(self, result)[1] for n in node.children)

        value = self.functions[node.name](*args)

        return node.get_type(self._solution, self.args), value

    def visit_variableref(self, node, result):

        value = result[node.name]

        try:

            etype = value.kind()

            value = str(value.key())

        except AttributeError:

            etype = self._solution[node.name]

        return etype, value

    def visit_constant(self, node, result):

        return node.get_type(kwargs=self.args), node.eval(self.args)

class RQLInterpreter(object):

    """algorithm:

    1. visit the restriction clauses and collect restriction for each subject

       of a relation. Different restriction types are:

       * EidRestriction

       * AttributeRestriction

       * RelationRestriction

       * VariableSelection (not really a restriction)

       -> dictionary {<variable>: [restriction...], ...}

    2. resolve eid restrictions

    3. for each select in union:

           for each solution in select'solutions:

               1. resolve variables which have attribute restriction

               2. resolve relation restriction

               3. resolve selection and add to global results

    """

    def __init__(self, schema):

        self.schema = schema

        Restriction.schema = schema # yalta!

        self.rqlhelper = RQLHelper(schema, {'eid': etype_from_key})