from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Any, Callable, Coroutine
from uuid import UUID, uuid4
from core.logging import get_logger

logger = get_logger(__name__)


@dataclass
class DomainEvent:
    event_id: UUID = field(default_factory=uuid4)
    occurred_at: datetime = field(default_factory=lambda: datetime.now(timezone.utc))
    tenant_id: UUID | None = None
    user_id: UUID | None = None


# Concrete domain events
@dataclass
class UserRegisteredEvent(DomainEvent):
    email: str = ""
    full_name: str = ""


@dataclass
class TenantCreatedEvent(DomainEvent):
    tenant_name: str = ""
    slug: str = ""
    owner_user_id: UUID | None = None


@dataclass
class BotRegisteredEvent(DomainEvent):
    bot_id: UUID | None = None
    bot_username: str = ""


EventHandler = Callable[[DomainEvent], Coroutine[Any, Any, None]]


class EventBus:
    def __init__(self):
        self._handlers: dict[type[DomainEvent], list[EventHandler]] = {}

    def subscribe(self, event_type: type[DomainEvent], handler: EventHandler) -> None:
        if event_type not in self._handlers:
            self._handlers[event_type] = []
        self._handlers[event_type].append(handler)

    async def publish(self, event: DomainEvent) -> None:
        event_type = type(event)
        handlers = self._handlers.get(event_type, [])
        logger.info(
            "dispatching_domain_event",
            event_type=event_type.__name__,
            event_id=str(event.event_id),
            handlers_count=len(handlers),
        )
        for handler in handlers:
            try:
                await handler(event)
            except Exception as exc:
                logger.error(
                    "event_handler_failed",
                    handler=handler.__name__,
                    event_type=event_type.__name__,
                    error=str(exc),
                )


_event_bus = EventBus()


async def _default_domain_event_logger(event: DomainEvent) -> None:
    """Default handler that records all published domain events into structured audit logs."""
    logger.info(
        "domain_event_recorded",
        event_type=type(event).__name__,
        event_id=str(event.event_id),
        tenant_id=str(event.tenant_id) if event.tenant_id else None,
        user_id=str(event.user_id) if event.user_id else None,
    )


# Register default system subscribers
_event_bus.subscribe(UserRegisteredEvent, _default_domain_event_logger)
_event_bus.subscribe(TenantCreatedEvent, _default_domain_event_logger)
_event_bus.subscribe(BotRegisteredEvent, _default_domain_event_logger)


def get_event_bus() -> EventBus:
    return _event_bus
