from temporalio import activity, workflow

with workflow.unsafe.imports_passed_through():
    from sientia_do.temporal.activities.postgres import Postgres
    from sientia_do.notifications.handlers import CoreNotificationHandler as NotificationHandler
    from sientia_do.observability.logger import Logger
    from laborious.activities.mlflow import MLFlow
    from laborious.activities.gates import Gates
    from laborious.activities.opc import OPC
    from typing import Any


class Activities(Postgres, MLFlow, Gates, OPC):

    def __init__(self,
                 postgres_config: dict[str, Any],
                 mlflow_config: dict[str, Any],
                 opc_config: dict[str, Any],
                 logger: Logger, notification_handler: NotificationHandler):

        # Initialize parent classes
        Postgres.__init__(self, host=postgres_config['host'],
                          port=postgres_config['port'],
                          user=postgres_config['user'],
                          password=postgres_config['password'],
                          dbname=postgres_config['dbname'],
                          min_connections=postgres_config['min_connections'],
                          max_connections=postgres_config['max_connections'],
                          logger=logger,
                          notification_handler=notification_handler)

        MLFlow.__init__(self, mlflow_host=mlflow_config['host'],
                        mlflow_port=mlflow_config['port'],
                        mlflow_username=mlflow_config['username'],
                        mlflow_password=mlflow_config['password'],
                        logger=logger,
                        notification_handler=notification_handler)

        Gates.__init__(self, logger=logger,
                       notification_handler=notification_handler)

        OPC.__init__(self,
                     opc_servers=opc_config,
                     logger=logger,
                     notification_handler=notification_handler)

    async def shutdown(self):
        Postgres.close(self)
        await OPC.shutdown(self)