"""Quick reply session service for managing FAQ sessions."""

import logging
from uuid import uuid4

from capa_de_integracion.models.quick_replies import QuickReplyScreen
from capa_de_integracion.services.firestore_service import FirestoreService
from capa_de_integracion.services.quick_reply_content import QuickReplyContentService
from capa_de_integracion.services.redis_service import RedisService

logger = logging.getLogger(__name__)


class QuickReplySessionResponse:
    """Response from quick reply session service."""

    def __init__(self, session_id: str, quick_replies: QuickReplyScreen) -> None:
        """Initialize response.

        Args:
            session_id: The session ID
            quick_replies: The quick reply screen data

        """
        self.session_id = session_id
        self.quick_replies = quick_replies


class QuickReplySessionService:
    """Service for managing quick reply FAQ sessions."""

    def __init__(
        self,
        redis_service: RedisService,
        firestore_service: FirestoreService,
        quick_reply_content_service: QuickReplyContentService,
    ) -> None:
        """Initialize quick reply session service.

        Args:
            redis_service: Redis service instance
            firestore_service: Firestore service instance
            quick_reply_content_service: Quick reply content service instance

        """
        self.redis_service = redis_service
        self.firestore_service = firestore_service
        self.quick_reply_content_service = quick_reply_content_service

    def _validate_phone(self, phone: str) -> None:
        """Validate phone number.

        Args:
            phone: Phone number to validate

        Raises:
            ValueError: If phone is empty or invalid

        """
        if not phone or not phone.strip():
            msg = "Phone number is required"
            raise ValueError(msg)

    async def start_quick_reply_session(
        self,
        telefono: str,
        _nombre: str,
        pantalla_contexto: str,
    ) -> QuickReplySessionResponse:
        """Start a quick reply FAQ session for a specific screen.

        Creates or updates a conversation session with pantalla_contexto set,
        loads the quick reply questions for the screen, and returns them.

        Args:
            telefono: User's phone number
            _nombre: User's name (currently unused but part of API contract)
            pantalla_contexto: Screen context identifier

        Returns:
            Quick reply session response with session ID and quick replies

        Raises:
            ValueError: If validation fails or data is invalid
            Exception: If there's an error creating session or loading content

        """
        self._validate_phone(telefono)

        # Get or create session
        session = await self.firestore_service.get_session_by_phone(telefono)
        if session:
            session_id = session.session_id
            await self.firestore_service.update_pantalla_contexto(
                session_id, pantalla_contexto,
            )
            session.pantalla_contexto = pantalla_contexto
        else:
            session_id = str(uuid4())
            user_id = f"user_by_phone_{telefono.replace(' ', '').replace('-', '')}"
            session = await self.firestore_service.create_session(
                session_id, user_id, telefono, pantalla_contexto,
            )

        # Cache session in Redis
        await self.redis_service.save_session(session)
        logger.info(
            "Created quick reply session %s for screen: %s",
            session_id,
            pantalla_contexto,
        )

        # Load quick replies for the screen
        quick_replies = await self.quick_reply_content_service.get_quick_replies(
            pantalla_contexto,
        )

        return QuickReplySessionResponse(
            session_id=session_id,
            quick_replies=quick_replies,
        )