from .._gae import ndb
from ..adapters.google import GoogleDatastore
from ..helpers.gae import NDBDecimalProperty
from .base import NoSQLDialect
from . import dialects, sqltype_for


@dialects.register_for(GoogleDatastore)
class GoogleDatastoreDialect(NoSQLDialect):
    FILTER_OPTIONS = {
        "=": lambda a, b: a == b,
        ">": lambda a, b: a > b,
        "<": lambda a, b: a < b,
        "<=": lambda a, b: a <= b,
        ">=": lambda a, b: a >= b,
        "!=": lambda a, b: a != b,
        "in": lambda a, b: a.IN(b),
    }

    @sqltype_for("string")
    def type_string(self):
        return lambda **kwargs: ndb.StringProperty(**kwargs)

    @sqltype_for("boolean")
    def type_boolean(self):
        return ndb.BooleanProperty

    @sqltype_for("text")
    def type_text(self):
        return ndb.TextProperty

    @sqltype_for("json")
    def type_json(self):
        return self.types["text"]

    @sqltype_for("password")
    def type_password(self):
        return ndb.StringProperty

    @sqltype_for("blob")
    def type_blob(self):
        return ndb.BlobProperty

    @sqltype_for("upload")
    def type_upload(self):
        return self.types["password"]

    @sqltype_for("integer")
    def type_integer(self):
        return ndb.IntegerProperty

    @sqltype_for("bigint")
    def type_bigint(self):
        return self.types["integer"]

    @sqltype_for("float")
    def type_float(self):
        return ndb.FloatProperty

    @sqltype_for("double")
    def type_double(self):
        return self.types["float"]

    @sqltype_for("decimal")
    def type_decimal(self):
        return NDBDecimalProperty

    @sqltype_for("date")
    def type_date(self):
        return ndb.DateProperty

    @sqltype_for("time")
    def type_time(self):
        return ndb.TimeProperty

    @sqltype_for("datetime")
    def type_datetime(self):
        return ndb.DateTimeProperty

    @sqltype_for("id")
    def type_id(self):
        return None

    @sqltype_for("reference")
    def type_reference(self):
        return ndb.IntegerProperty

    @sqltype_for("list:integer")
    def type_list_integer(self):
        return lambda **kwargs: ndb.IntegerProperty(
            repeated=True, default=None, **kwargs
        )

    @sqltype_for("list:string")
    def type_list_string(self):
        return lambda **kwargs: ndb.StringProperty(
            repeated=True, default=None, **kwargs
        )

    @sqltype_for("list:reference")
    def type_list_reference(self):
        return lambda **kwargs: ndb.IntegerProperty(
            repeated=True, default=None, **kwargs
        )

    def _and(self, first, second, query_env={}):
        first = self.expand(first, query_env=query_env)
        second = self.expand(second, query_env=query_env)
        # none means lack of query (true)
        if first == None:
            return second
        return ndb.AND(first, second)

    def _or(self, first, second, query_env={}):
        first = self.expand(first, query_env=query_env)
        second = self.expand(second, query_env=query_env)
        # none means lack of query (true)
        if first == None or second == None:
            return None
        return ndb.OR(first, second)

    def __gaef(self, first, op, second):
        name = first.name if first.name != "id" else "key"
        if name == "key" and op in (">", "!=") and second in (0, "0", None):
            return None
        field = getattr(first.table._tableobj, name)
        value = self.adapter.represent(second, first.type, first._tablename)
        return self.FILTER_OPTIONS[op](field, value)

    def eq(self, first, second=None, query_env={}):
        return self.__gaef(first, "=", second)

    def ne(self, first, second=None, query_env={}):
        return self.__gaef(first, "!=", second)

    def lt(self, first, second=None, query_env={}):
        return self.__gaef(first, "<", second)

    def lte(self, first, second=None, query_env={}):
        return self.__gaef(first, "<=", second)

    def gt(self, first, second=None, query_env={}):
        return self.__gaef(first, ">", second)

    def gte(self, first, second=None, query_env={}):
        return self.__gaef(first, ">=", second)

    def invert(self, first, query_env={}):
        return "-%s" % first.name

    def comma(self, first, second, query_env={}):
        return "%s,%s" % (first, second)

    def belongs(self, first, second, query_env={}):
        if not isinstance(second, (list, tuple, set)):
            raise SyntaxError("Not supported")
        if not isinstance(second, list):
            second = list(second)
        if len(second) == 0:
            # return a filter which will return a null set
            f = self.eq(first, 0)
            f.filter_all = True
            return f
        return self.__gaef(first, "in", second)

    def contains(self, first, second, case_sensitive=True, query_env={}):
        # silently ignoring: GAE can only do case sensitive matches!
        if not first.type.startswith("list:"):
            raise SyntaxError("Not supported")
        return self.__gaef(first, "=", second)

    def _not(self, val, query_env={}):
        op, f, s = val.op, val.first, val.second
        if op in [self._or, self._and]:
            not_op = self._and if op == self._or else self._or
            rv = not_op(self._not(f), self._not(s))
        elif op == self.eq:
            rv = self.__gaef(f, "!=", s)
        elif op == self.ne:
            rv = self.__gaef(f, "=", s)
        elif op == self.lt:
            rv = self.__gaef(f, ">=", s)
        elif op == self.lte:
            rv = self.__gaef(f, ">", s)
        elif op == self.gt:
            rv = self.__gaef(f, "<=", s)
        elif op == self.gte:
            rv = self.__gaef(f, "<", s)
        else:
            # TODO the IN operator must be split into a sequence of
            # (field!=value) AND (field!=value) AND ...
            raise NotImplementedError
        return rv