import logging
from typing import Union, Type, Tuple, Any

from sqlalchemy import update, delete, func
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.future import select
from sqlalchemy.sql.schema import UniqueConstraint

from server.dna.category.models import Category, CategoryEntity
from server.dna.utils import QueryWrapper

log = logging.getLogger(__name__)


class BaseQueryExecutor:
    @staticmethod
    async def get_count(model: Union[Type[Category], Type[CategoryEntity]], filters: dict) -> int:
        query = select(func.count("*")).select_from(model).filter_by(**filters)
        model_count = await QueryWrapper.select(query)
        return model_count

    @staticmethod
    async def get(
        model: Union[Type[Category], Type[CategoryEntity]],
        filters: dict,
        orders: Tuple = (None,),
        many: bool = False,
        limit: int = None,
        offset: int = None,
    ) -> Any:
        query = select(model).filter_by(**filters).order_by(*orders).limit(limit).offset(offset)
        instances = await QueryWrapper.select(query, many=many)
        return instances

    @staticmethod
    async def insert(
        model: Union[Type[Category], Type[CategoryEntity]],
        values: dict,
        constraint: Type[UniqueConstraint] = None,
        set_condition: dict = None,
    ) -> dict:
        query = insert(model).values(**values)
        if constraint and set_condition:
            query = query.on_conflict_do_update(constraint=constraint, set_=set_condition)
        result = await QueryWrapper.insert(query)
        return result

    @staticmethod
    async def update(model: Union[Type[Category], Type[CategoryEntity]], values: dict, filters: dict) -> dict:
        query = update(model).values(**values).filter_by(**filters)
        result = await QueryWrapper.update(query)
        return result

    @staticmethod
    async def delete(model: Union[Type[Category], Type[CategoryEntity]], filters: dict):
        query = delete(model).filter_by(**filters)
        await QueryWrapper.delete(query)