import pathlib

import boto3
from anydi import Container, Module, Provider, provider
from cachelib import BaseCache, RedisCache, SimpleCache
from fansifter_common.adapters.aws.secretsmanager import SecretsManager
from fansifter_common.legal_info.services import LegalInfoService
from fansifter_common.m2m_token import M2MTokenManager
from fansifter_common.utils.functional import lazy_proxy
from jinja2 import Environment, FileSystemLoader
from owsclient import OwsClient

from app.config import Settings, settings
from app.connectors.aws.ses.email_client import EmailClient
from app.connectors.ows_preference_center import (
    OwsPreferenceCenterClient,
)
from app.handlers import SongwhipFanConsentHandler


class AppModule(Module):
    @provider(scope="singleton")
    def aws_session(self, settings: Settings) -> boto3.Session:
        return boto3.Session(region_name=settings.aws_region_name)

    @provider(scope="singleton")
    def secrets_manager(
        self, session: boto3.Session, settings: Settings
    ) -> SecretsManager:
        return SecretsManager(session=session, region_name=settings.aws_region_name)

    @provider(scope="singleton")
    def m2m_token_manager(
        self, settings: Settings, secrets_manager: SecretsManager
    ) -> M2MTokenManager:
        return M2MTokenManager(
            secrets_manager=secrets_manager,
            secret_name_key=settings.m2m_token_secret_name,
            secret_expire_name_key=settings.m2m_token_expiration_secret_name,
        )

    @provider(scope="singleton")
    def ows_client(
        self, settings: Settings, m2m_token_manager: M2MTokenManager
    ) -> OwsClient:
        return OwsClient(
            environment=settings.environment,
            service_name=settings.service_name,
            m2m_token_manager=m2m_token_manager,
        )

    @provider(scope="singleton")
    def preference_center_client(
        self, ows_client: OwsClient
    ) -> OwsPreferenceCenterClient:
        return OwsPreferenceCenterClient(ows_client=ows_client)

    @provider(scope="singleton")
    def email_client(self, settings: Settings) -> EmailClient:
        return EmailClient(
            email_sender=settings.email_sender,
            email_sender_name=settings.email_sender_name,
            email_source_arn=settings.email_source_arn,
        )

    @provider(scope="singleton")
    def cache(self, settings: Settings) -> BaseCache:
        if settings.cache_backend == "redis":
            return RedisCache(
                host=settings.redis_host,
                port=settings.redis_port,
                db=settings.cache_redis_db,
                ssl=settings.redis_ssl,
                key_prefix=settings.cache_key_prefix,
                default_timeout=settings.cache_timeout,
            )
        return SimpleCache()

    @provider(scope="singleton")
    def legal_info_service(self) -> LegalInfoService:
        return LegalInfoService()

    @provider(scope="singleton")
    def jinja_env(self) -> Environment:
        return Environment(
            loader=FileSystemLoader(pathlib.Path(__file__).parent / "templates")
        )

    @provider(scope="singleton")
    def handler(
        self,
        settings: Settings,
        email_client: EmailClient,
        ows_preference_center_client: OwsPreferenceCenterClient,
        legal_info_service: LegalInfoService,
        cache: BaseCache,
        jinja_env: Environment,
    ) -> SongwhipFanConsentHandler:
        return SongwhipFanConsentHandler(
            email_client=email_client,
            jinja=jinja_env,
            email_content_wording=settings.email_content_wording,
            email_title_templates=settings.email_title_templates,
            preference_center_url=settings.preference_center_url,
            ows_preference_center_client=ows_preference_center_client,
            legal_info_service=legal_info_service,
            cache=cache,
        )


def make_container() -> Container:
    return Container(
        providers=[
            Provider(Settings, factory=lambda: settings, scope="singleton"),
        ],
        modules=[AppModule],
    )


container = lazy_proxy(make_container)