"""
Health check service for the AI Feedback API using Tortoise ORM.
"""

from datetime import datetime
from typing import Any

from app.core.logging import get_logger
from app.models.queue import AIFeedbackQueue

logger = get_logger("health_service")


class HealthService:
    """Service for health checks."""

    async def check_all(self) -> dict[str, Any]:
        """Check all system components."""
        return {
            "status": "healthy",
            "timestamp": datetime.utcnow().isoformat(),
            "checks": {
                "database": await self._check_database(),
                "aws": await self._check_aws(),
                "queue": await self._check_queue(),
            },
        }

    async def is_ready(self) -> bool:
        """Check if the service is ready to handle requests."""
        try:
            # Check database health
            db_healthy = await self._check_database()
            if not db_healthy["healthy"]:
                return False

            # Check queue status
            queue_healthy = await self._check_queue()
            if not queue_healthy["healthy"]:
                return False

            return True
        except Exception:
            return False

    async def _check_database(self) -> dict[str, Any]:
        """Check database connectivity."""
        try:
            # Use a simple ORM query to test database connection
            await AIFeedbackQueue.all().count()

            return {
                "healthy": True,
                "message": "Database connection successful",
                "timestamp": datetime.utcnow().isoformat(),
            }
        except Exception as e:
            return {
                "healthy": False,
                "message": f"Database connection failed: {e!s}",
                "timestamp": datetime.utcnow().isoformat(),
            }

    async def _check_aws(self) -> dict[str, Any]:
        """Check AWS connectivity."""
        # TODO: Implement actual AWS health check
        return {
            "healthy": True,
            "message": "AWS connection successful",
            "timestamp": datetime.utcnow().isoformat(),
        }

    async def _check_queue(self) -> dict[str, Any]:
        """Check queue status."""
        try:
            # Use ORM to count jobs by status
            stats = {}
            for status in ["0", "1", "2", "3"]:
                count = await AIFeedbackQueue.filter(status=status).count()
                stats[status] = count

            return {
                "healthy": True,
                "message": "Queue status check successful",
                "stats": stats,
                "timestamp": datetime.utcnow().isoformat(),
            }
        except Exception as e:
            return {
                "healthy": False,
                "message": f"Queue status check failed: {e!s}",
                "timestamp": datetime.utcnow().isoformat(),
            }