from collections.abc import Iterable, Sequence

import sqlalchemy as sa
from pydantic import TypeAdapter

from dmp.adapters.db import DefaultDB, Repository
from dmp.config import Settings
from dmp.meta.dtos import MetaAudienceAdAccount, MetaUserAdAccountLabel
from dmp.meta.models import MetaAdAccount

MetaUserAdAccountLabelAssociationListMapper = TypeAdapter(list[MetaUserAdAccountLabel])
MetaAudienceAdAccountListMapper = TypeAdapter(list[MetaAudienceAdAccount])


class MetaAdAccountRepository(Repository[MetaAdAccount]):
    def __init__(self, db: DefaultDB, settings: Settings):
        super().__init__(db)
        self.settings = settings

    def find_by_external_ids(
        self, external_ids: Iterable[str]
    ) -> Sequence[MetaAdAccount]:
        query = sa.select(MetaAdAccount).where(
            MetaAdAccount.external_id.in_(external_ids)
        )
        result = self.db.session.execute(query)
        return result.scalars().all()

    def find_by_identity_id_for_assigment(
        self, identity_id: str
    ) -> list[MetaUserAdAccountLabel]:
        query = self.db.query_from_template(
            "meta-ad-account/find-by-identity-id-for-assigment.sql",
            context={
                "identity_id": identity_id,
            },
        )
        result = self.db.session.execute(query)
        return MetaUserAdAccountLabelAssociationListMapper.validate_python(
            result.mappings().all(),
            context={"assets_cdn_domain": self.settings.assets_cdn_domain},
        )

    def exists_by_id(self, id_: str) -> bool:
        query = sa.select(sa.select(1).exists().where(MetaAdAccount.id == id_))
        result = self.db.session.execute(query)
        return bool(result.scalar_one())

    def count_by_ids(self, ids: list[str]) -> int:
        query = sa.select(sa.func.count()).where(MetaAdAccount.id.in_(ids))
        result = self.db.session.execute(query)
        return result.scalar_one()