import uuid
from collections.abc import Callable

from fansifter_common.utils.functional import lazy_proxy

from app.adapters import aws_lambda, aws_sqs
from app.config import settings
from app.dsp.enums import DSPClientName
from app.fandata.types import FanBatch


def _dispatch_fan_fanout() -> Callable[[uuid.UUID], None]:
    if settings.fan_fanout_dispatch_backend == "celery":

        def _send_celery(run_id: uuid.UUID) -> None:
            from app.pipeline import tasks

            tasks.fan_fanout.apply_async(
                args=(str(run_id),),
                queue=settings.celery_fan_fanout_queue,
            )

        return _send_celery

    if settings.fan_fanout_dispatch_backend == "lambda":

        def _send_lambda(run_id: uuid.UUID) -> None:
            aws_lambda.invoke_event(
                function_name=settings.fan_fanout_lambda_function_name,
                payload={"run_id": str(run_id)},
            )

        return _send_lambda

    def _noop(run_id: uuid.UUID) -> None:
        _ = run_id

    return _noop


dispatch_fan_fanout: Callable[[uuid.UUID], None] = lazy_proxy(_dispatch_fan_fanout)


def _dispatch_fan_collect() -> Callable[[FanBatch, DSPClientName], None]:
    if settings.fan_collect_dispatch_backend == "sqs":

        def _send_sqs(batch: FanBatch, client_name: DSPClientName) -> None:
            aws_sqs.send_message(
                queue_url=settings.sqs_fan_collect_queue_url_for(client_name),
                body=batch.model_dump_json(),
            )

        return _send_sqs

    if settings.fan_collect_dispatch_backend == "celery":

        def _send_celery(batch: FanBatch, client_name: DSPClientName) -> None:
            from app.pipeline import tasks

            if client_name == DSPClientName.spotify_smf:
                tasks.fan_collect_spotify_smf.apply_async(
                    args=(batch.model_dump(mode="json"),),
                    queue=settings.celery_fan_collect_spotify_smf_queue,
                )
            elif client_name == DSPClientName.spotify_songwhip:
                tasks.fan_collect_spotify_songwhip.apply_async(
                    args=(batch.model_dump(mode="json"),),
                    queue=settings.celery_fan_collect_spotify_songwhip_queue,
                )

        return _send_celery

    def _noop(batch: FanBatch, client_name: DSPClientName) -> None:
        _ = (batch, client_name)

    return _noop


dispatch_fan_collect: Callable[[FanBatch, DSPClientName], None] = lazy_proxy(
    _dispatch_fan_collect
)