"""Centralized initialization service for application startup and setup.""" import asyncio import os import re from pathlib import Path from typing import Callable, Optional import structlog from src.config.settings import settings from src.server.database.service import AnimeSeriesService from src.server.services.setup_service import SetupService logger = structlog.get_logger(__name__) # Provider site URL constant ANIMEWORLD_URL = "https://aniworld.to" async def _check_scan_status( check_method: Callable, scan_type: str, log_completed_msg: str = None, log_not_completed_msg: str = None ) -> bool: """Generic function to check if a scan has been completed. Args: check_method: SystemSettingsService method to check scan status scan_type: Type of scan (e.g., "initial", "NFO", "media") log_completed_msg: Optional custom message when scan is completed log_not_completed_msg: Optional custom message when scan not completed Returns: bool: True if scan was completed, False otherwise """ from src.server.database.connection import get_db_session from src.server.database.system_settings_service import SystemSettingsService try: async with get_db_session() as db: is_completed = await check_method(SystemSettingsService, db) if is_completed and log_completed_msg: logger.info(log_completed_msg) elif not is_completed and log_not_completed_msg: logger.info(log_not_completed_msg) return is_completed except Exception as e: logger.warning( "Failed to check %s scan status: %s, assuming not done", scan_type, e ) return False async def _mark_scan_completed( mark_method: Callable, scan_type: str ) -> None: """Generic function to mark a scan as completed. Args: mark_method: SystemSettingsService method to mark scan as completed scan_type: Type of scan (e.g., "initial", "NFO", "media") """ from src.server.database.connection import get_db_session from src.server.database.system_settings_service import SystemSettingsService try: async with get_db_session() as db: await mark_method(SystemSettingsService, db) logger.info("Marked %s scan as completed", scan_type) except Exception as e: logger.warning("Failed to mark %s scan as completed: %s", scan_type, e) async def _check_initial_scan_status() -> bool: """Check if initial scan has been completed. Returns: bool: True if scan was completed, False otherwise """ is_completed = await _check_scan_status( check_method=lambda svc, db: svc.is_initial_scan_completed(db), scan_type="initial", log_completed_msg=( "Initial scan already completed, skipping data file sync" ), log_not_completed_msg=( "Initial scan not completed, performing first-time setup" ) ) return is_completed async def _mark_initial_scan_completed() -> None: """Mark the initial scan as completed in system settings.""" await _mark_scan_completed( mark_method=lambda svc, db: svc.mark_initial_scan_completed(db), scan_type="initial" ) async def _check_legacy_key_cleanup_status() -> bool: """Check if legacy key file cleanup has been completed. Returns: bool: True if cleanup was completed, False otherwise """ return await _check_scan_status( check_method=lambda svc, db: svc.is_legacy_key_cleanup_completed(db), scan_type="legacy_key_cleanup", log_completed_msg="Legacy key file cleanup already completed, skipping", log_not_completed_msg="Legacy key file cleanup not yet run, will clean up key files" ) async def _mark_legacy_key_cleanup_completed() -> None: """Mark the legacy key file cleanup as completed in system settings.""" await _mark_scan_completed( mark_method=lambda svc, db: svc.mark_legacy_key_cleanup_completed(db), scan_type="legacy_key_cleanup" ) async def _cleanup_legacy_key_files() -> int: """Remove legacy key files from folders that already have DB entries. This is a one-time cleanup task that runs at startup after legacy migration. It removes deprecated 'key' files that cause duplicate key errors when folders are renamed, since the DB is now the source of truth. Returns: int: Number of key files deleted """ from src.server.database.connection import get_db_session from src.server.database.service import AnimeSeriesService logger.info("Checking for legacy key files to clean up...") if not settings.anime_directory or not os.path.isdir(settings.anime_directory): logger.warning( "Anime directory not configured or does not exist, skipping legacy key cleanup" ) return 0 deleted_count = 0 scanned_count = 0 try: async with get_db_session() as db: # Get all series from DB to know which folders should have key files removed all_series = await AnimeSeriesService.get_all(db) # Build a set of known folder names from DB db_folders: set[str] = {series.folder for series in all_series if series.folder} for folder_name in db_folders: folder_path = Path(settings.anime_directory) / folder_name key_file = folder_path / "key" if not key_file.exists(): continue scanned_count += 1 try: key_file.unlink() deleted_count += 1 logger.info( "Removed legacy key file", folder=folder_name, key_file=str(key_file) ) except OSError as exc: logger.warning( "Could not remove legacy key file", folder=folder_name, key_file=str(key_file), error=str(exc) ) except Exception as e: logger.error( "Legacy key file cleanup failed", error=str(e), exc_info=True ) return deleted_count logger.info( "Legacy key file cleanup complete", scanned=scanned_count, deleted=deleted_count ) return deleted_count async def _sync_anime_folders(progress_service=None) -> int: """Scan anime folders and sync series to database. Args: progress_service: Optional ProgressService for progress updates Returns: int: Number of series synced """ logger.info("Performing initial anime folder scan...") # Check if anime directory exists before attempting sync if not settings.anime_directory or not os.path.isdir(settings.anime_directory): logger.info( "Anime directory not configured or does not exist, skipping data file sync" ) if progress_service: await progress_service.update_progress( progress_id="series_sync", current=100, message="No anime directory configured, skipping data file sync", metadata={"step_id": "series_sync"} ) return 0 if progress_service: await progress_service.update_progress( progress_id="series_sync", current=25, message="Scanning anime folders...", metadata={"step_id": "series_sync"} ) # Legacy sync removed - series are loaded directly from database via _load_series_into_memory sync_count = 0 logger.info("Data file sync skipped - series loaded directly from database") if progress_service: await progress_service.update_progress( progress_id="series_sync", current=75, message=f"Series loaded directly from database", metadata={"step_id": "series_sync"} ) return sync_count async def _load_series_into_memory(progress_service=None) -> None: """Load series from database into SeriesApp's in-memory cache. Args: progress_service: Optional ProgressService for progress updates """ from src.server.utils.dependencies import get_anime_service anime_service = get_anime_service() await anime_service._load_series_from_db() logger.info("Series loaded from database into memory") if progress_service: await progress_service.complete_progress( progress_id="series_sync", message="Series loaded into memory", metadata={"step_id": "series_sync"} ) async def _scan_folders_to_database(progress_service=None) -> tuple[int, int]: """Scan anime folders and create AnimeSeries DB records. This function runs during initial setup only. It delegates to SetupService.run() which handles: 1. Iterates subdirectories of anime_directory 2. Extracts title/year from folder names (year via (YYYY) pattern) 3. Uses provider search to resolve key field when single match found 4. Creates AnimeSeries records for new folders Args: progress_service: Optional ProgressService for progress updates Returns: Tuple of (number of new series created, number of unresolved folders) """ logger.info("Scanning anime folders for new series...") if not settings.anime_directory or not os.path.isdir(settings.anime_directory): logger.info( "Anime directory not configured or does not exist, skipping folder scan" ) return 0, 0 # Use SetupService to handle the scanning and creation created_count, unresolved_count = await SetupService.run() logger.info( "Folder scan complete", created=created_count, unresolved=unresolved_count ) return created_count, unresolved_count async def _validate_anime_directory(progress_service=None) -> bool: """Validate that anime directory is configured. Args: progress_service: Optional ProgressService for progress updates Returns: bool: True if directory is configured, False otherwise """ logger.info( "Checking anime_directory setting: '%s'", settings.anime_directory ) if not settings.anime_directory: logger.info("Initialization skipped - anime directory not configured") if progress_service: await progress_service.complete_progress( progress_id="series_sync", message="No anime directory configured", metadata={"step_id": "series_sync"} ) return False return True async def perform_initial_setup(progress_service=None): """Perform initial setup including series sync and scan completion marking. This function is called both during application lifespan startup and when the setup endpoint is completed. It ensures that: 1. Legacy key/data files are migrated to database (one-time) 2. Series are synced from data files to database 3. Initial scan is marked as completed 4. Series are loaded into memory 5. NFO scan is performed if configured 6. Media scan is performed Args: progress_service: Optional ProgressService for emitting updates Returns: bool: True if initialization was performed, False if skipped """ # Send initial progress update if progress_service: from src.server.services.progress_service import ProgressType await progress_service.start_progress( progress_id="series_sync", progress_type=ProgressType.SYSTEM, title="Syncing Series Database", total=100, message="Checking initialization status...", metadata={"step_id": "series_sync"} ) # Check if initial setup has already been completed is_initial_scan_done = await _check_initial_scan_status() if is_initial_scan_done: if progress_service: await progress_service.complete_progress( progress_id="series_sync", message="Already completed", metadata={"step_id": "series_sync"} ) return False # Validate that anime directory is configured if not await _validate_anime_directory(progress_service): return False # Perform the actual initialization try: # Scan folders and create AnimeSeries records first folder_scan_count, unresolved_count = await _scan_folders_to_database(progress_service) if folder_scan_count > 0: logger.info("Created %d series from anime folders", folder_scan_count) # Sync series from anime folders to database await _sync_anime_folders(progress_service) # Clean up legacy key files from folders that now have DB entries # This runs after migration/sync to ensure DB entries exist before deletion is_key_cleanup_done = await _check_legacy_key_cleanup_status() if not is_key_cleanup_done: await _cleanup_legacy_key_files() await _mark_legacy_key_cleanup_completed() # Mark the initial scan as completed await _mark_initial_scan_completed() # Mark loading as complete in config (used by middleware to allow redirect to /login) # Only mark complete if there are no unresolved folders - otherwise user needs # to resolve them first via /setup/unresolved try: from src.server.services.config_service import get_config_service config_svc = get_config_service() init_config = config_svc.load_config() if unresolved_count == 0: init_config.other['loading_complete'] = True logger.info("No unresolved folders - marking loading complete") else: logger.info( "Unresolved folders exist (%d) - deferring loading_complete", unresolved_count ) config_svc.save_config(init_config, create_backup=False) except Exception as e: logger.warning("Failed to save loading_complete flag: %s", e) # Load series into memory from database await _load_series_into_memory(progress_service) # NOTE: NFO scan is NO longer run here - it runs in a separate phase # after unresolved folders are completed (via /loading?phase=nfo) return True except (OSError, RuntimeError, ValueError) as e: logger.warning("Failed to perform initial setup: %s", e) return False async def _check_nfo_scan_status() -> bool: """Check if initial NFO scan has been completed. Returns: bool: True if NFO scan was completed, False otherwise """ return await _check_scan_status( check_method=lambda svc, db: svc.is_initial_nfo_scan_completed(db), scan_type="NFO" ) async def _mark_nfo_scan_completed() -> None: """Mark the initial NFO scan as completed in system settings.""" await _mark_scan_completed( mark_method=lambda svc, db: svc.mark_initial_nfo_scan_completed(db), scan_type="NFO" ) async def _is_nfo_scan_configured() -> bool: """Check if NFO scan features are properly configured. Returns: bool: True if TMDB API key and NFO features are configured """ return settings.tmdb_api_key and ( settings.nfo_auto_create or settings.nfo_update_on_scan ) async def _execute_nfo_scan(progress_service=None) -> None: """Execute the actual NFO scan with TMDB data. Args: progress_service: Optional ProgressService for emitting updates """ from src.server.services.nfo_scan_service import NfoScanService from src.server.utils.dependencies import get_anime_service logger.info("Starting NFO scan...") anime_service = get_anime_service() nfo_service = NfoScanService() # Subscribe to NFO events and forward to progress service async def nfo_event_handler(event_data): if event_data.get('type') == 'nfo_scan_progress': data = event_data.get('data', {}) if progress_service: await progress_service.update_progress( progress_id="nfo_scan", current=data.get('current', 0), total=data.get('total', 100), message=data.get('message', 'Scanning...'), key=data.get('key'), folder=data.get('folder'), ) # Note: nfo_scan_completed event is NOT handled here because # perform_nfo_scan_phase handles completion after _execute_nfo_scan returns nfo_service.subscribe_to_scan_events(nfo_event_handler) try: # Run the scan nfo_result = await nfo_service.scan_all(anime_service) logger.info("NFO scan completed: %s", nfo_result) finally: nfo_service.unsubscribe_from_scan_events(nfo_event_handler) async def perform_nfo_scan_if_needed(progress_service=None): """Perform initial NFO scan if not yet completed and configured. Args: progress_service: Optional ProgressService for emitting updates """ if progress_service: from src.server.services.progress_service import ProgressType await progress_service.start_progress( progress_id="nfo_scan", progress_type=ProgressType.SCAN, title="Scanning NFO Files", total=100, message="Checking NFO scan status...", metadata={"step_id": "nfo_scan"} ) # Check if NFO scan was already completed is_nfo_scan_done = await _check_nfo_scan_status() # Check if NFO features are configured if not await _is_nfo_scan_configured(): message = ( "Skipped - TMDB API key not configured" if not settings.tmdb_api_key else "Skipped - NFO features disabled" ) logger.info("NFO scan skipped: %s", message) if progress_service: await progress_service.complete_progress( progress_id="nfo_scan", message=message, metadata={"step_id": "nfo_scan"} ) return # Skip if already completed if is_nfo_scan_done: logger.info("Skipping NFO scan - already completed on previous run") if progress_service: await progress_service.complete_progress( progress_id="nfo_scan", message="Already completed", metadata={"step_id": "nfo_scan"} ) return # Execute the NFO scan try: # Ensure any newly created series are loaded from DB into SeriesApp memory await _load_series_into_memory(progress_service=None) await _execute_nfo_scan(progress_service) await _mark_nfo_scan_completed() except Exception as e: logger.error("Failed to complete NFO scan: %s", e, exc_info=True) if progress_service: try: await progress_service.fail_progress( progress_id="nfo_scan", error_message=f"NFO scan failed: {str(e)}", metadata={"step_id": "nfo_scan"} ) except Exception as fail_err: logger.warning( "Could not fail progress 'nfo_scan': %s", fail_err, exc_info=True ) async def perform_nfo_scan_phase(progress_service=None): """Perform the NFO scan phase as part of the second loading page phase. This is called when the loading page is accessed with ?phase=nfo query param. It runs the NFO scan and emits progress updates via the progress service. Args: progress_service: Optional ProgressService for emitting updates """ logger.info("Starting NFO scan phase...") if progress_service: from src.server.services.progress_service import ProgressType await progress_service.start_progress( progress_id="nfo_scan", progress_type=ProgressType.SCAN, title="Scanning NFO Files", total=100, message="Starting NFO scan...", metadata={"step_id": "nfo_scan", "phase": "nfo"} ) # Check if NFO scan was already completed is_nfo_scan_done = await _check_nfo_scan_status() # Check if NFO features are configured if not await _is_nfo_scan_configured(): message = ( "Skipped - TMDB API key not configured" if not settings.tmdb_api_key else "Skipped - NFO features disabled" ) logger.info("NFO scan phase skipped: %s", message) if progress_service: await progress_service.complete_progress( progress_id="nfo_scan", message=message, metadata={"step_id": "nfo_scan", "phase": "nfo", "nfo_scan_complete": True} ) return # Skip if already completed if is_nfo_scan_done: logger.info("Skipping NFO scan phase - already completed on previous run") if progress_service: await progress_service.complete_progress( progress_id="nfo_scan", message="Already completed", metadata={"step_id": "nfo_scan", "phase": "nfo", "nfo_scan_complete": True} ) return # Execute the NFO scan try: # Ensure any newly created series (e.g., from resolving unresolved folders) # are loaded from DB into SeriesApp memory before scanning await _load_series_into_memory(progress_service=None) await _execute_nfo_scan(progress_service) await _mark_nfo_scan_completed() # Send completion event if progress_service: await progress_service.complete_progress( progress_id="nfo_scan", message="NFO scan completed successfully", metadata={"step_id": "nfo_scan", "phase": "nfo", "nfo_scan_complete": True} ) logger.info("NFO scan phase completed successfully") except Exception as e: logger.error("Failed to complete NFO scan phase: %s", e, exc_info=True) if progress_service: try: await progress_service.fail_progress( progress_id="nfo_scan", error_message=f"NFO scan failed: {str(e)}", metadata={"step_id": "nfo_scan", "phase": "nfo"} ) except Exception as fail_err: logger.warning( "Could not fail progress 'nfo_scan': %s", fail_err, exc_info=True ) async def _check_media_scan_status() -> bool: """Check if initial media scan has been completed. Returns: bool: True if media scan was completed, False otherwise """ return await _check_scan_status( check_method=lambda svc, db: svc.is_initial_media_scan_completed(db), scan_type="media" ) async def _mark_media_scan_completed() -> None: """Mark the initial media scan as completed in system settings.""" await _mark_scan_completed( mark_method=lambda svc, db: svc.mark_initial_media_scan_completed(db), scan_type="media" ) async def _execute_media_scan(background_loader) -> None: """Execute the actual media scan and queue background loading. Args: background_loader: The background loader service instance Raises: Exception: If media scan fails """ from src.server.fastapi_app import _check_incomplete_series_on_startup logger.info("Performing initial media scan...") await _check_incomplete_series_on_startup(background_loader) logger.info("Initial media scan completed") async def perform_media_scan_if_needed(background_loader): """Perform initial media scan if not yet completed. Args: background_loader: The background loader service instance """ # Check if media scan was already completed is_media_scan_done = await _check_media_scan_status() if is_media_scan_done: logger.info("Skipping media scan - already completed on previous run") return # Execute the media scan try: await _execute_media_scan(background_loader) await _mark_media_scan_completed() except Exception as e: logger.error("Failed to complete media scan: %s", e, exc_info=True)