from dataclasses import dataclass

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

from dmp.adapters.db import DefaultDB, transactional
from dmp.meta.dtos import MetaUser, MetaUserConnectionResult
from dmp.meta.enums import MetaUserConnectionStatus
from dmp.meta.exceptions import MetaUserConnectionError
from dmp.meta.services import MetaUserConnectionService


@dataclass(frozen=True)
class GetMetaUserConnectionRequest:
    identity_id: str


@singleton
class GetMetaUserConnectionHandler:
    permission = Permission("ad_connection", "view")

    def __init__(
        self,
        db: DefaultDB,
        auth_service: AuthService,
        user_connection_service: MetaUserConnectionService,
    ) -> None:
        self.db = db
        self.auth_service = auth_service
        self.user_connection_service = user_connection_service

    @transactional
    def handle(self, request: GetMetaUserConnectionRequest) -> MetaUserConnectionResult:
        user_connection = self.user_connection_service.get_user_connection(
            request.identity_id
        )
        if not user_connection:
            return self.user_connection_service.make_not_connected_result()

        self.auth_service.check_owned_resource(
            user_connection.identity_id,
            permission=self.permission,
            resource_id=user_connection.id,
        )

        if not user_connection.is_valid:
            return self.user_connection_service.make_error_connection_result(
                user=MetaUser(
                    id=user_connection.user_id,
                    name=user_connection.user_name,
                    granted_scopes=[],
                ),
                status=MetaUserConnectionStatus.INVALID,
            )

        access_token = self.user_connection_service.decrypt_token(user_connection.token)

        try:
            user = self.user_connection_service.get_user(
                user_connection,
                access_token=access_token,
            )
        except MetaUserConnectionError as exc:
            self.user_connection_service.invalidate_user_connection(user_connection)
            return MetaUserConnectionResult(
                user=exc.user,
                status=exc.status,
                required_scopes=exc.required_scopes,
                ad_accounts=[],
            )

        self.user_connection_service.refresh_user_connection_ad_accounts_tos(
            user_connection, user_access_token=access_token
        )

        return self.user_connection_service.make_connected_result(
            user_connection, user=user
        )