from pyexpat.errors import messages
from sqlalchemy import select, insert, delete, update
from sqlalchemy.orm import joinedload

from models import BaseMarketplace, Marketplace
from schemas.marketplace import *
from services.base import BaseService


class MarketplaceService(BaseService):
    async def get_all_base_marketplaces(self) -> GetAllBaseMarketplacesResponse:
        stmt = (select(BaseMarketplace).order_by(BaseMarketplace.key))
        base_marketplaces = (await self.session.scalars(stmt)).all()
        return GetAllBaseMarketplacesResponse(
            base_marketplaces=base_marketplaces
        )

    async def get_client_marketplaces(self, request: GetClientMarketplacesRequest) -> GetClientMarketplacesResponse:
        stmt = (
            select(
                Marketplace
            )
            .options(
                joinedload(Marketplace.base_marketplace),
                joinedload(Marketplace.client)
            )
            .where(
                Marketplace.client_id == request.client_id
            )
        )
        marketplaces = (await self.session.scalars(stmt)).all()
        return GetClientMarketplacesResponse(
            marketplaces=marketplaces
        )

    async def create_marketplace(self, request: CreateMarketplaceRequest) -> CreateMarketplaceResponse:
        try:
            marketplace = request.marketplace
            marketplace_dict = marketplace.dict()
            stmt = (
                insert(Marketplace)
                .values(
                    **marketplace_dict
                )
            )
            await self.session.execute(stmt)
            await self.session.commit()
            return CreateMarketplaceResponse(ok=True, message='Маркетплейс успешно создан')
        except Exception as e:
            await self.session.rollback()
            return CreateMarketplaceResponse(ok=False, message=str(e))

    async def delete_marketplace(self, request: DeleteMarketplaceRequest) -> DeleteMarketplaceResponse:
        try:
            stmt = (
                delete(Marketplace)
                .where(
                    Marketplace.id == request.marketplace_id
                )
            )
            await self.session.execute(stmt)
            await self.session.commit()
            return DeleteMarketplaceResponse(ok=True, message='Маркетплейс успешно удален')
        except Exception as e:
            await self.session.rollback()
            return DeleteMarketplaceResponse(ok=False, message=str(e))

    async def update_marketplace(self, request: UpdateMarketplaceRequest) -> UpdateMarketplaceResponse:
        try:
            marketplace = request.marketplace
            marketplace_dict = marketplace.dict()
            del marketplace_dict['id']
            del marketplace_dict['base_marketplace']
            del marketplace_dict['client']
            marketplace_dict['base_marketplace_key'] = marketplace.base_marketplace.key
            marketplace_dict['client_id'] = marketplace.client.id

            stmt = (
                update(
                    Marketplace
                )
                .values(
                    **marketplace_dict
                )
                .where(
                    Marketplace.id == marketplace.id
                )
            )
            await self.session.execute(stmt)
            await self.session.commit()
            return UpdateMarketplaceResponse(ok=True, message='Маркетплейс успешно обновлен')
        except Exception as e:
            await self.session.rollback()
            return UpdateMarketplaceResponse(ok=False, message=str(e))