"""
Audio processing service using Tortoise ORM with streaming S3 processing.
"""

from typing import Any

from app.core.logging import get_logger
from app.repositories.feedback_repository import FeedbackRepository
from app.services.progress_tracker import ProcessingStep, ProgressTracker
from app.utils.processing_runner import process_s3_file

logger = get_logger("audio_processor")


class AudioProcessor:
    """Service for processing audio files using streaming S3 approach."""

    def __init__(self):
        pass

    async def process_audio(
        self,
        job_id: str,
        user_id: int,
        interview_id: int,
        question_id: int,
        interview_type: str,
        audio_path: str,
    ) -> dict[str, Any]:
        """Process audio file for AI feedback analysis using streaming S3 processing."""
        try:
            logger.info(
                f"[JOB {job_id}] Audio processor started | "
                f"user_id={user_id} interview_id={interview_id} question_id={question_id}"
            )

            # Use streaming S3 processing for audio
            async def _analyze_audio_streaming(local_path: str) -> dict[str, Any]:
                # Update progress for audio analysis start
                await ProgressTracker.update_progress(
                    job_id, ProcessingStep.TRANSCRIBING_AUDIO
                )

                return await self._analyze_audio_content(
                    local_path,
                    user_id,
                    interview_id,
                    question_id,
                    interview_type,
                    job_id,
                )

            # Audio files are typically smaller, use regular streaming
            analysis_result = await process_s3_file(
                job_id,
                "audio",
                audio_path,
                _analyze_audio_streaming,
                cleanup=True,
            )

            # Store results in database
            logger.info(f"[JOB {job_id}] Saving audio analysis results to database")
            feedback_repo = FeedbackRepository()
            await feedback_repo.upsert_feedback_json(
                user_id=user_id,
                interview_id=interview_id,
                question_id=question_id,
                interview_type=interview_type,
                content_json=analysis_result,
            )
            logger.info(f"[JOB {job_id}] Audio analysis results saved successfully")

            # Cleanup handled by processing runner

            logger.info(f"[JOB {job_id}] Audio processing completed successfully")

            return {
                "status": "success",
                "message": "Streaming audio processing completed successfully",
                "job_id": job_id,
                "analysis_result": analysis_result,
                "processing_method": "streaming_s3",
                "duration": analysis_result.get("audio_length", "0"),
            }

        except Exception as e:
            logger.error(f"Streaming audio processing failed for job {job_id}: {e}")
            raise e

    async def _analyze_audio_content(
        self,
        audio_path: str,
        user_id: int,
        interview_id: int,
        question_id: int,
        interview_type: str,
        job_id: str,
    ) -> dict[str, Any]:
        """Analyze audio content using dedicated audio analysis service."""
        try:
            from app.services.audio_analysis_service import (
                AudioAnalysisService,
            )

            # Initialize dedicated audio analysis service
            analyzer = AudioAnalysisService()

            # Update progress for content analysis
            await ProgressTracker.update_progress(
                job_id, ProcessingStep.ANALYZING_CONTENT
            )

            # Perform comprehensive audio analysis
            analysis_result = await analyzer.analyze_audio(
                audio_path,
                user_id=user_id,
                interview_id=interview_id,
                question_id=question_id,
                interview_type=interview_type,
            )

            return analysis_result

        except Exception as e:
            logger.error(f"Audio content analysis failed: {e}")
            raise e