from dataclasses import dataclass

from anydi import singleton
from fansifter_common.auth.requests import AuthRequest
from fansifter_common.auth.services import AuthService
from fansifter_common.auth.types import Permission

from dmp.adapters.db import DefaultDB
from dmp.app_connections.services import AdsConnectionService
from dmp.meta.exceptions import MetaAdAccountNotFoundError
from dmp.meta.models import MetaAdAccount
from dmp.meta.repositories import MetaAdAccountRepository, MetaUserAdAccountRepository
from dmp.meta.services import (
    MetaAdReportingConnectionService,
    MetaUserConnectionService,
)


@dataclass
class DeleteMetaUserAdAccountRequest(AuthRequest):
    ad_account_id: str


@singleton
class DeleteMetaUserAdAccountHandler:
    permission = Permission("ad_account", "delete")

    def __init__(
        self,
        db: DefaultDB,
        auth_service: AuthService,
        ad_account_repository: MetaAdAccountRepository,
        user_ad_account_repository: MetaUserAdAccountRepository,
        user_connection_service: MetaUserConnectionService,
        ad_reporting_connection_service: MetaAdReportingConnectionService,
        ads_connection_service: AdsConnectionService,
    ) -> None:
        self.db = db
        self.auth_service = auth_service
        self.ad_account_repository = ad_account_repository
        self.user_ad_account_repository = user_ad_account_repository
        self.user_connection_service = user_connection_service
        self.ad_reporting_connection_service = ad_reporting_connection_service
        self.ads_connection_service = ads_connection_service

    def handle(self, request: DeleteMetaUserAdAccountRequest) -> None:
        with self.db.transaction():
            user_ad_account = (
                self.user_ad_account_repository.get_by_ad_account_id_and_identity_id(
                    ad_account_id=request.ad_account_id, identity_id=request.identity_id
                )
            )
            # Delete user ad account
            if user_ad_account:
                self.auth_service.check_account_owned_resource(
                    request.identity_id,
                    account=user_ad_account.account,
                    permission=self.permission,
                    resource_identity_id=user_ad_account.identity_id,
                    resource_id=request.ad_account_id,
                )
                self.user_ad_account_repository.delete(user_ad_account)
                ad_account: MetaAdAccount | None = user_ad_account.ad_account
            else:
                ad_account = self.ad_account_repository.get(request.ad_account_id)

            if not ad_account:
                raise MetaAdAccountNotFoundError

            # Remove ad account from user connection
            self.user_connection_service.delete_user_ad_account(
                identity_id=request.identity_id, ad_account=ad_account
            )

            # Remove ad account from ad reporting connection
            ad_reporting_connection = (
                self.ad_reporting_connection_service.delete_user_ad_account(
                    identity_id=request.identity_id, ad_account=ad_account
                )
            )

        if ad_reporting_connection:
            self.ads_connection_service.delete_fivetran_ad_account(
                ad_reporting_connection, ad_account.external_id
            )

        return None