from datetime import timedelta
from typing import Any
from uuid import uuid4

from fastapi import HTTPException, status
from sqlalchemy import or_, select

from app.core.config import get_settings
from app.core.constants import ActorValue
from app.core.http.pagination import bounded_limit
from app.core.utils.time import utc_now
from app.modules.audit.constants import (
    AuditAction,
    AuditRiskLevel,
    AuditSource,
    AuditTargetType,
)
from app.modules.audit.schemas import AuditLogCreate
from app.modules.audit.service import AuditService
from app.modules.events.constants import (
    EventErrorDetail,
    EventPayloadKey,
    EventStatus,
)
from app.modules.events.models import DomainEvent
from app.modules.events.services.serialization import _serialize_event


class EventDispatchMixin:
    def dispatch_event(self, event_id: str, worker_id: str | None = None) -> DomainEvent:
        record = self.get_event(event_id)
        if record.status == EventStatus.PROCESSED:
            return record
        if not self._can_attempt(record):
            return record
        settings = get_settings()
        now = utc_now()
        lock_owner = worker_id or f"api:{uuid4().hex}"
        record.locked_by = lock_owner
        record.locked_until = now + timedelta(seconds=settings.event_dispatch_lock_seconds)
        record.status = EventStatus.PENDING
        record.attempts += 1
        try:
            self._handle_event(record)
        except Exception as exc:
            retryable = record.attempts < self._max_attempts(record)
            record.status = EventStatus.PENDING if retryable else EventStatus.FAILED
            record.last_error = str(exc)
            record.next_attempt_at = (
                utc_now() + timedelta(seconds=settings.event_dispatch_retry_delay_seconds)
                if retryable
                else None
            )
            record.locked_by = None
            record.locked_until = None
            self.db.commit()
            self.db.refresh(record)
            self._audit_dispatch(record)
            return record
        record.status = EventStatus.PROCESSED
        record.last_error = None
        record.processed_at = utc_now()
        record.next_attempt_at = None
        record.locked_by = None
        record.locked_until = None
        self.db.commit()
        self.db.refresh(record)
        self._audit_dispatch(record)
        return record

    def dispatch_pending(
        self,
        limit: int = 100,
        worker_id: str | None = None,
    ) -> list[dict[str, Any]]:
        now = utc_now()
        stmt = (
            select(DomainEvent)
            .where(
                DomainEvent.status == EventStatus.PENDING,
                or_(
                    DomainEvent.next_attempt_at.is_(None),
                    DomainEvent.next_attempt_at <= now,
                ),
                or_(
                    DomainEvent.locked_until.is_(None),
                    DomainEvent.locked_until <= now,
                ),
                or_(
                    DomainEvent.max_attempts.is_(None),
                    DomainEvent.attempts < DomainEvent.max_attempts,
                ),
            )
            .order_by(DomainEvent.id.asc())
            .limit(bounded_limit(limit))
        )
        records = list(self.db.execute(stmt).scalars())
        lock_owner = worker_id or f"worker:{uuid4().hex}"
        return [
            _serialize_event(self.dispatch_event(record.event_id, worker_id=lock_owner))
            for record in records
        ]

    def retry_event(self, event_id: str, actor: str = ActorValue.API) -> DomainEvent:
        record = self.get_event(event_id)
        if record.status == EventStatus.PROCESSED:
            raise HTTPException(
                status_code=status.HTTP_409_CONFLICT,
                detail=EventErrorDetail.EVENT_NOT_RETRYABLE,
            )
        record.status = EventStatus.PENDING
        record.actor = actor
        record.attempts = 0
        record.max_attempts = record.max_attempts or get_settings().event_dispatch_max_attempts
        record.last_error = None
        record.locked_by = None
        record.locked_until = None
        record.next_attempt_at = utc_now()
        self.db.commit()
        self.db.refresh(record)
        return record

    def _audit_dispatch(self, record: DomainEvent) -> None:
        AuditService(self.db).log(
            AuditLogCreate(
                actor=record.actor,
                source=AuditSource.EVENTS,
                action=AuditAction.EVENT_DISPATCH,
                target_type=AuditTargetType.DOMAIN_EVENT,
                target_id=record.event_id,
                risk_level=AuditRiskLevel.LOW,
                response_payload={
                    EventPayloadKey.STATUS: record.status,
                    EventPayloadKey.ATTEMPTS: record.attempts,
                    EventPayloadKey.ERROR_MESSAGE: record.last_error,
                },
            )
        )

    def _can_attempt(self, record: DomainEvent) -> bool:
        return record.attempts < self._max_attempts(record)

    @staticmethod
    def _max_attempts(record: DomainEvent) -> int:
        return record.max_attempts or get_settings().event_dispatch_max_attempts