"""
Repository for feedback data operations using Tortoise ORM.
"""

from app.core.logging import get_logger
from app.models.feedback_data import AIFeedbackData

logger = get_logger("feedback_repository")


class FeedbackRepository:
    """Repository for feedback data operations."""

    async def upsert_feedback_json(
        self,
        *,
        user_id: int,
        interview_id: int,
        question_id: int,
        interview_type: str,
        content_json: str,
    ) -> int:
        """Insert or replace latest feedback json for the user/interview/question.

        Returns the inserted record id.
        """
        try:
            logger.info(
                f"Starting upsert_feedback_json for user_id={user_id}, interview_id={interview_id}, question_id={question_id}"
            )
            logger.info(f"Interview type: {interview_type}")
            logger.info(f"Content JSON length: {len(content_json)} characters")

            # Check for existing record
            existing = (
                await AIFeedbackData.filter(
                    user_id=user_id,
                    interview_id=interview_id,
                    question_id=question_id,
                )
                .order_by("-id")
                .first()
            )

            if existing:
                logger.info(f"Found existing record with id={existing.id}, deleting it")
                await existing.delete()
                logger.info("Existing record deleted successfully")
            else:
                logger.info("No existing record found, will create new one")

            # Create new record
            logger.info("Creating new AIFeedbackData record...")
            rec = await AIFeedbackData.create(
                user_id=user_id,
                interview_id=interview_id,
                question_id=question_id,
                interview_type=interview_type,
                content=content_json,
            )

            logger.info(f"Record created successfully with id: {rec.id}")
            return rec.id

        except Exception as e:
            logger.error(f"Failed to upsert feedback json: {e}")
            logger.error(f"Exception type: {type(e).__name__}")
            import traceback

            logger.error(f"Full traceback: {traceback.format_exc()}")
            raise

    async def get_feedback_data(
        self, user_id: int, interview_id: int, question_id: int
    ) -> AIFeedbackData | None:
        """Get feedback data for a specific user/interview/question."""
        try:
            feedback = (
                await AIFeedbackData.filter(
                    user_id=user_id,
                    interview_id=interview_id,
                    question_id=question_id,
                )
                .order_by("-id")
                .first()
            )

            return feedback
        except Exception as e:
            logger.error(f"Failed to get feedback data: {e}")
            return None

    async def get_feedback_data_by_interview(
        self, interview_id: int, interview_type: str
    ) -> list[AIFeedbackData]:
        """Get all feedback data for a specific interview."""
        try:
            feedback_list = (
                await AIFeedbackData.filter(
                    interview_id=interview_id,
                    interview_type=interview_type,
                )
                .order_by("question_id")
                .all()
            )

            return feedback_list
        except Exception as e:
            logger.error(
                f"Failed to get feedback data for interview {interview_id}: {e}"
            )
            return []

    async def delete_feedback_data(
        self, user_id: int, interview_id: int, question_id: int
    ) -> bool:
        """Delete feedback data for a specific user/interview/question."""
        try:
            deleted_count = await AIFeedbackData.filter(
                user_id=user_id,
                interview_id=interview_id,
                question_id=question_id,
            ).delete()

            logger.info(f"Deleted {deleted_count} feedback data records")
            return deleted_count > 0
        except Exception as e:
            logger.error(f"Failed to delete feedback data: {e}")
            return False