"""
Notification service for AI feedback completion and failures.
"""

import asyncio
from typing import Any

import httpx

from app.core.config import settings
from app.core.logging import get_logger
from app.repositories.interview_repository import InterviewRepository

logger = get_logger("notification_service")


class NotificationService:
    """Service for sending notifications about AI feedback completion."""

    def __init__(self):
        self.interview_repo = InterviewRepository()
        self.legacy_webhook_url = (
            ("https://myinterviewpractice.com/ajax/api/ai_feedbak_notify.php")
            if settings.ENVIRONMENT == "production"
            else "https://staging.myinterviewpractice.com/ajax/api/ai_feedbak_notify.php"
        )

        self.max_retries = 3
        self.base_delay = 1.0  # seconds

    async def notify_ai_feedback_completion(
        self, interview_id: int, interview_type: str
    ) -> dict[str, Any]:
        """Notify user that AI feedback is complete."""
        try:
            logger.info(
                f"Notifying completion for interview {interview_id} type {interview_type}"
            )

            # Get interview details
            interview_details = await self.interview_repo.get_interview_details(
                interview_id, interview_type
            )

            if not interview_details:
                logger.warning(f"Interview {interview_id} not found for notification")
                return {"status": "error", "message": "Interview not found"}

            # Send legacy webhook notification
            webhook_result = await self._send_legacy_webhook(
                interview_id, interview_type
            )

            logger.info(f"Notification sent for interview {interview_id}")
            return {
                "status": "success",
                "webhook": webhook_result,
            }

        except Exception as e:
            logger.error(
                f"Failed to send completion notification for interview {interview_id}: {e}"
            )
            return {"status": "error", "message": str(e)}

    async def notify_ai_feedback_failure(
        self, interview_id: int, interview_type: str, error_message: str
    ) -> dict[str, Any]:
        """Notify user about AI feedback failure."""
        try:
            logger.info(
                f"Notifying failure for interview {interview_id} type {interview_type}"
            )

            # Get interview details (kept for future DB notification usage)
            _interview_details = await self.interview_repo.get_interview_details(
                interview_id, interview_type
            )

            logger.info(f"Failure notification sent for interview {interview_id}")
            return {"status": "success", "error_message": error_message}

        except Exception as e:
            logger.error(
                f"Failed to send failure notification for interview {interview_id}: {e}"
            )
            return {"status": "error", "message": str(e)}

    async def _send_legacy_webhook(
        self, interview_id: int, interview_type: str
    ) -> dict[str, Any]:
        """Send notification to legacy PHP webhook endpoint."""
        try:
            payload = {"interview_id": str(interview_id), "type": str(interview_type)}

            headers = {
                "Content-Type": "application/x-www-form-urlencoded",
                "User-Agent": "AI-Feedback-FastAPI/2.0.0",
            }

            # Retry logic with exponential backoff
            for attempt in range(self.max_retries):
                try:
                    async with httpx.AsyncClient(timeout=30.0) as client:
                        response = await client.post(
                            self.legacy_webhook_url, data=payload, headers=headers
                        )

                        if response.status_code == 200:
                            logger.info(
                                f"Legacy webhook successful for interview {interview_id}"
                            )
                            return {
                                "status": "success",
                                "response_code": response.status_code,
                                "response_text": response.text,
                            }
                        else:
                            logger.warning(
                                f"Legacy webhook failed with status {response.status_code} for interview {interview_id}"
                            )

                except Exception as e:
                    logger.warning(
                        f"Webhook attempt {attempt + 1} failed for interview {interview_id}: {e}"
                    )

                    if attempt < self.max_retries - 1:
                        delay = self.base_delay * (2**attempt)  # Exponential backoff
                        await asyncio.sleep(delay)
                        continue
                    else:
                        raise e

            return {"status": "error", "message": "All webhook attempts failed"}

        except Exception as e:
            logger.error(
                f"Failed to send legacy webhook for interview {interview_id}: {e}"
            )
            return {"status": "error", "message": str(e)}