from sqlalchemy import select, update
from sqlalchemy.orm import joinedload

from models import Service, ServiceCategory
from services.base import BaseService
from schemas.service import ServiceGetAllResponse, ServiceSchema, ServiceGetAllCategoriesResponse, \
    ServiceCategorySchema, ServiceCreateRequest, ServiceCreateResponse, ServiceCreateCategoryRequest, \
    ServiceCreateCategoryResponse, ServiceUpdateRequest, ServiceUpdateResponse, ServiceDeleteResponse, \
    ServiceDeleteRequest


class ServiceService(BaseService):
    async def get_all(self) -> ServiceGetAllResponse:
        query = await (self.session
                       .scalars(select(Service)
                                .options(joinedload(Service.category))
                                .order_by(Service.category_id, Service.id)))
        services = []
        for service in query.all():
            services.append(ServiceSchema.model_validate(service))
        return ServiceGetAllResponse(services=services)

    async def create(self, request: ServiceCreateRequest) -> ServiceCreateResponse:
        try:
            raw_service = request.service
            service_dict = raw_service.model_dump()
            service_dict['category_id'] = raw_service.category.id
            del service_dict['id']
            del service_dict['category']
            service = Service(**service_dict)
            self.session.add(service)
            await self.session.commit()
            return ServiceCreateResponse(ok=True, message="Услуга успешно создана")
        except Exception as e:
            return ServiceCreateResponse(ok=False, message=f"Неудалось создать услугу, ошибка: {e}")

    async def update(self, request: ServiceUpdateRequest) -> ServiceUpdateResponse:
        try:
            raw_service = request.data
            service = await (self.session
                             .scalars(select(Service)
                                      .filter(Service.id == raw_service.id)))
            if not service:
                return ServiceUpdateResponse(ok=False, message="Услуга не найдена")

            service_dict = raw_service.dict()
            service_dict['category_id'] = raw_service.category.id
            del service_dict['category']
            await self.session.execute(
                update(Service)
                .where(Service.id == raw_service.id)
                .values(**service_dict)
            )

            await self.session.commit()
            return ServiceUpdateResponse(ok=True, message="Услуга успешно обновлена")
        except Exception as e:
            return ServiceUpdateResponse(ok=False, message=f"Неудалось обновить услугу, ошибка: {e}")

    async def delete(self, request: ServiceDeleteRequest) -> ServiceDeleteResponse:
        try:
            service = await (self.session
                             .scalar(select(Service)
                                     .filter(Service.id == request.service_id)))
            if not service:
                return ServiceDeleteResponse(ok=False, message="Услуга не найдена")
            await self.session.delete(service)
            await self.session.commit()
            return ServiceDeleteResponse(ok=True, message="Услуга успешно удалена")
        except Exception as e:
            return ServiceDeleteResponse(ok=False, message=f"Неудалось удалить услугу, ошибка: {e}")

    async def create_category(self, request: ServiceCreateCategoryRequest) -> ServiceCreateCategoryResponse:
        try:
            raw_category = request.category
            category_dict = raw_category.model_dump()
            del category_dict['id']
            category = ServiceCategory(**category_dict)
            self.session.add(category)
            await self.session.commit()
            return ServiceCreateCategoryResponse(ok=True, message="Категория успешно создана")

        except Exception as e:
            return ServiceCreateCategoryResponse(ok=False, message=f"Неудалось создать категорию, ошибка: {e}")

    async def get_all_categories(self) -> ServiceGetAllCategoriesResponse:
        query = await (self.session
                       .scalars(select(ServiceCategory)
                                .order_by(ServiceCategory.id)))
        categories = []
        for category in query.all():
            categories.append(ServiceCategorySchema.model_validate(category))
        return ServiceGetAllCategoriesResponse(categories=categories)