import logging
from dataclasses import dataclass

from app.adapters import aws_kms, ows_resonance_engine
from app.adapters.kafka import kafka_producer
from app.config import settings
from app.types import EventRecord, PresaveEvent

logger = logging.getLogger(__name__)


@dataclass(frozen=True, kw_only=True)
class ProcessSongwhipEventRequest:
    events: list[PresaveEvent]


def process_songwhip_event(request: ProcessSongwhipEventRequest) -> None:
    logger.info(
        "Handling Songwhip events",
        extra={"events_count": len(request.events)},
    )

    records: list[EventRecord] = []

    for event in request.events:
        records.extend(EventRecord.from_presave_event(event))

    # Publish the records to the Kafka topic
    if records:
        logger.info("Sending records to Kafka", extra={"records_count": len(records)})

        for event in records:
            kafka_producer.publish(
                topic=settings.kafka_producer_topic,
                value=event.model_dump_json(by_alias=True),
                key=event.key,
            )

            try:
                _send_event_to_resonance_engine(event)
            except Exception as exc:
                logger.exception(
                    "Error sending event to resonance engine.",
                    exc_info=exc,
                )

        # Flush the producer
        kafka_producer.flush()

    return None


def _send_event_to_resonance_engine(event: EventRecord) -> None:
    if not settings.send_events_to_resonance_engine:
        return

    if not event.token or not event.email:
        return

    dsp_client_name = _get_supported_dsp_client(event)
    if dsp_client_name is None:
        # DSP Client is not supported
        return

    ows_resonance_engine.create_fan_connection(
        email=event.email,
        dsp_client_name=dsp_client_name,
        token=aws_kms.decrypt(event.token),
    )

    logger.info(
        "Event `%s` sent to resonance engine",
        event.task_id,
        extra={
            "task_id": event.task_id,
            "dsp_client_name": dsp_client_name,
        },
    )


def _get_supported_dsp_client(event: EventRecord) -> str | None:
    if event.task_id.startswith("spotify-presave-"):
        return "spotify_songwhip"
    elif event.task_id.startswith("deezer-presave-"):
        return "deezer_songwhip"
    elif event.task_id.startswith("amazon-music-presave-"):
        return "amazon_songwhip"
    elif event.task_id.startswith("apple-music-presave-"):
        return "apple_songwhip"
    return None