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

:organization: Logilab

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

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

"""

__docformat__ = "restructuredtext en"

from mx.DateTime import DateTimeType, DateTimeDeltaType

from datetime import datetime

from rql import RQLHelper, nodes

from logilab.common.compat import any

from cubicweb import Binary

from cubicweb.rset import ResultSet

from cubicweb.goa import mx2datetime, datetime2mx

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)

        if isinstance(value, (DateTimeType, DateTimeDeltaType)):

            #yamstype = self.schema.rschema(self.rtype).objects()[0]

            value = mx2datetime(value, 'Datetime')

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

            value = c.eval(kwargs)

            if isinstance(value, (DateTimeType, DateTimeDeltaType)):

                #yamstype = self.schema.rschema(self.rtype).objects()[0]

                value = mx2datetime(value, 'Datetime')

            values.append(value)

        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 etype in ('Date', 'Datetime', 'Time'):

            value = datetime2mx(value, etype)

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