"""
Repository for interview operations using Tortoise ORM.
"""

from app.core.logging import get_logger
from app.models.interview import CustomInterview, Interview

logger = get_logger("interview_repository")


class InterviewRepository:
    """Repository for interview operations."""

    async def update_interview_ai_feedback_status(
        self, interview_id: int, interview_type: str, status: str = "2"
    ) -> bool:
        """
        Update the AI feedback status for an interview.

        Args:
            interview_id: The interview ID
            interview_type: The interview type ("1" for general, "2" for custom)
            status: The new status to set

        Returns:
            bool: True if successful, False otherwise
        """
        try:
            # First, check if the interview exists and get current status
            if interview_type == "1":
                # General interview table - ai_feedback is int
                interview = await Interview.get_or_none(id=interview_id)
                if not interview:
                    logger.error(
                        f"Interview {interview_id} not found in general interview table"
                    )
                    return False

                current_status = interview.ai_feedback
                logger.info(
                    f"Interview {interview_id} current ai_feedback status: {current_status}"
                )

                try:
                    status_int = int(status)
                except ValueError:
                    logger.error(
                        f"Invalid status value '{status}' for general interview - must be integer"
                    )
                    return False

                # Only update if status is different
                if current_status == status_int:
                    logger.info(
                        f"Interview {interview_id} already has status {status_int}, no update needed"
                    )
                    return True

                updated_count = await Interview.filter(id=interview_id).update(
                    ai_feedback=status_int
                )
            else:
                # Custom interview table - ai_feedback is enum (string)
                interview = await CustomInterview.get_or_none(id=interview_id)
                if not interview:
                    logger.error(
                        f"Interview {interview_id} not found in custom interview table"
                    )
                    return False

                current_status = interview.ai_feedback
                logger.info(
                    f"Interview {interview_id} current ai_feedback status: {current_status}"
                )

                # Only update if status is different
                if current_status == status:
                    logger.info(
                        f"Interview {interview_id} already has status {status}, no update needed"
                    )
                    return True

                updated_count = await CustomInterview.filter(id=interview_id).update(
                    ai_feedback=status
                )

            logger.info(
                f"Updated AI feedback status to {status} for interview {interview_id} "
                f"(type: {interview_type}), rows affected: {updated_count}"
            )

            return updated_count > 0

        except Exception as e:
            logger.error(
                f"Failed to update AI feedback status for interview {interview_id}: {e}"
            )
            return False

    async def get_interview_ai_feedback_status(
        self, interview_id: int, interview_type: str
    ) -> str | None:
        """
        Get the current AI feedback status for an interview.

        Args:
            interview_id: The interview ID
            interview_type: The interview type ("1" for general, "2" for custom)

        Returns:
            str: The AI feedback status or None if not found
        """
        try:
            if interview_type == "1":
                # General interview table - ai_feedback is int
                interview = await Interview.get_or_none(id=interview_id)
            else:
                # Custom interview table - ai_feedback is enum (string)
                interview = await CustomInterview.get_or_none(id=interview_id)

            if interview:
                # Convert to string for consistency
                return str(interview.ai_feedback)
            return None

        except Exception as e:
            logger.error(
                f"Failed to get AI feedback status for interview {interview_id}: {e}"
            )
            return None

    async def get_interview_details(
        self, interview_id: int, interview_type: str
    ) -> dict | None:
        """
        Get interview details including user information for notifications.

        Args:
            interview_id: The interview ID
            interview_type: The interview type ("1" for general, "2" for custom)

        Returns:
            dict: Interview details with user info or None if not found
        """
        try:
            if interview_type == "1":
                # General interview table - need to join with users table
                # For now, return basic info since we don't have the full user join
                interview = await Interview.get_or_none(id=interview_id)
                if interview:
                    return {
                        "id": interview.id,
                        "user_id": interview.user_id,
                        "interview_name": interview.interview_name,
                        "interview_type": interview_type,
                    }
            else:
                # Custom interview table - has different structure
                interview = await CustomInterview.get_or_none(id=interview_id)
                if interview:
                    return {
                        "id": interview.id,
                        "user_id": interview.user_id,
                        "interview_id": interview.interview_id,  # Use interview_id instead of interview_name
                        "interview_type": interview_type,
                    }

            return None

        except Exception as e:
            logger.error(
                f"Failed to get interview details for interview {interview_id}: {e}"
            )
            return None