from sqlalchemy import or_, and_, desc, asc
from sqlalchemy.sql.elements import BooleanClauseList, BinaryExpression, UnaryExpression

from .AbstractEngine import AbstractEngineClass
from ..utils.Models import FilterItem, FilterScope


class MsSqlEngine(AbstractEngineClass):

    def set_joins(self):
        pass

    filters = {}
    rows = []
    sort = None

    async def exe(self):
        _f = self.set_filters()
        if not self.custom_entities:
            query = self.query_class.query(self.model)
        else:
            query = self.query_class.query(*self.custom_entities)
        if self.joins:
            for j in self.joins:
                if isinstance(j, list):
                    query = query.join(*j)
                else:
                    query = query.join(j)

        if self.options:
            query = query.options(*self.options)
        tmp = query.filter(_f).order_by(self.set_sort())
        self.rows = tmp.limit(self.input.get_limit()).offset(self.input.skip()).all()
        return self.rows, tmp.count(), tmp

    def query_generator(self):
        if not self.input.has_filter():
            return None
        filters = self.input.filters()
        query = self.generate_scope_filter(filters, general=True)
        return query

    def set_sort(self):
        if self.input.o.field:
            self.sort = asc(getattr(self.model, self.input.o.field)) if self.input.o.direction == 'asc' else desc(
                getattr(self.model, self.input.o.field))
            return self.sort
        elif isinstance(self.default_sort_by, UnaryExpression):
            return self.default_sort_by
        else:
            return True

    def set_filters(self):
        filters = []
        query = self.query_generator()
        if isinstance(query, BooleanClauseList) or isinstance(query, BinaryExpression):
            filters.append(query)
        if self.input.has_text_search():
            items = []
            _search_cols = self.input.get_search_cols() if (
                    self.input.get_search_cols() and len(self.input.get_search_cols())) else self.search_cols
            if _search_cols:
                for col in _search_cols:
                    has_join = len(col.split('.')) > 1
                    if has_join:
                        pass
                    else:
                        items.append(
                            getattr(self.model, col).ilike("%{search}%".format(search=self.input.get_text_search())))
                filters.append(or_(*items))
        if self.input.extra_filter:
            for f in self.input.extra_filter:
                filters.append(f)
        if not filters:
            return True
        self.filters = and_(*filters)
        return self.filters

    @staticmethod
    def get_expression_filter(col=None, op: str = '', val: str = '') -> dict:
        _op = MsSqlEngine.get_operator(op)
        return getattr(col, op)(val)

    @staticmethod
    def get_operator(op: str):
        ops = {
            "eq": "__eq__",
            "n_eq": "__ne__",
            "gt": "__gt__",
            "gte": "__ge__",
            "lte": "__lte__",
            "lt": "__lt__",
            "like": "ilike",
            "n_like": "notlike",
            "in": "in_",
            "n_in": "not_in",
            "bet": "between",
            "n_bet": "not_between",
            "sw": "startswith",
            "ew": "endswith",
            'n_ew': 'not_endswith',
            'n_sw': 'not_startswith',
            'exi': 'exi',
            "n_exi": "n_exi",
        }
        return ops[op] if op in ops else '__eq__'

    @staticmethod
    def get_and_or(op):
        return or_ if op == 'or' else and_

    def count(self):
        pass

    def filter_item_generator(self, item: FilterItem):
        has_join = len(item.col.split('.')) > 1
        if has_join:

            pass
        else:
            return getattr(getattr(self.model, item.col), self.get_operator(item.op))(item.val)

    def generate_scope_filter(self, filters: list, general=False):
        if len(filters) == 1:
            _o = filters[0]
            if isinstance(_o, FilterItem):
                return self.filter_item_generator(filters[0])
            elif isinstance(_o, FilterScope):
                return self.generate_scope_filter(_o.items)
            else:
                return _o
        else:
            _a = filters.pop(0)
            _a = (self.filter_item_generator(_a) if isinstance(_a,
                                                               FilterItem) else _a) if not general else (
                self.generate_scope_filter(_a.items) if isinstance(_a, FilterScope) else _a)

            _b = filters.pop(0)

            _op = MsSqlEngine.get_and_or(_b.cr if not general else _b.op)
            _b = (self.filter_item_generator(_b) if isinstance(_b,
                                                               FilterItem) else _b) if not general else (
                self.generate_scope_filter(_b.items) if isinstance(_b, FilterScope) else _b)

            filters = [_op(_a, _b)] + filters
            return self.generate_scope_filter(filters, general)