from sqlalchemy import and_, or_
from database import models
from database.transaction import get_session
from graphql_schema.context import GraphQLContext
from graphql_schema.entities.helpers.combobox import handle_combobox_save
from graphql_schema.entities.resolvers.base import BaseMutationResolver, BaseQueryResolver
from graphql_schema.entities.types.mutation_input import EditAircraftInput, CreateAircraftInput
from graphql_schema.entities.types.types import Aircraft


class AircraftQueryResolver(BaseQueryResolver):
    def __init__(self):
        super().__init__(graphql_type=Aircraft, model=models.Aircraft)

    def get_query(
        self,
        user_id: int | None = None,
        object_id: int | None = None,
        order_by: list | None = None,
        organization_ids: set[int] | None = None,
        *args,
        **kwargs,
    ):
        filters = []
        if kwargs.get("call_sign"):
            filters.append(models.Aircraft.call_sign == kwargs['call_sign'])

        query = super().get_query(
            object_id=object_id,
            only_my=False,
            only_public=kwargs.get("only_public", False),
            order_by=order_by,
            filters=filters,
        )

        if kwargs.get("search"):
            search = kwargs["search"]
            query = query.filter(
                or_(
                    models.Aircraft.call_sign.contains(search),
                    models.Aircraft.manufacturer.contains(search),
                    models.Aircraft.model.contains(search),
                )

            )

        if organization_ids:
            query = (
                query.filter(
                    or_(
                        models.Aircraft.created_by_id == user_id,
                        and_(
                            models.Aircraft.organization_id.in_(organization_ids),
                            models.Aircraft.is_public.is_(True)
                        )
                    )
                )
            )
        elif user_id:
            filters.append(models.Aircraft.created_by_id == user_id)

        return query


class AircraftMutationResolver(BaseMutationResolver):
    def __init__(self):
        super().__init__(graphql_type=Aircraft, model=models.Aircraft)

    async def create(self, context: GraphQLContext, data: CreateAircraftInput) -> Aircraft:
        input_data = data.to_dict()

        async with get_session() as db:
            input_data['created_by_id'] = context.user_id
            if data.organization:
                input_data['organization_id'] = await handle_combobox_save(
                    db,
                    models.Organization,
                    input=data.organization,
                    user_id=context.user_id,
                )

            return await self._do_create(db, data=input_data)

    async def update(self, context: GraphQLContext, id: int, data: EditAircraftInput) -> Aircraft:
        update_data = data.to_dict()
        async with get_session() as db:
            if data.organization:
                update_data['organization_id'] = await handle_combobox_save(
                    db,
                    models.Organization,
                    input=data.organization,
                    user_id=context.user_id,
                )

            return await self._do_update(db, id, update_data)