from types import SimpleNamespace

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

from external.marketplace import YandexMarketplaceApi
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))

    async def get_yandex_market_campaigns(self,
                                          request: GetYandexMarketCampaignsRequest) -> GetYandexMarketCampaignsResponse:
        try:
            marketplace = SimpleNamespace()
            marketplace.auth_data = {
                'Api-Key': request.api_key
            }
            ym_api = YandexMarketplaceApi(marketplace)
            campaigns = []
            async for campaign in ym_api.get_campaigns():
                campaigns.append({
                    'id': campaign.get('id'),
                    'name': campaign.get('domain'),
                })
            return GetYandexMarketCampaignsResponse(campaigns=campaigns)
        except Exception as e:
            print(e)
            return GetYandexMarketCampaignsResponse(campaigns=[])