"""
Comprehensive video analysis service that integrates all analysis components.
"""

from typing import Any

from app.core.logging import get_logger
from app.services.analysis_utils import AnalysisUtils
from app.services.audio_analysis_service import AudioAnalysisService
from app.services.face_analysis_service import FaceAnalysisService
from app.services.gaze_tracking_service import GazeTrackingService
from app.services.progress_tracker import ProcessingStep, ProgressTracker
from app.utils.legacy_formatter import format_video_legacy_output

logger = get_logger("video_analysis")


class VideoAnalysisService:
    """Service for comprehensive video analysis matching legacy output format."""

    def __init__(self):
        self.gaze_tracker = GazeTrackingService()
        self.face_analyzer = FaceAnalysisService()
        self.analysis_utils = AnalysisUtils()
        self.audio_analyzer = AudioAnalysisService()

    async def analyze_video(
        self,
        video_path: str,
        user_id: int | None = None,
        interview_id: int | None = None,
        question_id: int | None = None,
        interview_type: str | None = None,
        job_id: str | None = None,
    ) -> dict[str, Any]:
        """
        Perform comprehensive video analysis matching legacy output format.

        Args:
            video_path: Path to the video file
            user_id: Optional user ID (for logging/traceability)
            interview_id: Optional interview ID (for logging/traceability)
            question_id: Optional question ID (for logging/traceability)
            interview_type: Optional interview type ("1" for general, "2" for custom)

        Returns:
            Dict containing analysis results in legacy format
        """
        try:
            logger.info(f"Starting comprehensive analysis for video: {video_path}")
            if any(
                v is not None
                for v in (user_id, interview_id, question_id, interview_type)
            ):
                logger.info(
                    "Analysis metadata: user_id=%s, interview_id=%s, question_id=%s, interview_type=%s",
                    user_id,
                    interview_id,
                    question_id,
                    interview_type,
                )

            # Extract audio from video and analyze it using AudioAnalysisService
            logger.info("Step 1/3: Extracting audio from video")
            if job_id:
                await ProgressTracker.update_progress(
                    job_id, ProcessingStep.EXTRACTING_AUDIO
                )
            audio = await self.analysis_utils.extract_audio_from_video(video_path)

            # Use AudioAnalysisService for all audio-related analysis
            logger.info("Step 2/3: Analyzing extracted audio")
            if job_id:
                await ProgressTracker.update_progress(
                    job_id, ProcessingStep.TRANSCRIBING_AUDIO
                )
            audio_analysis = await self.audio_analyzer.analyze_audio_from_video(audio)
            audio_result = audio_analysis["audio_result"]
            transcription_result = audio_analysis["transcription_result"]
            content_result = audio_analysis["content_result"]

            if job_id:
                await ProgressTracker.update_progress(
                    job_id, ProcessingStep.ANALYZING_CONTENT
                )

            # Analyze video-specific visual characteristics
            logger.info("Step 3/3: Analyzing visual characteristics")
            if job_id:
                await ProgressTracker.update_progress(
                    job_id, ProcessingStep.GAZE_TRACKING
                )
            video_result = await self._analyze_video_visual(video_path)

            if job_id:
                await ProgressTracker.update_progress(
                    job_id, ProcessingStep.FACE_ANALYSIS
                )

            # Combine all results in legacy format
            logger.info("Formatting final legacy output")
            legacy_output = format_video_legacy_output(
                audio_result, video_result, transcription_result, content_result
            )

            logger.info(f"Analysis completed for video: {video_path}")
            return legacy_output

        except Exception as e:
            logger.error(f"Failed to analyze video {video_path}: {e}")
            raise

    async def _analyze_video_visual(self, video_path: str) -> dict[str, Any]:
        """Analyze video visual characteristics matching legacy output."""
        try:
            logger.info("Visual analysis: getting video properties")
            # Get video properties
            video_props = await self.analysis_utils.get_video_properties(video_path)
            total_frames = video_props.get("total_frames", 0)

            # Analyze gaze tracking
            logger.info("Visual analysis: running gaze tracking")
            gaze_result = await self.gaze_tracker.analyze_video_gaze(video_path)

            # Analyze face detection and smile
            logger.info("Visual analysis: running face/smile detection")
            face_result = await self.face_analyzer.analyze_video_face(video_path)

            # Analyze lighting
            logger.info("Visual analysis: evaluating lighting conditions")
            lighting_result = await self.face_analyzer.analyze_video_lighting(
                video_path
            )

            logger.info("Visual analysis: completed")
            return {
                "total_video_frames": total_frames,
                "eye_contact_leftside": gaze_result.get("left_side", 0),
                "eye_contact_rightside": gaze_result.get("right_side", 0),
                "eye_contact_center": gaze_result.get("center", 0),
                "total_eye_capture": gaze_result.get("total_percentage", 0),
                "percentage_eye_contact_center": gaze_result.get(
                    "center_percentage", 0
                ),
                "percentage_eye_contact_left": gaze_result.get("left_percentage", 0),
                "percentage_eye_contact_right": gaze_result.get("right_percentage", 0),
                "eye_contact_behavior": gaze_result.get("behavior", "unknown"),
                "smiling_frames": face_result.get("smile_count", 0),
                "total_smile_capture": face_result.get("smile_percentage", 0),
                "video_light_value": lighting_result.get("light_value", 0),
                "video_light": lighting_result.get("light_category", "unknown"),
            }

        except Exception as e:
            logger.error(f"Video visual analysis failed: {e}")
            return {}