"""Sound management API endpoints."""

from typing import Annotated

from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlmodel.ext.asyncio.session import AsyncSession

from app.core.database import get_db, get_session_factory
from app.core.dependencies import get_current_active_user_flexible
from app.models.credit_action import CreditActionType
from app.models.user import User
from app.repositories.sound import SoundRepository
from app.services.credit import CreditService, InsufficientCreditsError
from app.services.extraction import ExtractionInfo, ExtractionService
from app.services.extraction_processor import extraction_processor
from app.services.sound_normalizer import NormalizationResults, SoundNormalizerService
from app.services.sound_scanner import ScanResults, SoundScannerService
from app.services.vlc_player import VLCPlayerService, get_vlc_player_service

router = APIRouter(prefix="/sounds", tags=["sounds"])


async def get_sound_scanner_service(
    session: Annotated[AsyncSession, Depends(get_db)],
) -> SoundScannerService:
    """Get the sound scanner service."""
    return SoundScannerService(session)


async def get_sound_normalizer_service(
    session: Annotated[AsyncSession, Depends(get_db)],
) -> SoundNormalizerService:
    """Get the sound normalizer service."""
    return SoundNormalizerService(session)


async def get_extraction_service(
    session: Annotated[AsyncSession, Depends(get_db)],
) -> ExtractionService:
    """Get the extraction service."""
    return ExtractionService(session)


def get_vlc_player() -> VLCPlayerService:
    """Get the VLC player service."""
    return get_vlc_player_service(get_session_factory())


def get_credit_service() -> CreditService:
    """Get the credit service."""
    return CreditService(get_session_factory())


async def get_sound_repository(
    session: Annotated[AsyncSession, Depends(get_db)],
) -> SoundRepository:
    """Get the sound repository."""
    return SoundRepository(session)


# SCAN
@router.post("/scan")
async def scan_sounds(
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    scanner_service: Annotated[SoundScannerService, Depends(get_sound_scanner_service)],
) -> dict[str, ScanResults | str]:
    """Sync the soundboard directory (add/update/delete sounds)."""
    # Only allow admins to scan sounds
    if current_user.role not in ["admin", "superadmin"]:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only administrators can sync sounds",
        )

    try:
        results = await scanner_service.scan_soundboard_directory()
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to sync sounds: {e!s}",
        ) from e
    else:
        return {
            "message": "Sound sync completed",
            "results": results,
        }


@router.post("/scan/custom")
async def scan_custom_directory(
    directory: str,
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    scanner_service: Annotated[SoundScannerService, Depends(get_sound_scanner_service)],
    sound_type: str = "SDB",
) -> dict[str, ScanResults | str]:
    """Sync a custom directory with the database (add/update/delete sounds)."""
    # Only allow admins to sync sounds
    if current_user.role not in ["admin", "superadmin"]:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only administrators can sync sounds",
        )

    try:
        results = await scanner_service.scan_directory(directory, sound_type)
    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=str(e),
        ) from e
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to sync directory: {e!s}",
        ) from e
    else:
        return {
            "message": f"Sync of directory '{directory}' completed",
            "results": results,
        }


# NORMALIZE
@router.post("/normalize/all")
async def normalize_all_sounds(
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    normalizer_service: Annotated[
        SoundNormalizerService, Depends(get_sound_normalizer_service),
    ],
    force: Annotated[bool, Query(  # noqa: FBT002
        description="Force normalization of already normalized sounds",
    )] = False,
    one_pass: Annotated[bool | None, Query(
        description="Use one-pass normalization (overrides config)",
    )] = None,
) -> dict[str, NormalizationResults | str]:
    """Normalize all unnormalized sounds."""
    # Only allow admins to normalize sounds
    if current_user.role not in ["admin", "superadmin"]:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only administrators can normalize sounds",
        )

    try:
        results = await normalizer_service.normalize_all_sounds(
            force=force,
            one_pass=one_pass,
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to normalize sounds: {e!s}",
        ) from e
    else:
        return {
            "message": "Sound normalization completed",
            "results": results,
        }


@router.post("/normalize/type/{sound_type}")
async def normalize_sounds_by_type(
    sound_type: str,
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    normalizer_service: Annotated[
        SoundNormalizerService, Depends(get_sound_normalizer_service),
    ],
    force: Annotated[bool, Query(  # noqa: FBT002
        description="Force normalization of already normalized sounds",
    )] = False,
    one_pass: Annotated[bool | None, Query(
        description="Use one-pass normalization (overrides config)",
    )] = None,
) -> dict[str, NormalizationResults | str]:
    """Normalize all sounds of a specific type (SDB, TTS, EXT)."""
    # Only allow admins to normalize sounds
    if current_user.role not in ["admin", "superadmin"]:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only administrators can normalize sounds",
        )

    # Validate sound type
    valid_types = ["SDB", "TTS", "EXT"]
    if sound_type not in valid_types:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=f"Invalid sound type. Must be one of: {', '.join(valid_types)}",
        )

    try:
        results = await normalizer_service.normalize_sounds_by_type(
            sound_type=sound_type,
            force=force,
            one_pass=one_pass,
        )
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to normalize {sound_type} sounds: {e!s}",
        ) from e
    else:
        return {
            "message": f"Normalization of {sound_type} sounds completed",
            "results": results,
        }


@router.post("/normalize/{sound_id}")
async def normalize_sound_by_id(
    sound_id: int,
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    normalizer_service: Annotated[
        SoundNormalizerService, Depends(get_sound_normalizer_service),
    ],
    force: Annotated[bool, Query(  # noqa: FBT002
        description="Force normalization of already normalized sound",
    )] = False,
    one_pass: Annotated[bool | None, Query(
        description="Use one-pass normalization (overrides config)",
    )] = None,
) -> dict[str, str]:
    """Normalize a specific sound by ID."""
    # Only allow admins to normalize sounds
    if current_user.role not in ["admin", "superadmin"]:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only administrators can normalize sounds",
        )

    try:
        # Get the sound
        sound = await normalizer_service.sound_repo.get_by_id(sound_id)
        if not sound:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail=f"Sound with ID {sound_id} not found",
            )

        # Normalize the sound
        result = await normalizer_service.normalize_sound(
            sound=sound,
            force=force,
            one_pass=one_pass,
        )

        # Check result status
        if result["status"] == "error":
            raise HTTPException(
                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                detail=f"Failed to normalize sound: {result['error']}",
            )

        return {
            "message": f"Sound normalization {result['status']}: {sound.filename}",
            "status": result["status"],
            "reason": result["reason"] or "",
            "normalized_filename": result["normalized_filename"] or "",
        }

    except HTTPException:
        # Re-raise HTTPExceptions without wrapping them
        raise
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to normalize sound: {e!s}",
        ) from e


# EXTRACT
@router.post("/extract")
async def create_extraction(
    url: str,
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
) -> dict[str, ExtractionInfo | str]:
    """Create a new extraction job for a URL."""
    try:
        if current_user.id is None:
            raise HTTPException(
                status_code=status.HTTP_401_UNAUTHORIZED,
                detail="User ID not available",
            )

        extraction_info = await extraction_service.create_extraction(
            url, current_user.id,
        )

        # Queue the extraction for background processing
        await extraction_processor.queue_extraction(extraction_info["id"])

    except ValueError as e:
        raise HTTPException(
            status_code=status.HTTP_400_BAD_REQUEST,
            detail=str(e),
        ) from e
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to create extraction: {e!s}",
        ) from e
    else:
        return {
            "message": "Extraction queued successfully",
            "extraction": extraction_info,
        }


@router.get("/extract/status")
async def get_extraction_processor_status(
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
) -> dict:
    """Get the status of the extraction processor."""
    # Only allow admins to see processor status
    if current_user.role not in ["admin", "superadmin"]:
        raise HTTPException(
            status_code=status.HTTP_403_FORBIDDEN,
            detail="Only administrators can view processor status",
        )

    return extraction_processor.get_status()


@router.get("/extract/{extraction_id}")
async def get_extraction(
    extraction_id: int,
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],  # noqa: ARG001
    extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
) -> ExtractionInfo:
    """Get extraction information by ID."""
    try:
        extraction_info = await extraction_service.get_extraction_by_id(extraction_id)

        if not extraction_info:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail=f"Extraction {extraction_id} not found",
            )

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to get extraction: {e!s}",
        ) from e
    else:
        return extraction_info


@router.get("/extract")
async def get_user_extractions(
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    extraction_service: Annotated[ExtractionService, Depends(get_extraction_service)],
) -> dict[str, list[ExtractionInfo]]:
    """Get all extractions for the current user."""
    try:
        if current_user.id is None:
            raise HTTPException(
                status_code=status.HTTP_401_UNAUTHORIZED,
                detail="User ID not available",
            )

        extractions = await extraction_service.get_user_extractions(current_user.id)

    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to get extractions: {e!s}",
        ) from e
    else:
        return {
            "extractions": extractions,
        }


# VLC PLAYER
@router.post("/vlc/play/{sound_id}")
async def play_sound_with_vlc(
    sound_id: int,
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],
    vlc_player: Annotated[VLCPlayerService, Depends(get_vlc_player)],
    sound_repo: Annotated[SoundRepository, Depends(get_sound_repository)],
    credit_service: Annotated[CreditService, Depends(get_credit_service)],
) -> dict[str, str | int | bool]:
    """Play a sound using VLC subprocess (requires 1 credit)."""
    try:
        # Get the sound
        sound = await sound_repo.get_by_id(sound_id)
        if not sound:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail=f"Sound with ID {sound_id} not found",
            )

        # Check and validate credits before playing
        try:
            await credit_service.validate_and_reserve_credits(
                current_user.id,
                CreditActionType.VLC_PLAY_SOUND,
                {"sound_id": sound_id, "sound_name": sound.name},
            )
        except InsufficientCreditsError as e:
            raise HTTPException(
                status_code=status.HTTP_402_PAYMENT_REQUIRED,
                detail=(
                    f"Insufficient credits: {e.required} required, "
                    f"{e.available} available"
                ),
            ) from e

        # Play the sound using VLC
        success = await vlc_player.play_sound(sound)

        # Deduct credits based on success
        await credit_service.deduct_credits(
            current_user.id,
            CreditActionType.VLC_PLAY_SOUND,
            success,
            {"sound_id": sound_id, "sound_name": sound.name},
        )

        if not success:
            raise HTTPException(
                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
                detail="Failed to launch VLC for sound playback",
            )

    except HTTPException:
        raise
    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to play sound: {e!s}",
        ) from e
    else:
        return {
            "message": f"Sound '{sound.name}' is now playing via VLC",
            "sound_id": sound_id,
            "sound_name": sound.name,
            "success": True,
            "credits_deducted": 1,
        }



@router.post("/vlc/stop-all")
async def stop_all_vlc_instances(
    current_user: Annotated[User, Depends(get_current_active_user_flexible)],  # noqa: ARG001
    vlc_player: Annotated[VLCPlayerService, Depends(get_vlc_player)],
) -> dict:
    """Stop all running VLC instances."""
    try:
        return await vlc_player.stop_all_vlc_instances()

    except Exception as e:
        raise HTTPException(
            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
            detail=f"Failed to stop VLC instances: {e!s}",
        ) from e