feat: Add AGENTS.md and new downloaders with metadata enrichment

- Add AGENTS.md for agentic coding guidelines
- Add Oneupload and Smoothpre video player downloaders
- Add MetadataEnrichment service with Kitsu API fallback
- Add tests for metadata enrichment and provider detection
- Update .gitignore to ignore runtime config files

.gitignore

@@ -45,3 +45,12 @@ favorites.json
 *.db
 *.sqlite
 ohm_streaming.db
+
+# Config (runtime-generated)
+config/anime_sama_domain.json
+config/metadata_cache.json
+data/
+favorites.json
+*.db
+*.sqlite
+ohm_streaming.db

AGENTS.md

@@ -0,0 +1,182 @@
+# AGENTS.md - Agentic Coding Guidelines
+
+This file provides guidance for AI agents working in this repository.
+
+## Quick Start
+
+```bash
+# Setup
+python3 -m venv venv && source venv/bin/activate
+pip install -r requirements.txt
+
+# Run dev server
+uvicorn main:app --reload --host 0.0.0.0 --port 3000
+```
+
+## Build, Lint & Test Commands
+
+### Running Tests
+
+```bash
+# All tests
+pytest
+
+# With coverage
+pytest --cov=app --cov-report=html
+
+# Unit only (fast)
+pytest -m "unit"
+
+# Exclude slow tests
+pytest -m "not slow"
+
+# Verbose with print debugging
+pytest -v -s
+```
+
+### Running Single Tests
+
+```bash
+# Specific file
+pytest tests/test_sonarr.py -v
+
+# Specific class
+pytest tests/test_sonarr.py::TestSonarrHandler -v
+
+# Specific test
+pytest tests/test_sonarr.py::TestSonarrHandler::test_add_mapping -v
+
+# Pattern match
+pytest -k "test_download" -v
+```
+
+## Code Style
+
+### Imports (PEP 8 order)
+1. Standard library (`os`, `json`, `asyncio`)
+2. Third-party (`httpx`, `beautifulsoup4`, `fastapi`)
+3. Local app (`app.config`, `app.utils`)
+
+```python
+import os
+import asyncio
+from typing import Optional
+
+import httpx
+from fastapi import APIRouter, HTTPException
+
+from app.config import get_settings
+from app.models import DownloadTask, DownloadStatus
+```
+
+### Formatting
+- **Line length**: 120 chars max
+- **Indentation**: 4 spaces
+- **Blank lines**: 2 between top-level, 1 between inline
+
+### Type Annotations
+- Use explicit types
+- Use `Optional[X]` not `X | None`
+- Use `list[X]`, `dict[X, Y]`
+
+```python
+# Good
+async def get_download_link(url: str, target_filename: Optional[str] = None) -> tuple[str, str]:
+    results: list[dict[str, str]] = []
+
+# Avoid
+async def get_download_link(url, target_filename=None):
+    results = []
+```
+
+### Naming Conventions
+
+| Element | Convention | Example |
+|---------|------------|---------|
+| Modules | snake_case | `download_manager.py` |
+| Classes | PascalCase | `DownloadManager` |
+| Functions | snake_case | `get_download_link()` |
+| Constants | UPPER_SNAKE | `MAX_PARALLEL_DOWNLOADS` |
+| Variables | snake_case | `download_task` |
+| Enums | PascalCase | `DownloadStatus` |
+| Enum values | UPPER_SNAKE | `DownloadStatus.PENDING` |
+
+### Async/Await
+- Always use for I/O operations
+- Close clients properly to avoid leaks
+
+```python
+async def close(self):
+    await self.client.aclose()
+```
+
+### Error Handling
+- Use try/except for recoverable errors
+- Raise specific exceptions (`HTTPException`, `ValueError`)
+- Never use empty except blocks
+- Log errors appropriately
+
+```python
+try:
+    result = await client.get(url)
+except httpx.TimeoutException:
+    logger.warning(f"Request timeout for {url}")
+    raise HTTPException(status_code=504, detail="Request timeout")
+```
+
+### File Operations
+- Always sanitize filenames: `app.utils.sanitize_filename()`
+- Validate paths: `app.utils.is_safe_filename()`
+
+### Testing
+- Use pytest with pytest-asyncio
+- Mark tests: `@pytest.mark.unit`, `@pytest.mark.integration`
+- Use fixtures from `tests/conftest.py`
+
+```python
+@pytest.mark.unit
+@pytest.mark.asyncio
+async def test_download_manager():
+    manager = DownloadManager(max_parallel=3)
+    assert manager.max_parallel == 3
+```
+
+### Security
+- Never hardcode secrets - use environment variables
+- Validate all inputs (URLs, filenames)
+- Use HMAC for webhook verification when configured
+- Limit CORS origins - never use `*` in production
+
+## Architecture Patterns
+
+**Three-Tier Downloader:**
+1. `app/downloaders/anime_sites/` - Anime catalogs
+2. `app/downloaders/series_sites/` - TV series catalogs  
+3. `app/downloaders/video_players/` - File hosting
+
+Each has base class and factory. When adding providers:
+1. Inherit from appropriate base class
+2. Implement required methods
+3. Register in factory
+4. Add to providers config in `app/providers.py`
+
+**URL Convention**: Pipe-separated format preserves metadata:
+```
+video_url|anime_page_url|episode_title
+```
+
+## Key Files
+
+| File | Purpose |
+|------|---------|
+| `main.py` | FastAPI app, endpoints |
+| `app/config.py` | Pydantic Settings |
+| `app/download_manager.py` | Download queue |
+| `app/utils.py` | sanitize_filename |
+| `app/auth.py` | JWT auth |
+| `app/models/__init__.py` | Pydantic models |
+
+## Configuration
+
+- Use `.env` from `.env.example`
+- JWT_SECRET_KEY must change in production

CLAUDE.md

@@ -281,7 +281,54 @@ The downloaders are organized into three categories with separate base classes:
 - Provides enriched metadata (synopsis, genres, ratings, poster images)
 - Used as fallback when provider metadata is incomplete
 
-### 10. Pydantic Models (`app/models/`)
+### 10. Watchlist & Auto-Download System
+
+**WatchlistManager** (`app/watchlist.py`):
+- JSON-based storage in `config/watchlist.json`
+- Per-user watchlist management (multi-tenant)
+- CRUD operations for tracked anime
+- Statistics and queries
+- Settings management in `config/watchlist_settings.json`
+
+**EpisodeChecker** (`app/episode_checker.py`):
+- Checks for new episodes for anime in watchlist
+- Downloads episodes automatically when detected
+- Integrates with existing downloaders
+- Handles errors and retries
+- Lazy initialization to avoid circular imports
+
+**AutoDownloadScheduler** (`app/auto_download_scheduler.py`):
+- APScheduler-based periodic checking
+- Configurable intervals (1-168 hours)
+- Start/stop control via API
+- Next run tracking
+- Background task execution
+
+**Watchlist Models** (`app/models/watchlist.py`):
+- `WatchlistItem` - Tracked anime with settings
+- `WatchlistStatus` - ACTIVE, PAUSED, COMPLETED, ARCHIVED
+- `QualityPreference` - AUTO, 1080p, 720p, 480p
+- `WatchlistSettings` - Global configuration
+- `AutoDownloadResult` - Operation results
+
+**Watchlist Endpoints:**
+- `GET /api/watchlist` - List user's watchlist (with status filter)
+- `POST /api/watchlist` - Add anime to watchlist
+- `GET /api/watchlist/{item_id}` - Get specific item
+- `PUT /api/watchlist/{item_id}` - Update watchlist item
+- `DELETE /api/watchlist/{item_id}` - Remove from watchlist
+- `POST /api/watchlist/{item_id}/check` - Check specific anime
+- `POST /api/watchlist/check-all` - Check all due items
+- `POST /api/watchlist/{item_id}/pause` - Pause tracking
+- `POST /api/watchlist/{item_id}/resume` - Resume tracking
+- `GET /api/watchlist/settings` - Get global settings
+- `PUT /api/watchlist/settings` - Update settings
+- `GET /api/watchlist/stats` - Get watchlist statistics
+- `GET /api/watchlist/scheduler/status` - Get scheduler status
+- `POST /api/watchlist/scheduler/start` - Start scheduler
+- `POST /api/watchlist/scheduler/stop` - Stop scheduler
+
+### 11. Pydantic Models (`app/models/`)
 - **`__init__.py`** - Core models:
   - `DownloadStatus` - Enum for task states (PENDING, DOWNLOADING, PAUSED, COMPLETED, FAILED, CANCELLED)
   - `HostType` - Enum for file host types (RAPIDFILE, UNFICHIER, DOODSTREAM, OTHER)
@@ -294,6 +341,17 @@ The downloaders are organized into three categories with separate base classes:
   - `SonarrEventType` - Enum for event types (Grab, Download, Rename, Delete, Test)
   - `SonarrMapping` - Mapping between Sonarr series and anime providers
   - `SonarrConfig` - Webhook configuration (enabled, secret, auto-download, etc.)
+- **`auth.py`** - Authentication models:
+  - `UserCreate` - User registration request
+  - `UserLogin` - Login request
+  - `User` - User profile
+  - `Token` - JWT token response
+- **`watchlist.py`** - Watchlist models:
+  - `WatchlistItem` - Tracked anime item
+  - `WatchlistItemCreate` - Create request
+  - `WatchlistItemUpdate` - Update request
+  - `WatchlistStatus` - Status enum
+  - `WatchlistSettings` - Global settings
 
 ## Test Structure
 
@@ -521,6 +579,8 @@ JWT_SECRET_KEY=change-me-in-production  # JWT signing key for auth
 - `config/users.json` - User authentication database (created automatically)
 - `config/sonarr.json` - Sonarr webhook configuration (created automatically)
 - `config/sonarr_mappings.json` - Sonarr to anime provider mappings (created automatically)
+- `config/watchlist.json` - User watchlist items (created automatically)
+- `config/watchlist_settings.json` - Watchlist global settings (created automatically)
 - `config/.gitkeep` - Ensures config directory is tracked in git
 - Example files: `config/sonarr.example.json`, `config/sonarr_mappings.example.json`
 
@@ -530,6 +590,27 @@ JWT_SECRET_KEY=change-me-in-production  # JWT signing key for auth
 - `docs/SONARR_INTEGRATION.md` - Complete Sonarr setup guide
 - `docs/SONARR_IMPLEMENTATION.md` - Technical implementation summary
 - `docs/IMPROVEMENTS_2024-01-24.md` - Recent security and quality improvements
+- `docs/WATCHLIST_AUTO_DOWNLOAD.md` - Watchlist system documentation
+
+## Security
+
+**Filename Sanitization (`app/utils.py`):**
+- `sanitize_filename()` - Removes dangerous characters (`\ / : * ? " < > |`)
+- `is_safe_filename()` - Validates against path traversal patterns
+- Used throughout the codebase for all file operations
+- Prevents `../../../etc/passwd` style attacks
+- Limits filename length to 255 characters
+
+**CORS Configuration:**
+- Restricted origins (not `*`) in production
+- Specific allowed methods (GET, POST, PUT, DELETE, PATCH, OPTIONS)
+- Configured in `main.py` via environment variables
+
+**Authentication:**
+- JWT token-based authentication with 7-day expiration
+- bcrypt password hashing with passlib
+- Passwords truncated to 72 bytes (bcrypt limitation)
+- Credentials stored in `config/users.json`
 
 ## Key Implementation Details
 
@@ -570,9 +651,14 @@ JWT_SECRET_KEY=change-me-in-production  # JWT signing key for auth
 - beautifulsoup4, lxml - HTML parsing
 - aiofiles - Async file operations
 - jieba - Chinese text segmentation for fuzzy search
+- passlib[bcrypt] - Password hashing
+- python-jose[cryptography] - JWT token handling
+- apscheduler - Task scheduling for auto-download
 
 **Testing:**
 - pytest - Test framework
 - pytest-asyncio - Async test support
 - pytest-cov - Coverage reporting
 - pytest-mock - Mocking support
+- pytest-timeout - Test timeout handling
+- pytest-html - HTML test reports

app/auth.py

@@ -7,6 +7,8 @@ from datetime import datetime, timedelta
 from typing import Optional, Dict
 from passlib.context import CryptContext
 import logging
+from fastapi import HTTPException
+from fastapi.security import HTTPAuthorizationCredentials
 
 logger = logging.getLogger(__name__)
 
@@ -42,11 +44,12 @@ class UserManager:
             self.users = {}
 
     def _save_users(self):
-        """Save users to JSON file"""
         try:
             os.makedirs(os.path.dirname(self.db_file), exist_ok=True)
-            with open(self.db_file, 'w', encoding='utf-8') as f:
+            temp_file = f"{self.db_file}.tmp"
+            with open(temp_file, 'w', encoding='utf-8') as f:
                 json.dump(self.users, f, indent=2, ensure_ascii=False, default=str)
+            os.replace(temp_file, self.db_file)
             logger.info(f"Saved {len(self.users)} users to database")
         except Exception as e:
             logger.error(f"Error saving users: {e}")
@@ -162,9 +165,15 @@ def verify_token(token: str) -> Optional[str]:
         return None
 
 
-def get_current_user(token: str) -> Optional[dict]:
+def get_current_user(credentials: HTTPAuthorizationCredentials) -> dict:
     """Get current user from JWT token"""
+    token = credentials.credentials
     username = verify_token(token)
     if username:
-        return user_manager.get_user(username)
-    return None
+        user = user_manager.get_user(username)
+        if not user:
+            raise HTTPException(status_code=401, detail="User not found")
+        if not user.get("is_active", True):
+            raise HTTPException(status_code=401, detail="Inactive user")
+        return user
+    raise HTTPException(status_code=401, detail="Invalid authentication credentials")

app/auto_download_scheduler.py

@@ -0,0 +1,154 @@
+"""Scheduler for automatic episode checking and downloading"""
+import asyncio
+import logging
+from datetime import datetime
+from typing import Optional
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.interval import IntervalTrigger
+
+from app.watchlist import watchlist_manager, WatchlistManager
+from app.episode_checker import EpisodeChecker, episode_checker
+
+logger = logging.getLogger(__name__)
+
+
+class AutoDownloadScheduler:
+    """Manages automatic episode checking and downloading on a schedule"""
+
+    def __init__(
+        self,
+        wlm: Optional[WatchlistManager] = None,
+        checker: Optional[EpisodeChecker] = None
+    ):
+        self.wlm = wlm or watchlist_manager
+        self.checker = checker or episode_checker
+        self.scheduler: Optional[AsyncIOScheduler] = None
+        self._running = False
+
+    async def _check_job(self):
+        """Job function that runs periodically to check for new episodes"""
+        try:
+            logger.info("Running scheduled episode check...")
+            results = await self.checker.check_all_due()
+
+            # Log summary
+            for result in results:
+                if result.new_episodes_found > 0:
+                    logger.info(
+                        f"✓ {result.anime_title}: "
+                        f"{result.new_episodes_found} new, "
+                        f"{len(result.episodes_downloaded)} downloaded"
+                    )
+
+            logger.info(f"Scheduled check complete: processed {len(results)} items")
+
+        except Exception as e:
+            logger.error(f"Error in scheduled check job: {e}", exc_info=True)
+
+    def start(self):
+        """Start the scheduler"""
+        if self._running:
+            logger.warning("Scheduler already running")
+            return
+
+        try:
+            self.scheduler = AsyncIOScheduler()
+
+            # Get initial check interval from settings
+            settings = self.wlm.get_settings()
+            interval_hours = settings.check_interval_hours
+
+            # Add the job
+            self.scheduler.add_job(
+                self._check_job,
+                trigger=IntervalTrigger(hours=interval_hours),
+                id='episode_check',
+                name='Check for new episodes',
+                replace_existing=True
+            )
+
+            # Start the scheduler
+            self.scheduler.start()
+            self._running = True
+
+            logger.info(
+                f"Auto-download scheduler started (checking every {interval_hours}h)"
+            )
+
+        except Exception as e:
+            logger.error(f"Error starting scheduler: {e}", exc_info=True)
+            raise
+
+    def stop(self):
+        """Stop the scheduler"""
+        if not self._running:
+            logger.warning("Scheduler not running")
+            return
+
+        try:
+            if self.scheduler:
+                self.scheduler.shutdown(wait=False)
+                self.scheduler = None
+
+            self._running = False
+            logger.info("Auto-download scheduler stopped")
+
+        except Exception as e:
+            logger.error(f"Error stopping scheduler: {e}", exc_info=True)
+
+    def restart(self):
+        """Restart the scheduler with updated settings"""
+        logger.info("Restarting scheduler with new settings...")
+        self.stop()
+        self.start()
+
+    def update_interval(self, hours: int):
+        """Update the check interval"""
+        if not self._running:
+            logger.warning("Scheduler not running, interval will be applied on start")
+            return
+
+        try:
+            settings = self.wlm.get_settings()
+            settings.check_interval_hours = hours
+            self.wlm.update_settings(settings)
+
+            # Restart to apply new interval
+            self.restart()
+
+            logger.info(f"Updated check interval to {hours}h")
+
+        except Exception as e:
+            logger.error(f"Error updating interval: {e}", exc_info=True)
+
+    def get_next_run_time(self) -> Optional[datetime]:
+        """Get the next scheduled run time"""
+        if not self._running or not self.scheduler:
+            return None
+
+        try:
+            job = self.scheduler.get_job('episode_check')
+            if job:
+                return job.next_run_time
+        except Exception as e:
+            logger.error(f"Error getting next run time: {e}")
+
+        return None
+
+    def is_running(self) -> bool:
+        """Check if scheduler is running"""
+        return self._running
+
+    async def trigger_check_now(self):
+        """Manually trigger an episode check now"""
+        logger.info("Manually triggering episode check...")
+        try:
+            await self._check_job()
+        except Exception as e:
+            logger.error(f"Error in manual check: {e}", exc_info=True)
+            raise
+
+
+# Global scheduler instance
+auto_download_scheduler = AutoDownloadScheduler()

app/downloaders/anime_sites/animesama.py

@@ -2,8 +2,11 @@ from .base import BaseAnimeSite
 from bs4 import BeautifulSoup
 import re
 import httpx
+import logging
 from urllib.parse import urljoin, unquote
 
+logger = logging.getLogger(__name__)
+
 
 class AnimeSamaDownloader(BaseAnimeSite):
     """Downloader for anime-sama.org / anime-sama.store"""
@@ -34,7 +37,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     from urllib.parse import urlparse
                     parsed = urlparse(href)
                     domain = parsed.netloc  # e.g., 'anime-sama.si'
-                    print(f"[ANIME-SAMA] Current domain from anime-sama.pw: {domain}")
+                    logger.info(f"Current domain from anime-sama.pw: {domain}")
                     return domain
 
                 # Fallback: look for any anime-sama.* link
@@ -45,14 +48,14 @@ class AnimeSamaDownloader(BaseAnimeSite):
                         parsed = urlparse(href)
                         domain = parsed.netloc
                         if domain not in ['anime-sama.pw', 'www.anime-sama.pw']:
-                            print(f"[ANIME-SAMA] Found domain via fallback: {domain}")
+                            logger.info(f"Found domain via fallback: {domain}")
                             return domain
 
-                print("[ANIME-SAMA] Could not determine current domain, using default")
+                logger.warning("Could not determine current domain, using default")
                 return "anime-sama.si"
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Error fetching current domain: {e}")
+            logger.error(f"Error fetching current domain: {e}")
             return "anime-sama.si"
 
     @classmethod
@@ -73,10 +76,10 @@ class AnimeSamaDownloader(BaseAnimeSite):
                 if domain not in cls.BASE_DOMAINS:
                     # Insert at the beginning for priority
                     cls.BASE_DOMAINS.insert(0, domain)
-                    print(f"[ANIME-SAMA] Added new domain: {domain}")
+                    logger.info(f"Added new domain: {domain}")
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Error updating domains: {e}")
+            logger.error(f"Error updating domains: {e}")
 
     def can_handle(self, url: str) -> bool:
         return any(domain in url.lower() for domain in self.BASE_DOMAINS)
@@ -88,7 +91,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
         We'll try to extract the video URL from these hosts
         """
         try:
-            print(f"[ANIME-SAMA] Extracting link from: {url}")
+            logger.debug(f"Extracting link from: {url}")
 
             # Check if URL contains the anime page context (format: video_url|anime_page_url|episode_title?)
             if '|' in url:
@@ -97,7 +100,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
                 anime_page_url = parts[1] if len(parts) > 1 else None
                 episode_title = parts[2] if len(parts) > 2 else None
 
-                print(f"[ANIME-SAMA] Split URL - video: {video_url[:60]}..., anime: {anime_page_url}, episode: {episode_title}")
+                logger.debug(f"Split URL - video: {video_url[:60]}..., anime: {anime_page_url}, episode: {episode_title}")
 
                 # Extract video from the host URL with anime context for filename
                 if 'vidmoly.to' in video_url or 'vidmoly' in video_url:
@@ -122,28 +125,28 @@ class AnimeSamaDownloader(BaseAnimeSite):
 
             # If it's an anime-sama page, try to find the video
             if 'anime-sama' in url.lower():
-                print(f"[ANIME-SAMA] Processing anime-sama page: {url}")
+                logger.debug(f"Processing anime-sama page: {url}")
                 response = await self.client.get(url, follow_redirects=True)
                 final_url = str(response.url)
                 soup = BeautifulSoup(response.text, 'lxml')
 
-                print(f"[ANIME-SAMA] Final URL after redirects: {final_url}")
+                logger.debug(f"Final URL after redirects: {final_url}")
 
                 # Look for iframe with video player
                 iframes = soup.find_all('iframe')
-                print(f"[ANIME-SAMA] Found {len(iframes)} iframes")
+                logger.debug(f"Found {len(iframes)} iframes")
 
                 for iframe in iframes:
                     src = iframe.get('src', '')
                     if src and any(provider in src for provider in ['vidmoly', 'player', 'stream', 'play', 'embed']):
                         if not src.startswith('http'):
                             src = urljoin(final_url, src)
-                        print(f"[ANIME-SAMA] Found iframe: {src}")
+                        logger.debug(f"Found iframe: {src}")
                         # Try to extract video from the player
                         try:
                             # For vidmoly, extract and return the video URL directly
                             if 'vidmoly' in src:
-                                print(f"[ANIME-SAMA] Extracting from vidmoly iframe: {src}")
+                                logger.debug(f"Extracting from vidmoly iframe: {src}")
                                 video_url, filename = await self._extract_from_vidmoly(src, anime_page_url=url, episode_title="Episode")
                                 return video_url, filename
                             else:
@@ -152,12 +155,12 @@ class AnimeSamaDownloader(BaseAnimeSite):
                                     filename = self._generate_filename(final_url)
                                     return video_url, filename
                         except Exception as e:
-                            print(f"[ANIME-SAMA] Error extracting from iframe: {e}")
+                            logger.debug(f"Error extracting from iframe: {e}")
                             continue
 
                 # Look for video tags
                 videos = soup.find_all('video')
-                print(f"[ANIME-SAMA] Found {len(videos)} video tags")
+                logger.debug(f"Found {len(videos)} video tags")
                 for video in videos:
                     src = video.get('src', '')
                     if src:
@@ -177,8 +180,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
 
                 # If we couldn't find video in iframe, the page structure might have changed
                 # Save HTML for debugging
-                print(f"[ANIME-SAMA] Could not find video link on page. HTML snippet:")
-                print(soup.prettify()[:1000])
+                logger.debug(f"Could not find video link on page. HTML snippet:\n{soup.prettify()[:1000]}")
 
             raise Exception("Could not find video link on page")
 
@@ -188,8 +190,8 @@ class AnimeSamaDownloader(BaseAnimeSite):
     async def _extract_from_vidmoly(self, url: str, anime_page_url: str = None, episode_title: str = None) -> tuple[str, str]:
         """Extract video URL from vidmoly player - delegate to VidMolyDownloader"""
         try:
-            print(f"[ANIME-SAMA] Extracting from vidmoly: {url}")
-            print(f"[ANIME-SAMA] Delegating to VidMolyDownloader...")
+            logger.debug(f"Extracting from vidmoly: {url}")
+            logger.debug(f"Delegating to VidMolyDownloader...")
 
             # Import VidMolyDownloader
             from ..video_players.vidmoly import VidMolyDownloader
@@ -202,13 +204,13 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     target_filename = f"{anime_name} - S{season_num} - {episode_title}.mp4"
                 else:
                     target_filename = f"{anime_name} - {episode_title}.mp4"
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (episode: {episode_title})")
+                logger.debug(f"Generated filename: {target_filename} (episode: {episode_title})")
             elif anime_page_url:
                 target_filename = self._generate_filename_from_anime_url(anime_page_url)
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (no episode title)")
+                logger.debug(f"Generated filename: {target_filename} (no episode title)")
             else:
                 target_filename = None
-                print(f"[ANIME-SAMA] No target_filename generated")
+                logger.debug(f"No target_filename generated")
 
             # Use VidMolyDownloader to extract and download
             vidmoly_downloader = VidMolyDownloader()
@@ -222,7 +224,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
             # Use the target filename
             filename = target_filename if target_filename else temp_filename
 
-            print(f"[ANIME-SAMA] Got video: {filename}")
+            logger.debug(f"Got video: {filename}")
 
             # Rename the file if needed
             import os
@@ -235,23 +237,23 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     if os.path.exists(final_path):
                         os.remove(final_path)
                     os.rename(temp_path, final_path)
-                    print(f"[ANIME-SAMA] Renamed {temp_filename} -> {filename}")
+                    logger.debug(f"Renamed {temp_filename} -> {filename}")
                 else:
-                    print(f"[ANIME-SAMA] Warning: temp file not found: {temp_path}")
+                    logger.debug(f"Warning: temp file not found: {temp_path}")
 
             # Return the video_url from VidMoly extractor (local path for M3U8, or URL for MP4)
             # NOT the original VidMoly embed URL!
             return video_url, filename
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Vidmoly extraction error: {e}")
+            logger.debug(f"Vidmoly extraction error: {e}")
             raise Exception(f"Error extracting from vidmoly: {str(e)}")
 
     async def _extract_from_sendvid(self, url: str, anime_page_url: str = None, episode_title: str = None) -> tuple[str, str]:
         """Extract video URL from sendvid player - delegate to SendVidDownloader"""
         try:
-            print(f"[ANIME-SAMA] Extracting from sendvid: {url}")
-            print(f"[ANIME-SAMA] Delegating to SendVidDownloader...")
+            logger.debug(f"Extracting from sendvid: {url}")
+            logger.debug(f"Delegating to SendVidDownloader...")
 
             # Import SendVidDownloader
             from ..video_players.sendvid import SendVidDownloader
@@ -264,13 +266,13 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     target_filename = f"{anime_name} - S{season_num} - {episode_title}.mp4"
                 else:
                     target_filename = f"{anime_name} - {episode_title}.mp4"
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (episode: {episode_title})")
+                logger.debug(f"Generated filename: {target_filename} (episode: {episode_title})")
             elif anime_page_url:
                 target_filename = self._generate_filename_from_anime_url(anime_page_url)
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (no episode title)")
+                logger.debug(f"Generated filename: {target_filename} (no episode title)")
             else:
                 target_filename = None
-                print(f"[ANIME-SAMA] No target_filename generated")
+                logger.debug(f"No target_filename generated")
 
             # Use SendVidDownloader to extract the video URL
             sendvid_downloader = SendVidDownloader()
@@ -284,21 +286,21 @@ class AnimeSamaDownloader(BaseAnimeSite):
             # Use the target filename
             filename = target_filename if target_filename else filename
 
-            print(f"[ANIME-SAMA] Got video: {filename}")
+            logger.debug(f"Got video: {filename}")
 
             # Return the direct video URL (SendVid provides direct MP4 links)
             # The download_manager will handle the actual download
             return video_url, filename
 
         except Exception as e:
-            print(f"[ANIME-SAMA] SendVid extraction error: {e}")
+            logger.debug(f"SendVid extraction error: {e}")
             raise Exception(f"Error extracting from sendvid: {str(e)}")
 
     async def _extract_from_sibnet(self, url: str, anime_page_url: str = None, episode_title: str = None) -> tuple[str, str]:
         """Extract video URL from sibnet player - delegate to SibnetDownloader"""
         try:
-            print(f"[ANIME-SAMA] Extracting from sibnet: {url}")
-            print(f"[ANIME-SAMA] Delegating to SibnetDownloader...")
+            logger.debug(f"Extracting from sibnet: {url}")
+            logger.debug(f"Delegating to SibnetDownloader...")
 
             # Import SibnetDownloader
             from ..video_players.sibnet import SibnetDownloader
@@ -311,13 +313,13 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     target_filename = f"{anime_name} - S{season_num} - {episode_title}.mp4"
                 else:
                     target_filename = f"{anime_name} - {episode_title}.mp4"
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (episode: {episode_title})")
+                logger.debug(f"Generated filename: {target_filename} (episode: {episode_title})")
             elif anime_page_url:
                 target_filename = self._generate_filename_from_anime_url(anime_page_url)
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (no episode title)")
+                logger.debug(f"Generated filename: {target_filename} (no episode title)")
             else:
                 target_filename = None
-                print(f"[ANIME-SAMA] No target_filename generated")
+                logger.debug(f"No target_filename generated")
 
             # Use SibnetDownloader to extract the video URL
             sibnet_downloader = SibnetDownloader()
@@ -326,15 +328,15 @@ class AnimeSamaDownloader(BaseAnimeSite):
             # Use the target filename if available
             filename = target_filename if target_filename else temp_filename
 
-            print(f"[ANIME-SAMA] Got video: {filename}")
-            print(f"[ANIME-SAMA] Video URL: {video_url[:100]}...")
+            logger.debug(f"Got video: {filename}")
+            logger.debug(f"Video URL: {video_url[:100]}...")
 
             # Return the direct video URL (Sibnet provides direct MP4 links)
             # The download_manager will handle the actual download
             return video_url, filename
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Sibnet extraction error: {e}")
+            logger.debug(f"Sibnet extraction error: {e}")
             raise Exception(f"Error extracting from sibnet: {str(e)}")
 
     def _generate_filename_from_anime_url(self, anime_url: str) -> str:
@@ -394,8 +396,8 @@ class AnimeSamaDownloader(BaseAnimeSite):
     async def _extract_from_lpayer(self, url: str, anime_page_url: str = None, episode_title: str = None) -> tuple[str, str]:
         """Extract video URL from lpayer player - delegate to LpayerDownloader"""
         try:
-            print(f"[ANIME-SAMA] Extracting from lpayer: {url}")
-            print(f"[ANIME-SAMA] Delegating to LpayerDownloader...")
+            logger.debug(f"Extracting from lpayer: {url}")
+            logger.debug(f"Delegating to LpayerDownloader...")
 
             # Import LpayerDownloader
             from ..video_players.lpayer import LpayerDownloader
@@ -408,13 +410,13 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     target_filename = f"{anime_name} - S{season_num} - {episode_title}.mp4"
                 else:
                     target_filename = f"{anime_name} - {episode_title}.mp4"
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (episode: {episode_title})")
+                logger.debug(f"Generated filename: {target_filename} (episode: {episode_title})")
             elif anime_page_url:
                 target_filename = self._generate_filename_from_anime_url(anime_page_url)
-                print(f"[ANIME-SAMA] Generated filename: {target_filename} (no episode title)")
+                logger.debug(f"Generated filename: {target_filename} (no episode title)")
             else:
                 target_filename = None
-                print(f"[ANIME-SAMA] No target_filename generated")
+                logger.debug(f"No target_filename generated")
 
             # Use LpayerDownloader to extract the video URL
             lpayer_downloader = LpayerDownloader()
@@ -423,15 +425,15 @@ class AnimeSamaDownloader(BaseAnimeSite):
             # Use the target filename if available
             filename = target_filename if target_filename else temp_filename
 
-            print(f"[ANIME-SAMA] Got video: {filename}")
-            print(f"[ANIME-SAMA] Video URL: {video_url[:100] if video_url else 'None'}...")
+            logger.debug(f"Got video: {filename}")
+            logger.debug(f"Video URL: {video_url[:100] if video_url else 'None'}...")
 
             # Return the direct video URL
             # The download_manager will handle the actual download
             return video_url, filename
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Lpayer extraction error: {e}")
+            logger.debug(f"Lpayer extraction error: {e}")
             # Re-raise with clearer message
             raise Exception(f"Lpayer player not supported - this video host requires manual download. Try another host (VidMoly, SendVid, Sibnet). Error: {str(e)}")
 
@@ -494,7 +496,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
         Returns synopsis, genres, rating, release year, studio, etc.
         """
         try:
-            print(f"[ANIME-SAMA] Extracting metadata from: {anime_url}")
+            logger.debug(f"Extracting metadata from: {anime_url}")
             response = await self.client.get(anime_url)
             soup = BeautifulSoup(response.text, 'lxml')
 
@@ -651,11 +653,11 @@ class AnimeSamaDownloader(BaseAnimeSite):
                         metadata['status'] = 'Completed'
                     break
 
-            print(f"[ANIME-SAMA] Extracted metadata: {metadata}")
+            logger.debug(f"Extracted metadata: {metadata}")
             return metadata
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Error extracting metadata: {e}")
+            logger.debug(f"Error extracting metadata: {e}")
             import traceback
             traceback.print_exc()
             return {}
@@ -678,7 +680,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
             import time
             from html import unescape
             start = time.time()
-            print(f"[ANIME-SAMA] Searching for '{query}' ({lang})...")
+            logger.debug(f"Searching for '{query}' ({lang})...")
 
             # Use the current domain from anime-sama.pw
             current_domain = await self.get_current_domain()
@@ -694,7 +696,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
             )
 
             elapsed = time.time() - start
-            print(f"[ANIME-SAMA] Got search response in {elapsed:.2f}s")
+            logger.debug(f"Got search response in {elapsed:.2f}s")
 
             if response.status_code == 200 and response.text.strip():
                 # Parse HTML results
@@ -729,14 +731,14 @@ class AnimeSamaDownloader(BaseAnimeSite):
 
                     results.append(result)
 
-                print(f"[ANIME-SAMA] Found {len(results)} results")
+                logger.debug(f"Found {len(results)} results")
                 return results
 
-            print(f"[ANIME-SAMA] No results found")
+            logger.debug(f"No results found")
             return []
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Search error: {str(e)}")
+            logger.debug(f"Search error: {str(e)}")
             import traceback
             traceback.print_exc()
             return []
@@ -760,7 +762,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
                 # Build the URL to episodes.js
                 episodes_js_url = f"{anime_url.rstrip('/')}/episodes.js?filever={file_ver}"
 
-                print(f"[ANIME-SAMA] Found episodes.js at {episodes_js_url}")
+                logger.debug(f"Found episodes.js at {episodes_js_url}")
 
                 try:
                     # Fetch the episodes.js file
@@ -782,7 +784,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
                         eps1_urls = re.findall(r"'(https?://[^']+)'", eps_matches[0][1])
                         is_format_a = len(eps1_urls) > 10  # More than 10 URLs in eps1 = Format A
 
-                        print(f"[ANIME-SAMA] Detected format {'A (source-based)' if is_format_a else 'B (episode-based)'} - eps1 has {len(eps1_urls)} URLs")
+                        logger.debug(f"Detected format {'A (source-based)' if is_format_a else 'B (episode-based)'} - eps1 has {len(eps1_urls)} URLs")
 
                         # No more host preference! Just collect all available URLs for each episode
                         # The download system will automatically detect and use the appropriate downloader
@@ -828,24 +830,24 @@ class AnimeSamaDownloader(BaseAnimeSite):
                                 'available_hosts': len(available_urls)  # Store count of available hosts
                             })
 
-                        print(f"[ANIME-SAMA] Found {len(episodes)} episodes")
+                        logger.debug(f"Found {len(episodes)} episodes")
                         return episodes
 
                 except Exception as e:
-                    print(f"[ANIME-SAMA] Error fetching episodes.js: {e}")
+                    logger.debug(f"Error fetching episodes.js: {e}")
                     import traceback
                     traceback.print_exc()
 
             # Fallback: Try to find episode links in the HTML (old method)
-            print(f"[ANIME-SAMA] Using fallback method to find episodes in HTML")
+            logger.debug(f"Using fallback method to find episodes in HTML")
 
             # Quick check: look for episode links with limited scope
             episode_links = soup.find_all('a', href=lambda x: x and 'episode-' in x)
-            print(f"[ANIME-SAMA] Found {len(episode_links)} episode links")
+            logger.debug(f"Found {len(episode_links)} episode links")
 
             if not episode_links:
                 # No episodes found in HTML, return empty immediately
-                print(f"[ANIME-SAMA] No episodes found in HTML")
+                logger.debug(f"No episodes found in HTML")
                 return []
 
             for link in episode_links:
@@ -856,7 +858,7 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     if match:
                         episode_num = match.group(1)
                         full_url = urljoin(anime_url, href)
-                        print(f"[ANIME-SAMA] Fallback: Found episode {episode_num} at {full_url}")
+                        logger.debug(f"Fallback: Found episode {episode_num} at {full_url}")
 
                         episodes.append({
                             'episode': episode_num,
@@ -876,13 +878,57 @@ class AnimeSamaDownloader(BaseAnimeSite):
             return unique_episodes
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Error getting episodes: {e}")
+            logger.debug(f"Error getting episodes: {e}")
             return []
 
     async def get_seasons(self, anime_url: str) -> list[dict]:
         """
-        Get list of available seasons for an anime
-        Returns list of seasons with their URLs and episode counts
+        Get list of available seasons for an anime with their episode counts.
+
+        This method uses a two-phase parallel loading strategy for optimal performance:
+
+        **Phase 1: Quick Detection (parallel)**
+        - Check seasons 1-10 in parallel with 3s timeout each
+        - Use asyncio.gather() for concurrent HTTP requests
+        - Only validates URL existence (checks for 'episodes.js' in HTML)
+        - Silent failure on timeout (season likely doesn't exist)
+        - Result: ~3 seconds to check all 10 seasons (vs 30s sequential)
+
+        **Phase 2: Episode Count Fetching (parallel)**
+        - Fetch episode counts ONLY for seasons that exist
+        - Parallel requests to get_episodes() for each valid season
+        - Filters out seasons with zero episodes
+        - Result: Additional ~1-3 seconds depending on number of seasons
+
+        **Performance Characteristics:**
+        - Best case (1 season): ~0.25s (just fetch episodes directly)
+        - Typical case (2-3 seasons): ~3-6s (parallel detection + fetch)
+        - Worst case (10 seasons): ~6-9s (all checks + episode counts)
+        - **200x faster than sequential checking** (50s → 0.25s for 2 seasons)
+
+        **Error Handling:**
+        - TimeoutException: Silent skip (season doesn't exist)
+        - ConnectError: Logged at debug level (network issues)
+        - Other exceptions: Logged at debug level, returns empty list
+        - Seasons with zero episodes are filtered out
+
+        **Args:**
+            anime_url: URL to anime page (e.g., 'https://anime-sama.si/catalogue/frieren/saison1/vostfr/')
+
+        **Returns:**
+            List of season dicts with keys:
+            - season (int): Season number (1, 2, 3, etc.)
+            - title (str): Display title ('Saison 1', 'Saison 2', etc.)
+            - url (str): Full URL to season page
+            - episode_count (int): Number of episodes in this season
+
+        **Example:**
+            >>> seasons = await downloader.get_seasons('https://anime-sama.si/catalogue/frieren/saison1/vostfr/')
+            >>> print(seasons)
+            [
+                {'season': 1, 'title': 'Saison 1', 'url': '...', 'episode_count': 28},
+                {'season': 2, 'title': 'Saison 2', 'url': '...', 'episode_count': 5}
+            ]
         """
         import asyncio
 
@@ -947,9 +993,9 @@ class AnimeSamaDownloader(BaseAnimeSite):
                         # Silent skip - season likely doesn't exist
                         pass
                     except httpx.ConnectError as e:
-                        print(f"[ANIME-SAMA] Connection error checking season {season_num}: {e}")
+                        logger.debug(f"Connection error checking season {season_num}: {e}")
                     except Exception as e:
-                        print(f"[ANIME-SAMA] Unexpected error checking season {season_num}: {e}")
+                        logger.debug(f"Unexpected error checking season {season_num}: {e}")
                     return None
 
                 # Check seasons 1-10 in parallel
@@ -966,19 +1012,19 @@ class AnimeSamaDownloader(BaseAnimeSite):
                     try:
                         episodes = await self.get_episodes(season_info['url'])
                         episode_count = len(episodes) if episodes else 0
-                        print(f"[ANIME-SAMA] Saison {season_info['season']} has {episode_count} episodes")
+                        logger.debug(f"Saison {season_info['season']} has {episode_count} episodes")
                         # Only return seasons that actually have episodes
                         if episode_count > 0:
                             season_info['episode_count'] = episode_count
                             return season_info
                         else:
                             # Skip seasons with no episodes
-                            print(f"[ANIME-SAMA] Skipping Saison {season_info['season']} (no episodes)")
+                            logger.debug(f"Skipping Saison {season_info['season']} (no episodes)")
                             return None
                     except httpx.TimeoutException:
-                        print(f"[ANIME-SAMA] Timeout fetching episodes for season {season_info['season']}")
+                        logger.debug(f"Timeout fetching episodes for season {season_info['season']}")
                     except Exception as e:
-                        print(f"[ANIME-SAMA] Error fetching episodes for season {season_info['season']}: {e}")
+                        logger.debug(f"Error fetching episodes for season {season_info['season']}: {e}")
                     return None
 
                 if seasons:
@@ -1016,20 +1062,20 @@ class AnimeSamaDownloader(BaseAnimeSite):
                                         'episode_count': episode_count
                                     })
                                 else:
-                                    print(f"[ANIME-SAMA] Skipping season {season_num} (no episodes)")
+                                    logger.debug(f"Skipping season {season_num} (no episodes)")
                             except httpx.TimeoutException:
-                                print(f"[ANIME-SAMA] Timeout fetching episodes for season {season_num}")
+                                logger.debug(f"Timeout fetching episodes for season {season_num}")
                             except Exception as e:
-                                print(f"[ANIME-SAMA] Error fetching episodes for season {season_num}: {e}")
+                                logger.debug(f"Error fetching episodes for season {season_num}: {e}")
 
             # Sort by season number
             seasons.sort(key=lambda x: x['season'])
 
-            print(f"[ANIME-SAMA] Found {len(seasons)} seasons for {anime_name}")
+            logger.debug(f"Found {len(seasons)} seasons for {anime_name}")
             return seasons
 
         except Exception as e:
-            print(f"[ANIME-SAMA] Error getting seasons: {e}")
+            logger.debug(f"Error getting seasons: {e}")
             import traceback
             traceback.print_exc()
             return []

app/downloaders/video_players/oneupload.py

@@ -0,0 +1,294 @@
+from .base import BaseVideoPlayer
+from bs4 import BeautifulSoup
+import re
+import asyncio
+from typing import Optional
+
+
+class OneuploadDownloader(BaseVideoPlayer):
+    """Downloader for oneupload.to video player"""
+
+    def can_handle(self, url: str) -> bool:
+        return 'oneupload.to' in url.lower()
+
+    async def get_download_link(self, url: str, target_filename: Optional[str] = None) -> tuple[str, str]:
+        """
+        Extract download link from Oneupload video page
+        Oneupload uses a custom video player with dynamic loading
+
+        Args:
+            url: The Oneupload video page URL
+            target_filename: Optional filename override
+
+        Returns:
+            Tuple of (direct_video_url, filename)
+        """
+        try:
+            print(f"[ONEUPLOAD] Extracting link from: {url}")
+
+            # Try using Playwright first (more reliable for dynamic content)
+            video_url = await self._extract_with_playwright(url)
+
+            if not video_url:
+                # Fallback to HTTP extraction
+                video_url = await self._extract_with_http(url)
+
+            if not video_url:
+                raise Exception("Could not find video URL in Oneupload page")
+
+            print(f"[ONEUPLOAD] Found video URL: {video_url[:80]}...")
+
+            # Generate filename
+            from app.utils import sanitize_filename
+            if target_filename:
+                filename = sanitize_filename(target_filename)
+            else:
+                # Try to extract filename from URL
+                filename = "oneupload_video.mp4"
+
+            return video_url, filename
+
+        except Exception as e:
+            raise Exception(f"Error extracting Oneupload link: {str(e)}")
+
+    async def _extract_with_playwright(self, url: str) -> str | None:
+        """Extract video URL using Playwright with network interception"""
+        try:
+            from playwright.async_api import async_playwright
+
+            print("[ONEUPLOAD] Launching browser with network interception...")
+
+            video_urls = []
+
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(
+                    headless=True,
+                    args=['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
+                )
+
+                context = await browser.new_context(
+                    user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36'
+                )
+
+                page = await context.new_page()
+
+                # Set up response interception
+                async def handle_response(response):
+                    try:
+                        resp_url = response.url
+                        content_type = response.headers.get('content-type', '')
+
+                        # Look for video files in responses
+                        if any(ext in resp_url.lower() for ext in ['.m3u8', '.mp4', '.mkv', '.ts']):
+                            if 'oneupload' not in resp_url.lower() and 'google' not in resp_url.lower():
+                                print(f"[ONEUPLOAD] 🎥 Captured video URL: {resp_url[:100]}...")
+                                video_urls.append(resp_url)
+                        # Also check by content-type
+                        elif any(ct in content_type.lower() for ct in ['video/', 'application/x-mpegurl']):
+                            if 'oneupload' not in resp_url.lower():
+                                print(f"[ONEUPLOAD] 🎥 Captured video response: {resp_url[:100]}...")
+                                video_urls.append(resp_url)
+                    except Exception as e:
+                        pass  # Ignore interception errors
+
+                page.on('response', handle_response)
+
+                print("[ONEUPLOAD] Navigating to page...")
+
+                try:
+                    await page.goto(url, wait_until='networkidle', timeout=30000)
+                except Exception as e:
+                    print(f"[ONEUPLOAD] Navigation warning: {e}")
+
+                # Wait for page to load
+                print("[ONEUPLOAD] Waiting for video player to load...")
+                await asyncio.sleep(3)
+
+                # Try to find and click play button
+                try:
+                    play_selectors = [
+                        'button[aria-label="Play"]',
+                        '.play-button',
+                        'button[class*="play"]',
+                        '.jw-icon-display',
+                        'video',
+                        '.video-wrapper video',
+                    ]
+
+                    for selector in play_selectors:
+                        try:
+                            element = await page.query_selector(selector)
+                            if element:
+                                print(f"[ONEUPLOAD] Found element: {selector}")
+                                if 'button' in selector or 'jw' in selector:
+                                    await element.click()
+                                    await asyncio.sleep(2)
+                                break
+                        except:
+                            continue
+                except Exception as e:
+                    print(f"[ONEUPLOAD] Play button interaction: {e}")
+
+                # Wait more for network requests
+                await asyncio.sleep(4)
+
+                # Try JavaScript extraction
+                try:
+                    js_code = r"""
+                        () => {
+                            // Check for JWPlayer setup
+                            if (window.jwplayer) {
+                                try {
+                                    const playlist = window.jwplayer().getPlaylist();
+                                    if (playlist && playlist[0] && playlist[0].sources) {
+                                        for (let source of playlist[0].sources) {
+                                            if (source.file && (source.file.includes('.m3u8') || source.file.includes('.mp4'))) {
+                                                return source.file;
+                                            }
+                                        }
+                                    }
+                                } catch(e) {}
+                            }
+
+                            // Check all video elements
+                            const videos = document.querySelectorAll('video');
+                            for (let v of videos) {
+                                if (v.src && (v.src.includes('.m3u8') || v.src.includes('.mp4'))) {
+                                    return v.src;
+                                }
+                                const sources = v.querySelectorAll('source');
+                                for (let s of sources) {
+                                    if (s.src && (s.src.includes('.m3u8') || s.src.includes('.mp4'))) {
+                                        return s.src;
+                                    }
+                                }
+                            }
+
+                            // Check window object for video URLs
+                            const searchKeys = ['player', 'video', 'source', 'file', 'url'];
+                            for (let key of searchKeys) {
+                                if (window[key] && typeof window[key] === 'object') {
+                                    try {
+                                        const json = JSON.stringify(window[key]);
+                                        const match = json.match(/(https?:\/\/[^\s"\'<>]+\.(m3u8|mp4))/);
+                                        if (match) return match[1];
+                                    } catch(e) {}
+                                }
+                            }
+
+                            return null;
+                        }
+                    """
+                    js_result = await page.evaluate(js_code)
+
+                    if js_result and ('.m3u8' in js_result or '.mp4' in js_result):
+                        print(f"[ONEUPLOAD] ✅ Found video URL via JavaScript: {js_result[:100]}...")
+                        video_urls.append(js_result)
+                except Exception as e:
+                    print(f"[ONEUPLOAD] JS extraction error: {e}")
+
+                # Parse page HTML for video URLs
+                try:
+                    content = await page.content()
+                    patterns = [
+                        r'"file"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"file"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'(https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*)',
+                        r'(https?://[^\s"\'<>]+\.mp4[^\s"\'<>]*)',
+                        r"url\s*[:=]\s*['\"]([^'\"]+\.m3u8[^'\"]*)['\"]",
+                        r"url\s*[:=]\s*['\"]([^'\"]+\.mp4[^'\"]*)['\"]",
+                    ]
+
+                    for pattern in patterns:
+                        matches = re.findall(pattern, content, re.IGNORECASE)
+                        for match in matches:
+                            # Clean up the URL
+                            match = match.replace('\\/', '/').replace('\\', '')
+                            if 'http' in match and 'oneupload' not in match and 'google' not in match:
+                                print(f"[ONEUPLOAD] Found in HTML: {match[:100]}...")
+                                video_urls.append(match)
+                except Exception as e:
+                    print(f"[ONEUPLOAD] HTML parsing error: {e}")
+
+                await browser.close()
+
+                # Return first valid video URL (prefer .m3u8 over .mp4)
+                if video_urls:
+                    seen = set()
+                    unique_urls = []
+                    for vid_url in video_urls:
+                        if vid_url not in seen:
+                            seen.add(vid_url)
+                            unique_urls.append(vid_url)
+
+                    if unique_urls:
+                        # Sort to prefer .m3u8 (source quality)
+                        unique_urls.sort(key=lambda x: 0 if '.m3u8' in x else 1)
+                        print(f"[ONEUPLOAD] ✅ Found {len(unique_urls)} video URL(s)")
+                        print(f"[ONEUPLOAD] Selected: {unique_urls[0][:100]}...")
+                        return unique_urls[0]
+
+                print("[ONEUPLOAD] ❌ No video URLs found")
+                return None
+
+        except ImportError:
+            print("[ONEUPLOAD] ⚠️ Playwright not installed - using HTTP extraction only")
+            return None
+        except Exception as e:
+            print(f"[ONEUPLOAD] Playwright error: {e}")
+            import traceback
+            traceback.print_exc()
+            return None
+
+    async def _extract_with_http(self, url: str) -> str | None:
+        """Extract video URL using simple HTTP requests"""
+        try:
+            print(f"[ONEUPLOAD] Trying HTTP extraction from: {url}")
+
+            response = await self.client.get(url, follow_redirects=True)
+            soup = BeautifulSoup(response.text, 'lxml')
+
+            # Method 1: Look for video/source tags
+            videos = soup.find_all('video')
+            for video in videos:
+                src = video.get('src') or video.get('data-src')
+                if src and any(ext in src for ext in ['.m3u8', '.mp4']):
+                    print(f"[ONEUPLOAD] ✅ Found video in video tag: {src[:100]}...")
+                    return src
+
+                sources = video.find_all('source')
+                for source in sources:
+                    src = source.get('src')
+                    if src and any(ext in src for ext in ['.m3u8', '.mp4']):
+                        print(f"[ONEUPLOAD] ✅ Found video in source tag: {src[:100]}...")
+                        return src
+
+            # Method 2: Look in script tags for video URLs
+            scripts = soup.find_all('script')
+            for script in scripts:
+                if script.string:
+                    patterns = [
+                        r'"file"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"file"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'(https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*)',
+                        r'(https?://[^\s"\'<>]+\.mp4[^\s"\'<>]*)',
+                    ]
+
+                    for pattern in patterns:
+                        matches = re.findall(pattern, script.string, re.IGNORECASE)
+                        for match in matches:
+                            match = match.replace('\\/', '/')
+                            if 'http' in match and 'oneupload' not in match.lower():
+                                print(f"[ONEUPLOAD] ✅ Found video in script: {match[:100]}...")
+                                return match
+
+            print("[ONEUPLOAD] ❌ HTTP extraction failed - no video URLs found")
+            return None
+
+        except Exception as e:
+            print(f"[ONEUPLOAD] HTTP extraction error: {e}")
+            return None

app/downloaders/video_players/smoothpre.py

@@ -0,0 +1,290 @@
+from .base import BaseVideoPlayer
+from bs4 import BeautifulSoup
+import re
+import asyncio
+from typing import Optional
+
+
+class SmoothpreDownloader(BaseVideoPlayer):
+    """Downloader for smoothpre.com video player (JWPlayer-based)"""
+
+    def can_handle(self, url: str) -> bool:
+        return 'smoothpre.com' in url.lower()
+
+    async def get_download_link(self, url: str, target_filename: Optional[str] = None) -> tuple[str, str]:
+        """
+        Extract download link from Smoothpre video page
+        Smoothpre uses JWPlayer with dynamic JavaScript - requires Playwright
+
+        Args:
+            url: The Smoothpre video page URL
+            target_filename: Optional filename override
+
+        Returns:
+            Tuple of (direct_video_url, filename)
+        """
+        try:
+            print(f"[SMOOTHPRE] Extracting link from: {url}")
+
+            # Try using Playwright to extract video URL
+            video_url = await self._extract_with_playwright(url)
+
+            if not video_url:
+                raise Exception("Could not find video URL in Smoothpre page")
+
+            print(f"[SMOOTHPRE] Found video URL: {video_url[:80]}...")
+
+            # Generate filename
+            from app.utils import sanitize_filename
+            if target_filename:
+                filename = sanitize_filename(target_filename)
+            else:
+                filename = "smoothpre_video.mp4"
+
+            return video_url, filename
+
+        except Exception as e:
+            raise Exception(f"Error extracting Smoothpre link: {str(e)}")
+
+    async def _extract_with_playwright(self, url: str) -> str | None:
+        """Extract video URL using Playwright with network interception"""
+        try:
+            from playwright.async_api import async_playwright
+
+            print("[SMOOTHPRE] Launching browser with network interception...")
+
+            video_urls = []
+
+            async with async_playwright() as p:
+                browser = await p.chromium.launch(
+                    headless=True,
+                    args=['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
+                )
+
+                context = await browser.new_context(
+                    user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36'
+                )
+
+                page = await context.new_page()
+
+                # Set up response interception
+                async def handle_response(response):
+                    try:
+                        resp_url = response.url
+                        content_type = response.headers.get('content-type', '')
+
+                        # Look for video files in responses
+                        if any(ext in resp_url.lower() for ext in ['.m3u8', '.mp4', '.mkv', '.ts']):
+                            if 'smoothpre' not in resp_url.lower() and 'google' not in resp_url.lower():
+                                print(f"[SMOOTHPRE] 🎥 Captured video URL: {resp_url[:100]}...")
+                                video_urls.append(resp_url)
+                        # Also check by content-type
+                        elif any(ct in content_type.lower() for ct in ['video/', 'application/x-mpegurl']):
+                            if 'smoothpre' not in resp_url.lower():
+                                print(f"[SMOOTHPRE] 🎥 Captured video response: {resp_url[:100]}...")
+                                video_urls.append(resp_url)
+                    except Exception as e:
+                        pass  # Ignore interception errors
+
+                page.on('response', handle_response)
+
+                print("[SMOOTHPRE] Navigating to page...")
+
+                try:
+                    await page.goto(url, wait_until='networkidle', timeout=30000)
+                except Exception as e:
+                    print(f"[SMOOTHPRE] Navigation warning: {e}")
+
+                # Wait for page to load
+                print("[SMOOTHPRE] Waiting for video player to load...")
+                await asyncio.sleep(3)
+
+                # Try to find and click play button
+                try:
+                    play_selectors = [
+                        'button[aria-label="Play"]',
+                        '.play-button',
+                        'button[class*="play"]',
+                        '.jw-icon-display',
+                        'video',
+                    ]
+
+                    for selector in play_selectors:
+                        try:
+                            element = await page.query_selector(selector)
+                            if element:
+                                print(f"[SMOOTHPRE] Found element: {selector}")
+                                if 'button' in selector or 'jw' in selector:
+                                    await element.click()
+                                    await asyncio.sleep(2)
+                                break
+                        except:
+                            continue
+                except Exception as e:
+                    print(f"[SMOOTHPRE] Play button interaction: {e}")
+
+                # Wait more for network requests
+                await asyncio.sleep(4)
+
+                # Try JavaScript extraction - JWPlayer specific
+                try:
+                    js_code = r"""
+                        () => {
+                            // Check for JWPlayer setup (primary method for Smoothpre)
+                            if (window.jwplayer) {
+                                try {
+                                    const playlist = window.jwplayer().getPlaylist();
+                                    if (playlist && playlist[0] && playlist[0].sources) {
+                                        for (let source of playlist[0].sources) {
+                                            if (source.file && (source.file.includes('.m3u8') || source.file.includes('.mp4'))) {
+                                                return source.file;
+                                            }
+                                        }
+                                    }
+                                } catch(e) {}
+                            }
+
+                            // Check all video elements
+                            const videos = document.querySelectorAll('video');
+                            for (let v of videos) {
+                                if (v.src && (v.src.includes('.m3u8') || v.src.includes('.mp4'))) {
+                                    return v.src;
+                                }
+                                const sources = v.querySelectorAll('source');
+                                for (let s of sources) {
+                                    if (s.src && (s.src.includes('.m3u8') || s.src.includes('.mp4'))) {
+                                        return s.src;
+                                    }
+                                }
+                            }
+
+                            // Check window object for video URLs
+                            const searchKeys = ['player', 'video', 'source', 'file', 'url', 'jw'];
+                            for (let key of searchKeys) {
+                                if (window[key] && typeof window[key] === 'object') {
+                                    try {
+                                        const json = JSON.stringify(window[key]);
+                                        const match = json.match(/(https?:\/\/[^\s"\'<>]+\.(m3u8|mp4))/);
+                                        if (match) return match[1];
+                                    } catch(e) {}
+                                }
+                            }
+
+                            return null;
+                        }
+                    """
+                    js_result = await page.evaluate(js_code)
+
+                    if js_result and ('.m3u8' in js_result or '.mp4' in js_result):
+                        print(f"[SMOOTHPRE] ✅ Found video URL via JavaScript: {js_result[:100]}...")
+                        video_urls.append(js_result)
+                except Exception as e:
+                    print(f"[SMOOTHPRE] JS extraction error: {e}")
+
+                # Parse page HTML for video URLs - enhanced patterns
+                try:
+                    content = await page.content()
+                    patterns = [
+                        r'"file"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"file"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'(https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*)',
+                        r'(https?://[^\s"\'<>]+\.mp4[^\s"\'<>]*)',
+                        r"url\s*[:=]\s*['\"]([^'\"]+\.m3u8[^'\"]*)['\"]",
+                        r"url\s*[:=]\s*['\"]([^'\"]+\.mp4[^'\"]*)['\"]",
+                    ]
+
+                    for pattern in patterns:
+                        matches = re.findall(pattern, content, re.IGNORECASE)
+                        for match in matches:
+                            # Clean up the URL
+                            match = match.replace('\\/', '/').replace('\\', '')
+                            if 'http' in match and 'smoothpre' not in match and 'google' not in match:
+                                print(f"[SMOOTHPRE] Found in HTML: {match[:100]}...")
+                                video_urls.append(match)
+                except Exception as e:
+                    print(f"[SMOOTHPRE] HTML parsing error: {e}")
+
+                await browser.close()
+
+                # Return first valid video URL (prefer .m3u8 over .mp4 as it's usually the source)
+                if video_urls:
+                    seen = set()
+                    unique_urls = []
+                    for vid_url in video_urls:
+                        if vid_url not in seen:
+                            seen.add(vid_url)
+                            unique_urls.append(vid_url)
+
+                    if unique_urls:
+                        # Sort to prefer .m3u8 (source quality)
+                        unique_urls.sort(key=lambda x: 0 if '.m3u8' in x else 1)
+                        print(f"[SMOOTHPRE] ✅ Found {len(unique_urls)} video URL(s)")
+                        print(f"[SMOOTHPRE] Selected: {unique_urls[0][:100]}...")
+                        return unique_urls[0]
+
+                print("[SMOOTHPRE] ❌ No video URLs found")
+                return None
+
+        except ImportError:
+            print("[SMOOTHPRE] ⚠️ Playwright not installed - falling back to HTTP extraction")
+            return await self._extract_with_http(url)
+        except Exception as e:
+            print(f"[SMOOTHPRE] Playwright error: {e}")
+            import traceback
+            traceback.print_exc()
+            # Fallback to HTTP extraction
+            return await self._extract_with_http(url)
+
+    async def _extract_with_http(self, url: str) -> str | None:
+        """Extract video URL using simple HTTP requests (fallback when Playwright fails)"""
+        try:
+            print(f"[SMOOTHPRE] Trying HTTP extraction from: {url}")
+
+            response = await self.client.get(url, follow_redirects=True)
+            soup = BeautifulSoup(response.text, 'lxml')
+
+            # Method 1: Look for video/source tags
+            videos = soup.find_all('video')
+            for video in videos:
+                src = video.get('src') or video.get('data-src')
+                if src and any(ext in src for ext in ['.m3u8', '.mp4']):
+                    print(f"[SMOOTHPRE] ✅ Found video in video tag: {src[:100]}...")
+                    return src
+
+                sources = video.find_all('source')
+                for source in sources:
+                    src = source.get('src')
+                    if src and any(ext in src for ext in ['.m3u8', '.mp4']):
+                        print(f"[SMOOTHPRE] ✅ Found video in source tag: {src[:100]}...")
+                        return src
+
+            # Method 2: Look in script tags for JWPlayer configuration
+            scripts = soup.find_all('script')
+            for script in scripts:
+                if script.string:
+                    # JWPlayer patterns
+                    patterns = [
+                        r'"file"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"file"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.m3u8[^"]*)"',
+                        r'"source"\s*:\s*"([^"]+\.mp4[^"]*)"',
+                        r'(https?://[^\s"\'<>]+\.m3u8[^\s"\'<>]*)',
+                        r'(https?://[^\s"\'<>]+\.mp4[^\s"\'<>]*)',
+                    ]
+
+                    for pattern in patterns:
+                        matches = re.findall(pattern, script.string, re.IGNORECASE)
+                        for match in matches:
+                            match = match.replace('\\/', '/')
+                            if 'http' in match and 'smoothpre' not in match.lower():
+                                print(f"[SMOOTHPRE] ✅ Found video in script: {match[:100]}...")
+                                return match
+
+            print("[SMOOTHPRE] ❌ HTTP extraction failed - no video URLs found")
+            return None
+
+        except Exception as e:
+            print(f"[SMOOTHPRE] HTTP extraction error: {e}")
+            return None

app/episode_checker.py

@@ -0,0 +1,245 @@
+"""Episode checker for detecting and downloading new episodes automatically"""
+import logging
+from typing import List, Optional, Dict
+from datetime import datetime
+
+from app.watchlist import watchlist_manager, WatchlistManager
+from app.models import DownloadRequest, DownloadTask, DownloadStatus
+from app.models.watchlist import (
+    WatchlistItem,
+    WatchlistSettings,
+    NewEpisodeInfo,
+    AutoDownloadResult
+)
+
+logger = logging.getLogger(__name__)
+
+
+class EpisodeChecker:
+    """Checks for new episodes and downloads them automatically"""
+
+    def __init__(self, wlm: Optional[WatchlistManager] = None):
+        self.wlm = wlm or watchlist_manager
+        self.download_manager = None  # Will be set by main.py
+
+    def set_download_manager(self, download_manager):
+        """Set the download manager (called by main.py to avoid circular import)"""
+        self.download_manager = download_manager
+
+    async def check_anime(self, item: WatchlistItem) -> List[NewEpisodeInfo]:
+        """
+        Check for new episodes of a specific anime
+
+        Args:
+            item: WatchlistItem to check
+
+        Returns:
+            List of NewEpisodeInfo objects
+        """
+        try:
+            logger.info(f"Checking for new episodes: {item.anime_title}")
+
+            # Import here to avoid circular imports
+            from app.downloaders import get_downloader
+
+            # Get the appropriate downloader
+            downloader = get_downloader(item.anime_url)
+            if not downloader:
+                logger.error(f"No downloader found for URL: {item.anime_url}")
+                return []
+
+            # Get episodes list
+            episodes = await downloader.get_episodes(item.anime_url, item.lang)
+            if not episodes:
+                logger.warning(f"No episodes found for {item.anime_title}")
+                return []
+
+            # Filter new episodes
+            new_episodes = []
+            for ep in episodes:
+                ep_num = ep.get('episode_number', 0)
+                if ep_num > item.last_episode_downloaded:
+                    new_episodes.append(NewEpisodeInfo(
+                        episode_number=ep_num,
+                        episode_title=ep.get('title'),
+                        episode_url=ep['url'],
+                        season_number=ep.get('season'),
+                        anime_title=item.anime_title,
+                        provider_id=item.provider_id
+                    ))
+
+            if new_episodes:
+                logger.info(f"Found {len(new_episodes)} new episodes for {item.anime_title}")
+            else:
+                logger.info(f"No new episodes for {item.anime_title}")
+
+            return new_episodes
+
+        except Exception as e:
+            logger.error(f"Error checking anime {item.anime_title}: {e}", exc_info=True)
+            return []
+
+    async def download_new_episodes(
+        self,
+        item: WatchlistItem,
+        episodes: List[NewEpisodeInfo]
+    ) -> AutoDownloadResult:
+        """
+        Download new episodes for a watchlist item
+
+        Args:
+            item: WatchlistItem
+            episodes: List of new episodes to download
+
+        Returns:
+            AutoDownloadResult with download status
+        """
+        result = AutoDownloadResult(
+            watchlist_item_id=item.id,
+            anime_title=item.anime_title,
+            new_episodes_found=len(episodes),
+            checked_at=datetime.now()
+        )
+
+        if not episodes:
+            return result
+
+        # Get settings
+        settings = self.wlm.get_settings()
+        if not settings.auto_download_enabled:
+            logger.info(f"Auto-download disabled, skipping {len(episodes)} episodes")
+            return result
+
+        try:
+            # Import here to avoid circular imports
+            from app.downloaders import get_downloader
+
+            downloader = get_downloader(item.anime_url)
+
+            # Download each new episode
+            for ep_info in episodes:
+                try:
+                    logger.info(f"Downloading {item.anime_title} Episode {ep_info.episode_number}")
+
+                    # Get download link
+                    download_link, filename = await downloader.get_download_link(ep_info.episode_url)
+
+                    # Create download task
+                    request = DownloadRequest(url=download_link, filename=filename)
+                    task = self.download_manager.create_task(request)
+                    
+                    if task:
+                        await self.download_manager.start_download(task.id)
+                        result.episodes_downloaded.append(ep_info.episode_number)
+                        logger.info(f"Started download: {filename}")
+                    else:
+                        result.episodes_failed.append((ep_info.episode_number, "Failed to create download task"))
+
+                except Exception as e:
+                    error_msg = str(e)
+                    logger.error(f"Error downloading episode {ep_info.episode_number}: {error_msg}")
+                    result.episodes_failed.append((ep_info.episode_number, error_msg))
+
+            # Update watchlist with last episode downloaded
+            if result.episodes_downloaded:
+                last_ep = max(result.episodes_downloaded)
+                self.wlm.update_check_time(item.id, last_ep)
+
+        except Exception as e:
+            logger.error(f"Error in download_new_episodes: {e}", exc_info=True)
+
+        return result
+
+    async def check_and_download(self, item: WatchlistItem) -> AutoDownloadResult:
+        """
+        Check for new episodes and download them if auto_download is enabled
+
+        Args:
+            item: WatchlistItem to check
+
+        Returns:
+            AutoDownloadResult
+        """
+        # Check for new episodes
+        new_episodes = await self.check_anime(item)
+
+        result = AutoDownloadResult(
+            watchlist_item_id=item.id,
+            anime_title=item.anime_title,
+            new_episodes_found=len(new_episodes),
+            checked_at=datetime.now()
+        )
+
+        # Download if auto_download is enabled
+        if item.auto_download and new_episodes:
+            settings = self.wlm.get_settings()
+            if settings.auto_download_enabled:
+                download_result = await self.download_new_episodes(item, new_episodes)
+                result = download_result
+            else:
+                logger.info(f"Auto-download globally disabled, skipping {len(new_episodes)} episodes")
+
+        # Update check time even if no downloads
+        self.wlm.update_check_time(item.id, item.last_episode_downloaded)
+
+        return result
+
+    async def check_all_due(self) -> List[AutoDownloadResult]:
+        """
+        Check all watchlist items that are due for checking
+
+        Returns:
+            List of AutoDownloadResult objects
+        """
+        settings = self.wlm.get_settings()
+        due_items = self.wlm.get_due_for_check(settings.check_interval_hours)
+
+        logger.info(f"Checking {len(due_items)} due watchlist items")
+
+        results = []
+        for item in due_items:
+            try:
+                result = await self.check_and_download(item)
+                results.append(result)
+            except Exception as e:
+                logger.error(f"Error processing {item.anime_title}: {e}", exc_info=True)
+                # Still add a result to track the failure
+                results.append(AutoDownloadResult(
+                    watchlist_item_id=item.id,
+                    anime_title=item.anime_title,
+                    new_episodes_found=0,
+                    checked_at=datetime.now()
+                ))
+
+        # Log summary
+        total_new = sum(r.new_episodes_found for r in results)
+        total_downloaded = sum(len(r.episodes_downloaded) for r in results)
+        total_failed = sum(len(r.episodes_failed) for r in results)
+
+        logger.info(
+            f"Check complete: {total_new} new episodes found, "
+            f"{total_downloaded} downloaded, {total_failed} failed"
+        )
+
+        return results
+
+    async def manual_check(self, item_id: str) -> Optional[AutoDownloadResult]:
+        """
+        Manually trigger a check for a specific watchlist item
+
+        Args:
+            item_id: Watchlist item ID
+
+        Returns:
+            AutoDownloadResult or None if item not found
+        """
+        item = self.wlm.get_by_id(item_id)
+        if not item:
+            logger.error(f"Watchlist item not found: {item_id}")
+            return None
+
+        return await self.check_and_download(item)
+
+
+# Global episode checker instance
+episode_checker = EpisodeChecker()

app/metadata_enrichment.py

@@ -0,0 +1,423 @@
+"""
+Metadata enrichment service with Kitsu API fallback.
+
+This module provides intelligent metadata enrichment by:
+1. Merging provider metadata with Kitsu API data
+2. Filling missing fields from Kitsu
+3. Normalizing data formats across providers
+4. Caching enriched metadata to reduce API calls
+"""
+import asyncio
+import logging
+from typing import Dict, Optional, List, Set
+from datetime import datetime, timedelta
+from pathlib import Path
+import json
+import hashlib
+
+from app.kitsu_api import KitsuAPI
+from app.models import AnimeMetadata
+
+logger = logging.getLogger(__name__)
+
+
+class MetadataEnricher:
+    """
+    Enriches anime metadata by combining provider data with Kitsu API fallback.
+    Caches results to minimize API calls.
+    """
+
+    # Fields that Kitsu can provide as fallback
+    # Note: studio is not included as Kitsu API requires separate calls
+    KITSU_FIELDS = {
+        'synopsis', 'genres', 'rating', 'release_year',
+        'poster_image', 'banner_image', 'total_episodes', 'status',
+        'alternative_titles'
+    }
+
+    # Cache duration in hours
+    CACHE_DURATION_HOURS = 24
+
+    def __init__(self, cache_dir: str = "config"):
+        self.cache_dir = Path(cache_dir)
+        self.cache_file = self.cache_dir / "metadata_cache.json"
+        self.kitsu_api = KitsuAPI()
+        self._cache: Dict[str, Dict] = {}
+        self._cache_dirty = False
+
+        # Load cache on initialization
+        self._load_cache()
+
+    def _load_cache(self):
+        """Load metadata cache from disk."""
+        try:
+            if self.cache_file.exists():
+                with open(self.cache_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    # Filter out expired entries
+                    now = datetime.now()
+                    self._cache = {
+                        k: v for k, v in data.items()
+                        if datetime.fromisoformat(v.get('cached_at', '')) >
+                        now - timedelta(hours=self.CACHE_DURATION_HOURS)
+                    }
+                    logger.info(f"Loaded {len(self._cache)} cached metadata entries")
+        except Exception as e:
+            logger.warning(f"Failed to load metadata cache: {e}")
+            self._cache = {}
+
+    def _save_cache(self):
+        """Save metadata cache to disk."""
+        if not self._cache_dirty:
+            return
+
+        try:
+            self.cache_dir.mkdir(parents=True, exist_ok=True)
+            with open(self.cache_file, 'w', encoding='utf-8') as f:
+                json.dump(self._cache, f, ensure_ascii=False, indent=2)
+            self._cache_dirty = False
+            logger.debug("Saved metadata cache")
+        except Exception as e:
+            logger.error(f"Failed to save metadata cache: {e}")
+
+    def _get_cache_key(self, title: str, url: Optional[str] = None) -> str:
+        """Generate cache key from title and URL."""
+        # Use both title and URL for more precise caching
+        key_data = f"{title}|{url or ''}"
+        return hashlib.md5(key_data.encode()).hexdigest()
+
+    def _get_cached_metadata(self, cache_key: str) -> Optional[Dict]:
+        """Get cached metadata if available and not expired."""
+        if cache_key in self._cache:
+            entry = self._cache[cache_key]
+            cached_at = datetime.fromisoformat(entry.get('cached_at', ''))
+            if cached_at > datetime.now() - timedelta(hours=self.CACHE_DURATION_HOURS):
+                logger.debug(f"Cache hit for key: {cache_key}")
+                return entry.get('metadata')
+            else:
+                # Remove expired entry
+                del self._cache[cache_key]
+                self._cache_dirty = True
+        return None
+
+    def _set_cached_metadata(self, cache_key: str, metadata: Dict):
+        """Cache enriched metadata."""
+        self._cache[cache_key] = {
+            'metadata': metadata,
+            'cached_at': datetime.now().isoformat()
+        }
+        self._cache_dirty = True
+
+    async def enrich_metadata(
+        self,
+        provider_metadata: Dict,
+        title: str,
+        url: Optional[str] = None,
+        use_kitsu_fallback: bool = True
+    ) -> AnimeMetadata:
+        """
+        Enrich provider metadata with Kitsu API fallback.
+
+        Args:
+            provider_metadata: Metadata dict from anime provider
+            title: Anime title (for Kitsu search)
+            url: Optional anime URL (for cache key)
+            use_kitsu_fallback: Whether to use Kitsu API for missing fields
+
+        Returns:
+            Enriched AnimeMetadata object
+        """
+        # Check cache first
+        cache_key = self._get_cache_key(title, url)
+        cached = self._get_cached_metadata(cache_key)
+        if cached:
+            return AnimeMetadata(**cached)
+
+        # Start with provider metadata
+        enriched = provider_metadata.copy()
+
+        # Check which fields are missing
+        missing_fields = self._get_missing_fields(enriched)
+
+        if missing_fields and use_kitsu_fallback:
+            logger.info(f"Missing fields for '{title}': {missing_fields} - fetching from Kitsu")
+            try:
+                # Fetch from Kitsu
+                kitsu_metadata = await self._fetch_from_kitsu(title)
+
+                if kitsu_metadata:
+                    # Merge Kitsu data
+                    enriched = self._merge_metadata(enriched, kitsu_metadata)
+                    enriched['_kitsu_enriched'] = True
+                    enriched['_enriched_fields'] = list(missing_fields)
+            except Exception as e:
+                logger.warning(f"Failed to fetch Kitsu metadata for '{title}': {e}")
+
+        # Calculate quality score
+        enriched['_quality_score'] = self._calculate_quality_score(enriched)
+
+        # Convert to AnimeMetadata
+        result = AnimeMetadata(**{
+            k: v for k, v in enriched.items()
+            if not k.startswith('_')  # Exclude internal fields
+        })
+
+        # Cache the result
+        self._set_cached_metadata(cache_key, result.model_dump())
+
+        # Periodically save cache
+        if self._cache_dirty and len(self._cache) % 10 == 0:
+            self._save_cache()
+
+        return result
+
+    def _get_missing_fields(self, metadata: Dict) -> Set[str]:
+        """Identify which metadata fields are missing or empty."""
+        missing = set()
+        for field in self.KITSU_FIELDS:
+            value = metadata.get(field)
+            if value is None or value == [] or value == '':
+                missing.add(field)
+        return missing
+
+    async def _fetch_from_kitsu(self, title: str) -> Optional[Dict]:
+        """Fetch metadata from Kitsu API."""
+        try:
+            # Search for anime
+            results = await self.kitsu_api.search_anime(title, limit=1)
+
+            if results and len(results) > 0:
+                anime_data = results[0]
+                return self._convert_kitsu_to_metadata(anime_data)
+            else:
+                logger.debug(f"No Kitsu results for '{title}'")
+                return None
+
+        except Exception as e:
+            logger.error(f"Error fetching from Kitsu for '{title}': {e}")
+            return None
+
+    def _convert_kitsu_to_metadata(self, kitsu_data: Dict) -> Dict:
+        """Convert Kitsu API response to metadata format."""
+        metadata = {}
+
+        # Synopsis
+        if kitsu_data.get('synopsis'):
+            metadata['synopsis'] = kitsu_data['synopsis']
+
+        # Genres
+        if kitsu_data.get('genres'):
+            metadata['genres'] = kitsu_data['genres']
+
+        # Rating (Kitsu returns score out of 10, convert to string)
+        if kitsu_data.get('score'):
+            score = kitsu_data['score']
+            if score > 0:
+                metadata['rating'] = f"{score:.1f}/10"
+
+        # Release year
+        if kitsu_data.get('year'):
+            metadata['release_year'] = kitsu_data['year']
+
+        # Poster image
+        if kitsu_data.get('images', {}).get('jpg', {}).get('large_image_url'):
+            metadata['poster_image'] = kitsu_data['images']['jpg']['large_image_url']
+        elif kitsu_data.get('images', {}).get('jpg', {}).get('image_url'):
+            metadata['poster_image'] = kitsu_data['images']['jpg']['image_url']
+
+        # Banner image (Kitsu calls it coverImage)
+        # Note: Kitsu API structure doesn't clearly separate poster vs banner,
+        # but we can use different sizes if available
+        if kitsu_data.get('images', {}).get('webp', {}).get('large_image_url'):
+            metadata['banner_image'] = kitsu_data['images']['webp']['large_image_url']
+
+        # Total episodes
+        if kitsu_data.get('episodes'):
+            metadata['total_episodes'] = kitsu_data['episodes']
+
+        # Status
+        if kitsu_data.get('status'):
+            # Translate Kitsu status to our format
+            status_map = {
+                'Airing': 'Ongoing',
+                'Finished Airing': 'Completed',
+                'To Be Aired': 'Upcoming'
+            }
+            metadata['status'] = status_map.get(
+                kitsu_data['status'],
+                kitsu_data['status']
+            )
+
+        # Alternative titles
+        alt_titles = []
+        if kitsu_data.get('title_japanese'):
+            alt_titles.append(kitsu_data['title_japanese'])
+        if kitsu_data.get('title_english'):
+            alt_titles.append(kitsu_data['title_english'])
+        if alt_titles:
+            metadata['alternative_titles'] = alt_titles
+
+        return metadata
+
+    def _merge_metadata(
+        self,
+        provider_metadata: Dict,
+        kitsu_metadata: Dict
+    ) -> Dict:
+        """
+        Merge provider and Kitsu metadata, preferring provider data.
+
+        Provider data takes priority except for missing fields.
+        """
+        merged = provider_metadata.copy()
+
+        for field, value in kitsu_metadata.items():
+            # Only use Kitsu data if provider doesn't have it
+            if field not in merged or not merged[field]:
+                merged[field] = value
+
+        return merged
+
+    def _calculate_quality_score(self, metadata: Dict) -> float:
+        """
+        Calculate metadata quality score (0-1).
+
+        Based on completeness of critical fields.
+        """
+        weights = {
+            'synopsis': 0.2,
+            'genres': 0.15,
+            'rating': 0.1,
+            'release_year': 0.1,
+            'studio': 0.1,
+            'poster_image': 0.15,
+            'banner_image': 0.05,
+            'total_episodes': 0.05,
+            'status': 0.05,
+            'alternative_titles': 0.05
+        }
+
+        total_weight = sum(weights.values())
+        score = 0.0
+
+        for field, weight in weights.items():
+            value = metadata.get(field)
+            if value:
+                # For lists, check if not empty
+                if isinstance(value, list):
+                    if len(value) > 0:
+                        score += weight
+                # For strings, check if not empty
+                elif isinstance(value, str):
+                    if len(value) > 10:  # Minimum meaningful length
+                        score += weight
+                # For numbers
+                else:
+                    score += weight
+
+        return round(score / total_weight, 2) if total_weight > 0 else 0.0
+
+    async def enrich_search_results(
+        self,
+        results: List[Dict],
+        use_kitsu_fallback: bool = True
+    ) -> List[Dict]:
+        """
+        Enrich metadata for a list of search results.
+
+        Args:
+            results: List of search result dicts with optional 'metadata' field
+            use_kitsu_fallback: Whether to use Kitsu API
+
+        Returns:
+            List of results with enriched metadata
+        """
+        enriched_results = []
+
+        # Process results in parallel for better performance
+        enrichment_tasks = []
+        for result in results:
+            # Skip if no metadata - will add later in order
+            if 'metadata' not in result:
+                continue
+
+            task = self.enrich_metadata(
+                provider_metadata=result['metadata'],
+                title=result.get('title', ''),
+                url=result.get('url'),
+                use_kitsu_fallback=use_kitsu_fallback
+            )
+            enrichment_tasks.append(task)
+
+        # Wait for all enrichment tasks
+        if enrichment_tasks:
+            enriched_metadata_list = await asyncio.gather(
+                *enrichment_tasks,
+                return_exceptions=True
+            )
+
+            # Update results with enriched metadata
+            # Create index mapping to preserve order
+            temp_results = {}
+            metadata_idx = 0
+            for i, result in enumerate(results):
+                if 'metadata' in result:
+                    enriched_meta = enriched_metadata_list[metadata_idx]
+
+                    if isinstance(enriched_meta, Exception):
+                        logger.warning(
+                            f"Failed to enrich metadata for '{result.get('title')}': {enriched_meta}"
+                        )
+                        # Keep original metadata
+                        result_copy = result.copy()
+                    else:
+                        result_copy = result.copy()
+                        result_copy['metadata'] = enriched_meta.model_dump()
+
+                    temp_results[i] = result_copy
+                    metadata_idx += 1
+
+            # Build final result list in correct order
+            enriched_results = []
+            for i in range(len(results)):
+                if i in temp_results:
+                    enriched_results.append(temp_results[i])
+                else:
+                    # No metadata result - use original
+                    enriched_results.append(results[i].copy())
+
+        return enriched_results
+
+    async def close(self):
+        """Close resources and save cache."""
+        await self.kitsu_api.close()
+        self._save_cache()
+        logger.info("MetadataEnricher closed")
+
+
+# Global instance
+_enricher_instance: Optional[MetadataEnricher] = None
+_enricher_lock = asyncio.Lock()
+
+
+async def get_metadata_enricher() -> MetadataEnricher:
+    """Get or create the global MetadataEnricher instance."""
+    global _enricher_instance
+
+    if _enricher_instance is None:
+        async with _enricher_lock:
+            if _enricher_instance is None:
+                _enricher_instance = MetadataEnricher()
+                logger.info("Created global MetadataEnricher instance")
+
+    return _enricher_instance
+
+
+async def close_metadata_enricher():
+    """Close the global MetadataEnricher instance."""
+    global _enricher_instance
+
+    if _enricher_instance is not None:
+        await _enricher_instance.close()
+        _enricher_instance = None
+        logger.info("Closed global MetadataEnricher instance")

app/models/watchlist.py

@@ -0,0 +1,121 @@
+"""Pydantic models for Watchlist and Auto-Download system"""
+from pydantic import BaseModel, Field
+from typing import Optional, Literal
+from datetime import datetime
+from enum import Enum
+
+
+class WatchlistStatus(str, Enum):
+    """Status of a watchlist item"""
+    ACTIVE = "active"           # Currently tracking for new episodes
+    PAUSED = "paused"           # Temporarily paused
+    COMPLETED = "completed"     # Anime completed, no longer tracking
+    ARCHIVED = "archived"       # Archived but kept for history
+
+
+class QualityPreference(str, Enum):
+    """Preferred video quality"""
+    AUTO = "auto"               # Let provider decide
+    P1080 = "1080p"             # Full HD
+    P720 = "720p"               # HD
+    P480 = "480p"               # SD
+
+
+class WatchlistItem(BaseModel):
+    """An anime being tracked for automatic episode downloads"""
+    id: str = Field(..., description="Unique identifier (UUID)")
+    user_id: str = Field(..., description="User ID who owns this watchlist item")
+    anime_title: str = Field(..., description="Title of the anime")
+    anime_url: str = Field(..., description="URL to the anime page")
+    provider_id: str = Field(..., description="Provider ID (animesama, nekosama, etc.)")
+    lang: Literal["vostfr", "vf"] = Field(default="vostfr", description="Language preference")
+
+    # Tracking state
+    last_checked: Optional[datetime] = Field(None, description="Last time we checked for new episodes")
+    last_episode_downloaded: int = Field(default=0, description="Last episode number downloaded")
+    total_episodes: Optional[int] = Field(None, description="Total episodes if known")
+
+    # Settings
+    auto_download: bool = Field(default=True, description="Automatically download new episodes")
+    quality_preference: QualityPreference = Field(default=QualityPreference.AUTO, description="Preferred quality")
+    status: WatchlistStatus = Field(default=WatchlistStatus.ACTIVE, description="Tracking status")
+
+    # Metadata
+    poster_image: Optional[str] = Field(None, description="URL to poster image")
+    cover_image: Optional[str] = Field(None, description="URL to cover image")
+    synopsis: Optional[str] = Field(None, description="Anime synopsis")
+    genres: list[str] = Field(default_factory=list, description="Anime genres")
+
+    # Timestamps
+    added_at: datetime = Field(default_factory=datetime.now, description="When added to watchlist")
+    updated_at: datetime = Field(default_factory=datetime.now, description="Last update time")
+
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+class WatchlistItemCreate(BaseModel):
+    """Model for creating a new watchlist item"""
+    anime_title: str
+    anime_url: str
+    provider_id: str
+    lang: Literal["vostfr", "vf"] = "vostfr"
+    auto_download: bool = True
+    quality_preference: QualityPreference = QualityPreference.AUTO
+
+    # Optional metadata
+    poster_image: Optional[str] = None
+    cover_image: Optional[str] = None
+    synopsis: Optional[str] = None
+    genres: list[str] = []
+
+
+class WatchlistItemUpdate(BaseModel):
+    """Model for updating a watchlist item"""
+    auto_download: Optional[bool] = None
+    quality_preference: Optional[QualityPreference] = None
+    status: Optional[WatchlistStatus] = None
+    last_episode_downloaded: Optional[int] = None
+    total_episodes: Optional[int] = None
+
+
+class NewEpisodeInfo(BaseModel):
+    """Information about a newly detected episode"""
+    episode_number: int
+    episode_title: Optional[str] = None
+    episode_url: str
+    season_number: Optional[int] = None
+    anime_title: str
+    provider_id: str
+
+
+class AutoDownloadResult(BaseModel):
+    """Result of an automatic download check"""
+    watchlist_item_id: str
+    anime_title: str
+    new_episodes_found: int
+    episodes_downloaded: list[int] = Field(default_factory=list)
+    episodes_failed: list[tuple[int, str]] = Field(default_factory=list)  # (episode_number, error_message)
+    checked_at: datetime = Field(default_factory=datetime.now)
+
+
+class WatchlistSettings(BaseModel):
+    """Global watchlist settings"""
+    check_interval_hours: int = Field(default=6, ge=1, le=168, description="Check interval (1-168 hours)")
+    auto_download_enabled: bool = Field(default=True, description="Global auto-download toggle")
+    max_concurrent_auto_downloads: int = Field(default=2, ge=1, le=10, description="Max concurrent auto-downloads")
+    notify_on_new_episodes: bool = Field(default=False, description="Send notifications for new episodes")
+    include_completed_anime: bool = Field(default=False, description="Check completed anime too")
+
+    class Config:
+        json_schema_extra = {
+            "example": {
+                "check_interval_hours": 6,
+                "auto_download_enabled": True,
+                "max_concurrent_auto_downloads": 2,
+                "notify_on_new_episodes": False,
+                "include_completed_anime": False
+            }
+        }

app/sonarr_handler.py

@@ -3,6 +3,7 @@ import hmac
 import hashlib
 import json
 import logging
+import os
 from typing import Optional, Dict, List, Tuple, Any
 from pathlib import Path
 from datetime import datetime
@@ -14,6 +15,7 @@ from app.models.sonarr import (
     SonarrConfig,
     SonarrDownloadRequest
 )
+from app.models import DownloadRequest
 from app.downloaders import get_downloader, AnimeSamaDownloader, NekoSamaDownloader, AnimeUltimeDownloader, VostfreeDownloader
 
 # Configure logging
@@ -28,11 +30,15 @@ class SonarrHandler:
         self.mappings_path = Path(mappings_path)
         self.config = self._load_config()
         self.mappings = self._load_mappings()
+        self.download_manager = None
 
         # Create config directories if they don't exist
         self.config_path.parent.mkdir(exist_ok=True)
         self.mappings_path.parent.mkdir(exist_ok=True)
 
+    def set_download_manager(self, download_manager):
+        self.download_manager = download_manager
+
     def _load_config(self) -> SonarrConfig:
         """Load Sonarr configuration from file"""
         if self.config_path.exists():
@@ -45,10 +51,11 @@ class SonarrHandler:
         return SonarrConfig()
 
     def _save_config(self):
-        """Save Sonarr configuration to file"""
         try:
-            with open(self.config_path, 'w') as f:
+            temp_file = f"{self.config_path}.tmp"
+            with open(temp_file, 'w') as f:
                 json.dump(self.config.model_dump(mode='json'), f, indent=2)
+            os.replace(temp_file, self.config_path)
         except Exception as e:
             logger.error(f"Failed to save Sonarr config: {e}")
             raise
@@ -65,11 +72,13 @@ class SonarrHandler:
         return []
 
     def _save_mappings(self):
-        """Save mappings to file"""
         try:
-            with open(self.mappings_path, 'w') as f:
+            os.makedirs(os.path.dirname(self.mappings_path), exist_ok=True)
+            temp_file = f"{self.mappings_path}.tmp"
+            with open(temp_file, 'w') as f:
                 mappings_data = [m.model_dump(mode='json') for m in self.mappings]
                 json.dump(mappings_data, f, indent=2)
+            os.replace(temp_file, self.mappings_path)
         except Exception as e:
             logger.error(f"Failed to save mappings: {e}")
             raise
@@ -231,26 +240,25 @@ class SonarrHandler:
         downloads = []
         for episode in payload.episodes:
             try:
-                download_request = SonarrDownloadRequest(
-                    sonarr_series_id=payload.series.tvdbId,
-                    sonarr_title=payload.series.title,
-                    season_number=episode.seasonNumber,
-                    episode_number=episode.episodeNumber,
-                    quality=payload.release.quality.quality.get('name') if payload.release else mapping.quality_preference,
-                    lang=mapping.lang,
-                    provider=mapping.anime_provider
+                success = await self._trigger_download(
+                    mapping,
+                    episode.seasonNumber,
+                    episode.episodeNumber
                 )
                 
-                # Trigger the download (will be implemented in main.py)
                 downloads.append({
                     "season": episode.seasonNumber,
                     "episode": episode.episodeNumber,
-                    "status": "queued"
+                    "status": "started" if success else "failed"
                 })
-
-                logger.info(f"Queued download for {mapping.anime_title} S{episode.seasonNumber}E{episode.episodeNumber}")
             except Exception as e:
-                logger.error(f"Failed to queue download for episode {episode.episodeNumber}: {e}")
+                logger.error(f"Failed to trigger download for episode {episode.episodeNumber}: {e}")
+                downloads.append({
+                    "season": episode.seasonNumber,
+                    "episode": episode.episodeNumber,
+                    "status": "error",
+                    "error": str(e)
+                })
 
         return {
             "status": "processing",
@@ -259,6 +267,49 @@ class SonarrHandler:
             "downloads": downloads
         }
 
+    async def _trigger_download(self, mapping: SonarrMapping, season_number: int, episode_number: int) -> bool:
+        if not self.download_manager:
+            logger.error("DownloadManager not set in SonarrHandler")
+            return False
+
+        try:
+            downloader = get_downloader(mapping.anime_url)
+            if not downloader:
+                logger.error(f"No downloader for {mapping.anime_url}")
+                return False
+
+            episodes = await downloader.get_episodes(mapping.anime_url, mapping.lang)
+            
+            target_episode = None
+            for ep in episodes:
+                if ep.get('episode_number') == episode_number:
+                    if ep.get('season') and ep['season'] != season_number:
+                        continue
+                    target_episode = ep
+                    break
+            
+            if not target_episode:
+                logger.warning(f"Episode {episode_number} not found for {mapping.anime_title}")
+                return False
+
+            video_url, _ = await downloader.get_download_link(target_episode['url'])
+            
+            player_handler = get_downloader(video_url)
+            download_url, filename = await player_handler.get_download_link(video_url)
+            
+            request = DownloadRequest(url=download_url, filename=filename)
+            task = self.download_manager.create_task(request)
+            
+            if task:
+                await self.download_manager.start_download(task.id)
+                logger.info(f"Sonarr: Started download for {mapping.anime_title} S{season_number}E{episode_number}")
+                return True
+            
+            return False
+        except Exception as e:
+            logger.error(f"Error triggering Sonarr download: {e}")
+            return False
+
     async def _handle_download(self, payload: SonarrWebhookPayload) -> Dict:
         """Handle Download event (when Sonarr completes download)"""
         # Similar to Grab but for post-download processing

app/watchlist.py

@@ -0,0 +1,263 @@
+"""Watchlist management system for automatic episode tracking and downloading"""
+import json
+import os
+import uuid
+import logging
+from datetime import datetime, timedelta
+from typing import List, Optional, Dict
+from pathlib import Path
+
+from app.models.watchlist import (
+    WatchlistItem,
+    WatchlistItemCreate,
+    WatchlistItemUpdate,
+    WatchlistStatus,
+    WatchlistSettings,
+    NewEpisodeInfo,
+    AutoDownloadResult
+)
+
+logger = logging.getLogger(__name__)
+
+# Watchlist database file
+WATCHLIST_DB_FILE = "config/watchlist.json"
+WATCHLIST_SETTINGS_FILE = "config/watchlist_settings.json"
+
+
+class WatchlistManager:
+    """Manages user watchlist for automatic episode downloads"""
+
+    def __init__(self, db_file: str = WATCHLIST_DB_FILE):
+        self.db_file = db_file
+        self.settings_file = WATCHLIST_SETTINGS_FILE
+        self.watchlist: Dict[str, WatchlistItem] = {}
+        self.settings: Optional[WatchlistSettings] = None
+        self._load_watchlist()
+        self._load_settings()
+
+    def _load_watchlist(self):
+        """Load watchlist from JSON file"""
+        try:
+            if os.path.exists(self.db_file):
+                with open(self.db_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self.watchlist = {
+                        item_id: WatchlistItem(**item_data)
+                        for item_id, item_data in data.items()
+                    }
+                logger.info(f"Loaded {len(self.watchlist)} items from watchlist")
+            else:
+                self.watchlist = {}
+                logger.info("Watchlist database not found, starting with empty watchlist")
+        except Exception as e:
+            logger.error(f"Error loading watchlist: {e}")
+            self.watchlist = {}
+
+    def _save_watchlist(self):
+        try:
+            os.makedirs(os.path.dirname(self.db_file), exist_ok=True)
+            data = {
+                item_id: item.model_dump(mode='json')
+                for item_id, item in self.watchlist.items()
+            }
+            temp_file = f"{self.db_file}.tmp"
+            with open(temp_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False, default=str)
+            os.replace(temp_file, self.db_file)
+            logger.debug(f"Saved {len(self.watchlist)} items to watchlist")
+        except Exception as e:
+            logger.error(f"Error saving watchlist: {e}")
+
+    def _load_settings(self):
+        """Load watchlist settings from JSON file"""
+        try:
+            if os.path.exists(self.settings_file):
+                with open(self.settings_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    self.settings = WatchlistSettings(**data)
+                logger.info(f"Loaded watchlist settings")
+            else:
+                self.settings = WatchlistSettings()
+                self._save_settings()
+                logger.info("Settings file not found, using defaults")
+        except Exception as e:
+            logger.error(f"Error loading settings: {e}")
+            self.settings = WatchlistSettings()
+
+    def _save_settings(self):
+        try:
+            os.makedirs(os.path.dirname(self.settings_file), exist_ok=True)
+            temp_file = f"{self.settings_file}.tmp"
+            with open(temp_file, 'w', encoding='utf-8') as f:
+                json.dump(self.settings.model_dump(mode='json'), f, indent=2, ensure_ascii=False)
+            os.replace(temp_file, self.settings_file)
+            logger.debug("Saved watchlist settings")
+        except Exception as e:
+            logger.error(f"Error saving settings: {e}")
+
+    def get_all(self, user_id: Optional[str] = None, status: Optional[WatchlistStatus] = None) -> List[WatchlistItem]:
+        """Get all watchlist items, optionally filtered by user and status"""
+        items = list(self.watchlist.values())
+
+        if user_id:
+            items = [item for item in items if item.user_id == user_id]
+
+        if status:
+            items = [item for item in items if item.status == status]
+
+        # Sort by added_at descending
+        items.sort(key=lambda x: x.added_at, reverse=True)
+        return items
+
+    def get_by_id(self, item_id: str) -> Optional[WatchlistItem]:
+        """Get a watchlist item by ID"""
+        return self.watchlist.get(item_id)
+
+    def get_by_anime_url(self, anime_url: str, user_id: str) -> Optional[WatchlistItem]:
+        """Get a watchlist item by anime URL and user ID"""
+        for item in self.watchlist.values():
+            if item.anime_url == anime_url and item.user_id == user_id:
+                return item
+        return None
+
+    def create(self, user_id: str, item_data: WatchlistItemCreate) -> WatchlistItem:
+        """Create a new watchlist item"""
+        # Check if already exists
+        existing = self.get_by_anime_url(item_data.anime_url, user_id)
+        if existing:
+            raise ValueError(f"Anime already in watchlist (ID: {existing.id})")
+
+        # Create new item
+        item_id = str(uuid.uuid4())
+        now = datetime.now()
+
+        watchlist_item = WatchlistItem(
+            id=item_id,
+            user_id=user_id,
+            anime_title=item_data.anime_title,
+            anime_url=item_data.anime_url,
+            provider_id=item_data.provider_id,
+            lang=item_data.lang,
+            auto_download=item_data.auto_download,
+            quality_preference=item_data.quality_preference,
+            status=WatchlistStatus.ACTIVE,
+            poster_image=item_data.poster_image,
+            cover_image=item_data.cover_image,
+            synopsis=item_data.synopsis,
+            genres=item_data.genres,
+            added_at=now,
+            updated_at=now,
+            last_checked=None,
+            last_episode_downloaded=0,
+            total_episodes=None
+        )
+
+        self.watchlist[item_id] = watchlist_item
+        self._save_watchlist()
+        logger.info(f"Added anime to watchlist: {watchlist_item.anime_title} (ID: {item_id})")
+        return watchlist_item
+
+    def update(self, item_id: str, update_data) -> Optional[WatchlistItem]:
+        """Update a watchlist item
+
+        Args:
+            item_id: Item ID to update
+            update_data: WatchlistItemUpdate object or dict with fields to update
+        """
+        item = self.watchlist.get(item_id)
+        if not item:
+            return None
+
+        # Handle both dict and WatchlistItemUpdate
+        if isinstance(update_data, dict):
+            update_dict = update_data
+        else:
+            update_dict = update_data.model_dump(exclude_unset=True)
+
+        # Update fields
+        for field, value in update_dict.items():
+            if value is not None:
+                setattr(item, field, value)
+
+        item.updated_at = datetime.now()
+        self._save_watchlist()
+        logger.info(f"Updated watchlist item: {item_id}")
+        return item
+
+    def delete(self, item_id: str) -> bool:
+        """Delete a watchlist item"""
+        if item_id in self.watchlist:
+            del self.watchlist[item_id]
+            self._save_watchlist()
+            logger.info(f"Deleted watchlist item: {item_id}")
+            return True
+        return False
+
+    def update_check_time(self, item_id: str, last_episode: int) -> Optional[WatchlistItem]:
+        """Update last_checked time and last_episode_downloaded"""
+        item = self.watchlist.get(item_id)
+        if not item:
+            return None
+
+        item.last_checked = datetime.now()
+        item.last_episode_downloaded = max(item.last_episode_downloaded, last_episode)
+        item.updated_at = datetime.now()
+        self._save_watchlist()
+        return item
+
+    def get_settings(self) -> WatchlistSettings:
+        """Get watchlist settings"""
+        if not self.settings:
+            self.settings = WatchlistSettings()
+        return self.settings
+
+    def update_settings(self, settings: WatchlistSettings) -> WatchlistSettings:
+        """Update watchlist settings"""
+        self.settings = settings
+        self._save_settings()
+        logger.info("Updated watchlist settings")
+        return self.settings
+
+    def get_due_for_check(self, check_interval_hours: Optional[int] = None) -> List[WatchlistItem]:
+        """Get items that are due for checking"""
+        if check_interval_hours is None:
+            check_interval_hours = self.settings.check_interval_hours
+
+        cutoff_time = datetime.now() - timedelta(hours=check_interval_hours)
+
+        due_items = []
+        for item in self.watchlist.values():
+            # Only check active items with auto_download enabled
+            if item.status != WatchlistStatus.ACTIVE or not item.auto_download:
+                continue
+
+            # Check if due
+            if item.last_checked is None or item.last_checked < cutoff_time:
+                due_items.append(item)
+
+        logger.info(f"Found {len(due_items)} items due for check")
+        return due_items
+
+    def get_stats(self, user_id: Optional[str] = None) -> Dict:
+        """Get watchlist statistics"""
+        items = self.get_all(user_id=user_id)
+
+        stats = {
+            "total": len(items),
+            "active": len([i for i in items if i.status == WatchlistStatus.ACTIVE]),
+            "paused": len([i for i in items if i.status == WatchlistStatus.PAUSED]),
+            "completed": len([i for i in items if i.status == WatchlistStatus.COMPLETED]),
+            "auto_download_enabled": len([i for i in items if i.auto_download]),
+            "providers": {}
+        }
+
+        # Count by provider
+        for item in items:
+            provider = item.provider_id
+            stats["providers"][provider] = stats["providers"].get(provider, 0) + 1
+
+        return stats
+
+
+# Global watchlist manager instance
+watchlist_manager = WatchlistManager()

config/watchlist.json

@@ -0,0 +1,22 @@
+{
+  "2293bca2-c1c2-4e4f-8862-c4a6601f2b6f": {
+    "id": "2293bca2-c1c2-4e4f-8862-c4a6601f2b6f",
+    "user_id": "test_user_1",
+    "anime_title": "Test Anime",
+    "anime_url": "https://anime-sama.si/catalogue/test/vostfr/",
+    "provider_id": "animesama",
+    "lang": "vostfr",
+    "last_checked": null,
+    "last_episode_downloaded": 0,
+    "total_episodes": null,
+    "auto_download": true,
+    "quality_preference": "auto",
+    "status": "active",
+    "poster_image": null,
+    "cover_image": null,
+    "synopsis": null,
+    "genres": [],
+    "added_at": "2026-01-29T21:53:38.078765",
+    "updated_at": "2026-01-29T21:53:38.078765"
+  }
+}

config/watchlist_settings.json

@@ -0,0 +1,7 @@
+{
+  "check_interval_hours": 6,
+  "auto_download_enabled": true,
+  "max_concurrent_auto_downloads": 2,
+  "notify_on_new_episodes": false,
+  "include_completed_anime": false
+}

docs/WATCHLIST_AUTO_DOWNLOAD.md

@@ -0,0 +1,441 @@
+# Watchlist & Auto-Download System
+
+## 🎯 Overview
+
+The Watchlist & Auto-Download system allows users to automatically track and download new episodes of their favorite anime. It features periodic checking, automatic downloads, and a flexible scheduler.
+
+## 📋 Features
+
+### Core Functionality
+- **Automatic Episode Tracking**: Track new episodes for anime in your watchlist
+- **Periodic Checking**: Configurable check intervals (1-168 hours)
+- **Auto-Download**: Automatically download new episodes when detected
+- **Manual Checks**: Trigger checks on-demand via API
+- **Per-Anime Settings**: Configure auto-download, quality, and status per anime
+- **Scheduler Management**: Start/stop the automatic scheduler
+
+### Status Types
+- **ACTIVE**: Currently tracking for new episodes
+- **PAUSED**: Temporarily paused (won't check)
+- **COMPLETED**: Anime completed, no longer tracking
+- **ARCHIVED**: Archived but kept for history
+
+## 🚀 Installation
+
+### 1. Install APScheduler
+
+The system requires APScheduler for scheduling:
+
+```bash
+# If using virtual environment (recommended)
+source venv/bin/activate
+pip install apscheduler==3.11.0
+
+# Or add to requirements.txt and install
+pip install -r requirements.txt
+```
+
+### 2. Configuration Files
+
+The system uses JSON files for persistence:
+
+```
+config/
+├── watchlist.json           # User watchlist items (auto-created)
+├── watchlist_settings.json  # Global settings (auto-created)
+└── .gitkeep
+```
+
+## 📚 API Endpoints
+
+### Watchlist Management
+
+#### Add Anime to Watchlist
+```http
+POST /api/watchlist
+Content-Type: application/json
+Authorization: Bearer <token>
+
+{
+  "anime_title": "Naruto Shippuden",
+  "anime_url": "https://anime-sama.si/catalogue/naruto-shippuden/saison1/vostfr/",
+  "provider_id": "animesama",
+  "lang": "vostfr",
+  "auto_download": true,
+  "quality_preference": "auto",
+  "poster_image": "https://...",
+  "synopsis": "Ninja anime...",
+  "genres": ["Action", "Adventure"]
+}
+```
+
+#### Get User's Watchlist
+```http
+GET /api/watchlist?status=active
+Authorization: Bearer <token>
+```
+
+#### Get Specific Item
+```http
+GET /api/watchlist/{item_id}
+Authorization: Bearer <token>
+```
+
+#### Update Watchlist Item
+```http
+PUT /api/watchlist/{item_id}
+Content-Type: application/json
+Authorization: Bearer <token>
+
+{
+  "auto_download": false,
+  "status": "paused",
+  "last_episode_downloaded": 12
+}
+```
+
+#### Delete from Watchlist
+```http
+DELETE /api/watchlist/{item_id}
+Authorization: Bearer <token>
+```
+
+### Episode Checking
+
+#### Check Specific Anime
+```http
+POST /api/watchlist/{item_id}/check
+Authorization: Bearer <token>
+```
+
+#### Check All Due Items
+```http
+POST /api/watchlist/check-all
+Authorization: Bearer <token>
+```
+
+### Pause/Resume
+
+#### Pause Tracking
+```http
+POST /api/watchlist/{item_id}/pause
+Authorization: Bearer <token>
+```
+
+#### Resume Tracking
+```http
+POST /api/watchlist/{item_id}/resume
+Authorization: Bearer <token>
+```
+
+### Settings
+
+#### Get Settings
+```http
+GET /api/watchlist/settings
+Authorization: Bearer <token>
+```
+
+Response:
+```json
+{
+  "check_interval_hours": 6,
+  "auto_download_enabled": true,
+  "max_concurrent_auto_downloads": 2,
+  "notify_on_new_episodes": false,
+  "include_completed_anime": false
+}
+```
+
+#### Update Settings
+```http
+PUT /api/watchlist/settings
+Content-Type: application/json
+Authorization: Bearer <token>
+
+{
+  "check_interval_hours": 12,
+  "auto_download_enabled": true
+}
+```
+
+### Statistics
+
+#### Get Watchlist Stats
+```http
+GET /api/watchlist/stats
+Authorization: Bearer <token>
+```
+
+Response:
+```json
+{
+  "total": 15,
+  "active": 12,
+  "paused": 2,
+  "completed": 1,
+  "auto_download_enabled": 12,
+  "providers": {
+    "animesama": 8,
+    "nekosama": 5,
+    "animeultime": 2
+  }
+}
+```
+
+### Scheduler Control
+
+#### Get Scheduler Status
+```http
+GET /api/watchlist/scheduler/status
+Authorization: Bearer <token>
+```
+
+Response:
+```json
+{
+  "running": true,
+  "next_run": "2026-01-29T18:00:00Z",
+  "settings": { ... }
+}
+```
+
+#### Start Scheduler
+```http
+POST /api/watchlist/scheduler/start
+Authorization: Bearer <token>
+```
+
+#### Stop Scheduler
+```http
+POST /api/watchlist/scheduler/stop
+Authorization: Bearer <token>
+```
+
+## 🏗️ Architecture
+
+### Components
+
+1. **WatchlistManager** (`app/watchlist.py`)
+   - Manages watchlist storage (JSON-based)
+   - CRUD operations for watchlist items
+   - Settings management
+   - Statistics and queries
+
+2. **EpisodeChecker** (`app/episode_checker.py`)
+   - Checks for new episodes
+   - Downloads episodes automatically
+   - Integrates with existing downloaders
+   - Handles errors and retries
+
+3. **AutoDownloadScheduler** (`app/auto_download_scheduler.py`)
+   - APScheduler-based periodic checking
+   - Configurable intervals
+   - Start/stop control
+   - Next run tracking
+
+4. **Pydantic Models** (`app/models/watchlist.py`)
+   - WatchlistItem
+   - WatchlistItemCreate
+   - WatchlistItemUpdate
+   - WatchlistSettings
+   - AutoDownloadResult
+
+### Data Flow
+
+```
+User Request → API Endpoint → WatchlistManager → JSON Storage
+                                                ↓
+Scheduler (periodic) → EpisodeChecker → Downloaders → DownloadManager
+```
+
+## 💡 Usage Examples
+
+### Example 1: Add Anime and Enable Auto-Download
+
+```bash
+curl -X POST "http://localhost:3000/api/watchlist" \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "anime_title": "Frieren",
+    "anime_url": "https://anime-sama.si/catalogue/frieren/saison1/vostfr/",
+    "provider_id": "animesama",
+    "lang": "vostfr",
+    "auto_download": true
+  }'
+```
+
+### Example 2: Check All Animes Manually
+
+```bash
+curl -X POST "http://localhost:3000/api/watchlist/check-all" \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
+### Example 3: Pause Tracking for an Anime
+
+```bash
+curl -X POST "http://localhost:3000/api/watchlist/ITEM_ID/pause" \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
+### Example 4: Update Settings to Check Every 3 Hours
+
+```bash
+curl -X PUT "http://localhost:3000/api/watchlist/settings" \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "check_interval_hours": 3,
+    "auto_download_enabled": true
+  }'
+```
+
+## 🔧 Configuration
+
+### Environment Variables
+
+No special environment variables required. The system uses:
+
+- `DOWNLOAD_DIR`: From app/config.py (default: "downloads")
+- `MAX_PARALLEL_DOWNLOADS`: From app/config.py (default: 3)
+
+### Settings
+
+Settings are stored in `config/watchlist_settings.json`:
+
+```json
+{
+  "check_interval_hours": 6,
+  "auto_download_enabled": true,
+  "max_concurrent_auto_downloads": 2,
+  "notify_on_new_episodes": false,
+  "include_completed_anime": false
+}
+```
+
+## 🎨 Frontend Integration (TODO)
+
+The UI components to be implemented:
+
+1. **Watchlist Page** (`/watchlist`)
+   - List of tracked anime
+   - Status indicators
+   - Pause/Resume buttons
+   - Settings modal
+
+2. **Add to Watchlist Button**
+   - On anime search results
+   - On anime detail pages
+   - Quick-add with confirmation
+
+3. **Settings Panel**
+   - Global toggle for auto-download
+   - Check interval selector
+   - Scheduler controls
+
+4. **Notifications**
+   - New episode alerts
+   - Download progress
+   - Error notifications
+
+## 🧪 Testing
+
+### Manual Testing
+
+```python
+# Test adding to watchlist
+from app.watchlist import watchlist_manager
+from app.models.watchlist import WatchlistItemCreate
+
+item_data = WatchlistItemCreate(
+    anime_title="Test Anime",
+    anime_url="https://anime-sama.si/catalogue/test/vostfr/",
+    provider_id="animesama",
+    lang="vostfr"
+)
+item = watchlist_manager.create("user_id", item_data)
+print(f"Created: {item.id}")
+
+# Test getting stats
+stats = watchlist_manager.get_stats("user_id")
+print(f"Stats: {stats}")
+```
+
+### API Testing
+
+```bash
+# Start the server
+uvicorn main:app --reload
+
+# Test endpoints
+curl -X GET "http://localhost:3000/api/watchlist" \
+  -H "Authorization: Bearer YOUR_TOKEN"
+
+# Start scheduler
+curl -X POST "http://localhost:3000/api/watchlist/scheduler/start" \
+  -H "Authorization: Bearer YOUR_TOKEN"
+```
+
+## 🔍 Troubleshooting
+
+### Scheduler Not Running
+
+1. Check scheduler status:
+   ```bash
+   curl "http://localhost:3000/api/watchlist/scheduler/status"
+   ```
+
+2. Check logs for APScheduler errors
+
+3. Ensure APScheduler is installed:
+   ```bash
+   pip list | grep apscheduler
+   ```
+
+### Episodes Not Downloading
+
+1. Verify auto_download is enabled:
+   ```json
+   {
+     "auto_download": true,
+     "status": "active"
+   }
+   ```
+
+2. Check global settings:
+   ```json
+   {
+     "auto_download_enabled": true
+   }
+   ```
+
+3. Check download manager has capacity
+
+### Circular Import Errors
+
+The system uses lazy initialization to avoid circular imports:
+- `EpisodeChecker.set_download_manager()` is called by `main.py`
+- Do not import `download_manager` directly in other modules
+
+## 📊 Future Enhancements
+
+Potential improvements:
+
+1. **Notifications**: Email, Telegram, Discord alerts
+2. **Quality Selection**: Choose 1080p/720p/480p per anime
+3. **Smart Detection**: Detect completed anime automatically
+4. **Batch Operations**: Add multiple anime at once
+5. **Calendar View**: Visual schedule of episode releases
+6. **Statistics Dashboard**: Charts of download history
+7. **RSS Feeds**: Generate RSS feeds for watchlist
+8. **Watchlist Sharing**: Share lists between users
+
+## 📝 Notes
+
+- The scheduler runs in the background and is started/stopped via API
+- All operations are per-user (multi-tenant)
+- Failed downloads are logged but don't stop the scheduler
+- The system is resilient to temporary network failures
+- Watchlist data is persisted in JSON format for easy backup

main.py

@@ -32,9 +32,21 @@ from app.models.sonarr import (
     SonarrDownloadRequest
 )
 from app.models.auth import UserCreate, UserLogin, User, Token
-from app.auth import user_manager, create_access_token, verify_token, get_current_user
+from app.auth import user_manager, create_access_token, verify_token
 from app.utils import sanitize_filename, is_safe_filename
 
+# Watchlist and auto-download
+from app.watchlist import watchlist_manager
+from app.episode_checker import episode_checker
+from app.auto_download_scheduler import auto_download_scheduler
+from app.models.watchlist import (
+    WatchlistItem,
+    WatchlistItemCreate,
+    WatchlistItemUpdate,
+    WatchlistStatus,
+    WatchlistSettings
+)
+
 # Security
 security = HTTPBearer()
 
@@ -57,6 +69,20 @@ app.add_middleware(
 # Initialize download manager
 download_manager = DownloadManager(download_dir="downloads", max_parallel=3)
 
+# Initialize episode checker with download manager
+episode_checker.set_download_manager(download_manager)
+
+
+@app.on_event("startup")
+async def startup_event():
+    from app.sonarr_handler import get_sonarr_handler
+    sonarr_handler = get_sonarr_handler()
+    sonarr_handler.set_download_manager(download_manager)
+    
+    from app.auto_download_scheduler import auto_download_scheduler
+    auto_download_scheduler.start()
+    logger.info("Application started: Sonarr handler and scheduler initialized")
+
 
 def restore_completed_downloads():
     """Scan downloads directory and restore completed download tasks"""
@@ -171,15 +197,16 @@ async def get_current_user_from_token(credentials: HTTPAuthorizationCredentials
             headers={"WWW-Authenticate": "Bearer"},
         )
 
-    user = user_manager.get_user(username)
-    if user is None:
+    user_dict = user_manager.get_user(username)
+    if user_dict is None:
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="User not found",
             headers={"WWW-Authenticate": "Bearer"},
         )
 
-    return user
+    # Convert dict to User Pydantic model
+    return User(**user_dict)
 
 
 @app.post("/api/auth/register")
@@ -279,7 +306,7 @@ async def login(form_data: UserLogin):
 
 
 @app.get("/api/auth/me")
-async def get_me(current_user: dict = Depends(get_current_user_from_token)):
+async def get_me(current_user: User = Depends(get_current_user_from_token)):
     """
     Get current user information
 
@@ -288,13 +315,13 @@ async def get_me(current_user: dict = Depends(get_current_user_from_token)):
     """
     return {
         "user": {
-            "id": current_user["id"],
-            "username": current_user["username"],
-            "email": current_user.get("email"),
-            "full_name": current_user.get("full_name"),
-            "is_active": current_user.get("is_active", True),
-            "created_at": current_user.get("created_at"),
-            "last_login": current_user.get("last_login")
+            "id": current_user.id,
+            "username": current_user.username,
+            "email": current_user.email,
+            "full_name": current_user.full_name,
+            "is_active": current_user.is_active,
+            "created_at": current_user.created_at,
+            "last_login": current_user.last_login
         }
     }
 
@@ -331,6 +358,12 @@ async def login_page(request: Request):
     return templates.TemplateResponse("login.html", {"request": request})
 
 
+@app.get("/watchlist")
+async def watchlist_page(request: Request):
+    """Watchlist management page"""
+    return templates.TemplateResponse("watchlist.html", {"request": request})
+
+
 # API Endpoints
 @app.post("/api/download")
 async def create_download(request: DownloadRequest, background_tasks: BackgroundTasks):
@@ -1780,6 +1813,312 @@ async def trigger_sonarr_download(request: SonarrDownloadRequest, background_tas
         raise HTTPException(status_code=500, detail=str(e))
 
 
+# ================================
+# WATCHLIST & AUTO-DOWNLOAD ENDPOINTS
+# ================================
+
+@app.post("/api/watchlist", response_model=WatchlistItem, tags=["Watchlist"])
+async def add_to_watchlist(
+    item_data: WatchlistItemCreate,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Add an anime to the watchlist for automatic episode tracking"""
+    try:
+        item = watchlist_manager.create(current_user.id, item_data)
+        return item
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.error(f"Error adding to watchlist: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/watchlist", response_model=List[WatchlistItem], tags=["Watchlist"])
+async def get_watchlist(
+    status: Optional[WatchlistStatus] = None,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Get user's watchlist, optionally filtered by status"""
+    try:
+        items = watchlist_manager.get_all(user_id=current_user.id, status=status)
+        return items
+    except Exception as e:
+        logger.error(f"Error getting watchlist: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/watchlist/settings", response_model=WatchlistSettings, tags=["Watchlist"])
+async def get_watchlist_settings(
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Get global watchlist settings"""
+    try:
+        settings = watchlist_manager.get_settings()
+        return settings
+    except Exception as e:
+        logger.error(f"Error getting watchlist settings: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/watchlist/settings", response_model=WatchlistSettings, tags=["Watchlist"])
+async def update_watchlist_settings(
+    settings: WatchlistSettings,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Update global watchlist settings"""
+    try:
+        updated_settings = watchlist_manager.update_settings(settings)
+
+        # Restart scheduler with new interval if it's running
+        if auto_download_scheduler.is_running():
+            auto_download_scheduler.restart()
+
+        return updated_settings
+    except Exception as e:
+        logger.error(f"Error updating watchlist settings: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/watchlist/stats", tags=["Watchlist"])
+async def get_watchlist_stats(
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Get watchlist statistics"""
+    try:
+        stats = watchlist_manager.get_stats(user_id=current_user.id)
+        return stats
+    except Exception as e:
+        logger.error(f"Error getting watchlist stats: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/watchlist/check-all", tags=["Watchlist"])
+async def check_all_watchlist_items(
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Manually trigger a check for all due watchlist items"""
+    try:
+        results = await episode_checker.check_all_due()
+
+        # Filter results to only show user's items
+        user_results = []
+        for result in results:
+            item = watchlist_manager.get_by_id(result.watchlist_item_id)
+            if item and item.user_id == current_user.id:
+                user_results.append(result)
+
+        return {
+            "status": "success",
+            "checked": len(user_results),
+            "total_new_episodes": sum(r.new_episodes_found for r in user_results),
+            "total_downloaded": sum(len(r.episodes_downloaded) for r in user_results),
+            "results": user_results
+        }
+    except Exception as e:
+        logger.error(f"Error checking all watchlist items: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/watchlist/scheduler/status", tags=["Watchlist"])
+async def get_scheduler_status(
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Get auto-download scheduler status"""
+    try:
+        return {
+            "running": auto_download_scheduler.is_running(),
+            "next_run": auto_download_scheduler.get_next_run_time(),
+            "settings": watchlist_manager.get_settings()
+        }
+    except Exception as e:
+        logger.error(f"Error getting scheduler status: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/watchlist/scheduler/start", tags=["Watchlist"])
+async def start_scheduler(
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Start the auto-download scheduler"""
+    try:
+        if auto_download_scheduler.is_running():
+            return {"status": "already_running", "message": "Scheduler is already running"}
+
+        auto_download_scheduler.start()
+        return {"status": "started", "message": "Scheduler started successfully"}
+    except Exception as e:
+        logger.error(f"Error starting scheduler: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/watchlist/scheduler/stop", tags=["Watchlist"])
+async def stop_scheduler(
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Stop the auto-download scheduler"""
+    try:
+        if not auto_download_scheduler.is_running():
+            return {"status": "not_running", "message": "Scheduler is not running"}
+
+        auto_download_scheduler.stop()
+        return {"status": "stopped", "message": "Scheduler stopped successfully"}
+    except Exception as e:
+        logger.error(f"Error stopping scheduler: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/watchlist/{item_id}", response_model=WatchlistItem, tags=["Watchlist"])
+async def get_watchlist_item(
+    item_id: str,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Get a specific watchlist item"""
+    try:
+        item = watchlist_manager.get_by_id(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="Watchlist item not found")
+
+        # Check ownership
+        if item.user_id != current_user.id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        return item
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting watchlist item: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.put("/api/watchlist/{item_id}", response_model=WatchlistItem, tags=["Watchlist"])
+async def update_watchlist_item(
+    item_id: str,
+    update_data: WatchlistItemUpdate,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Update a watchlist item (settings, status, etc.)"""
+    try:
+        item = watchlist_manager.get_by_id(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="Watchlist item not found")
+
+        # Check ownership
+        if item.user_id != current_user.id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        updated_item = watchlist_manager.update(item_id, update_data)
+        return updated_item
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error updating watchlist item: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.delete("/api/watchlist/{item_id}", tags=["Watchlist"])
+async def delete_watchlist_item(
+    item_id: str,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Delete an anime from the watchlist"""
+    try:
+        item = watchlist_manager.get_by_id(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="Watchlist item not found")
+
+        # Check ownership
+        if item.user_id != current_user.id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        success = watchlist_manager.delete(item_id)
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to delete item")
+
+        return {"status": "success", "message": "Item deleted from watchlist"}
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting watchlist item: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/watchlist/{item_id}/check", tags=["Watchlist"])
+async def check_watchlist_item(
+    item_id: str,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Manually trigger a check for new episodes of a specific anime"""
+    try:
+        item = watchlist_manager.get_by_id(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="Watchlist item not found")
+
+        # Check ownership
+        if item.user_id != current_user.id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        result = await episode_checker.manual_check(item_id)
+        if not result:
+            raise HTTPException(status_code=500, detail="Check failed")
+
+        return result
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error checking watchlist item: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/watchlist/{item_id}/pause", response_model=WatchlistItem, tags=["Watchlist"])
+async def pause_watchlist_item(
+    item_id: str,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Pause automatic downloading for a specific anime"""
+    try:
+        item = watchlist_manager.get_by_id(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="Watchlist item not found")
+
+        # Check ownership
+        if item.user_id != current_user.id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        update_data = WatchlistItemUpdate(status=WatchlistStatus.PAUSED)
+        updated_item = watchlist_manager.update(item_id, update_data)
+        return updated_item
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error pausing watchlist item: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/api/watchlist/{item_id}/resume", response_model=WatchlistItem, tags=["Watchlist"])
+async def resume_watchlist_item(
+    item_id: str,
+    current_user: User = Depends(get_current_user_from_token)
+):
+    """Resume automatic downloading for a paused anime"""
+    try:
+        item = watchlist_manager.get_by_id(item_id)
+        if not item:
+            raise HTTPException(status_code=404, detail="Watchlist item not found")
+
+        # Check ownership
+        if item.user_id != current_user.id:
+            raise HTTPException(status_code=403, detail="Access denied")
+
+        update_data = WatchlistItemUpdate(status=WatchlistStatus.ACTIVE)
+        updated_item = watchlist_manager.update(item_id, update_data)
+        return updated_item
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error resuming watchlist item: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 if __name__ == "__main__":
     uvicorn.run(
         "main:app",

requirements.txt

@@ -23,3 +23,6 @@ pytest-html==4.1.1
 passlib[bcrypt]==1.7.4
 python-jose[cryptography]==3.3.0
 bcrypt<4.0
+
+# Scheduler for auto-download
+apscheduler==3.11.0

static/css/style.css

@@ -241,22 +241,24 @@
 
         .anime-card-actions {
             display: flex;
+            flex-direction: column;
             gap: 8px;
             margin-top: 15px;
         }
 
         .anime-card-actions select {
-            flex: 1;
+            width: 100%;
             padding: 8px;
             border: 2px solid rgba(255, 255, 255, 0.1);
             border-radius: 6px;
             background: rgba(0, 0, 0, 0.3);
             color: #fff;
             font-size: 13px;
+            box-sizing: border-box;
         }
 
         .anime-card-actions button {
-            flex: 1;
+            width: 100%;
             padding: 8px 12px;
             font-size: 12px;
         }

static/js/anime-details.js

@@ -62,26 +62,27 @@ async function searchAnimeDetails(query, malId = null) {
             const providersData = await getProvidersInfo();
 
             // Build results HTML
-            streamingHtml = `
-                <div class="streaming-results-header">
+            const streamingParts = [
+                `<div class="streaming-results-header">
                     <h3>🎬 Résultats de streaming</h3>
                 </div>
-                <div class="search-results" style="margin-top: 20px;">
-            `;
+                <div class="search-results" style="margin-top: 20px;">`
+            ];
 
-            // Display results from each provider
+            // Display results from each provider - render all cards in parallel
             for (const [providerId, results] of Object.entries(streamingData.value.results)) {
                 if (results && results.length > 0) {
                     const provider = providersData.anime_providers[providerId];
 
-                    results.forEach((anime) => {
-                        // Use the same renderAnimeCard function from anime.js for consistency
-                        streamingHtml += renderAnimeCard(anime, providerId, provider, 'vostfr');
-                    });
+                    // Render all cards for this provider
+                    const cardPromises = results.map((anime) => renderAnimeCard(anime, providerId, provider, 'vostfr'));
+                    const cards = await Promise.all(cardPromises);
+                    streamingParts.push(...cards);
                 }
             }
 
-            streamingHtml += '</div>';
+            streamingParts.push('</div>');
+            streamingHtml = streamingParts.join('');
         }
 
         // Display results
@@ -149,12 +150,12 @@ async function getProviderSearchResults(query) {
         }
 
         // Build results HTML
-        let html = `
-            <div class="streaming-results-header">
+        const htmlParts = [
+            `<div class="streaming-results-header">
                 <h3>🎬 Résultats de streaming</h3>
             </div>
-            <div class="search-results" style="margin-top: 20px;">
-        `;
+            <div class="search-results" style="margin-top: 20px;">`
+        ];
 
         // Display results from each provider
         for (const [providerId, results] of Object.entries(data.results)) {
@@ -162,16 +163,16 @@ async function getProviderSearchResults(query) {
                 const providersData = await getProvidersInfo();
                 const provider = providersData.anime_providers[providerId];
 
-                results.forEach((anime, index) => {
-                    // Use the same renderAnimeCard function from anime.js for consistency
-                    html += renderAnimeCard(anime, providerId, provider, 'vostfr');
-                });
+                // Render all cards for this provider in parallel
+                const cardPromises = results.map((anime) => renderAnimeCard(anime, providerId, provider, 'vostfr'));
+                const cards = await Promise.all(cardPromises);
+                htmlParts.push(...cards);
             }
         }
 
-        html += '</div>';
+        htmlParts.push('</div>');
 
-        return html;
+        return htmlParts.join('');
 
     } catch (error) {
         console.error('Error getting provider search results:', error);

static/js/anime.js

@@ -10,7 +10,7 @@ async function displaySearchResults(data, lang) {
     const providers = await getProvidersInfo();
 
     let totalResults = 0;
-    let html = '';
+    let htmlPromises = [];
 
     for (const [providerId, results] of Object.entries(data.results)) {
         if (results && results.length > 0) {
@@ -18,18 +18,22 @@ async function displaySearchResults(data, lang) {
 
             results.forEach(anime => {
                 const providerInfo = providers.anime_providers[providerId];
-                html += renderAnimeCard(anime, providerId, providerInfo, lang);
+                // Collect promises for async rendering
+                htmlPromises.push(renderAnimeCard(anime, providerId, providerInfo, lang));
             });
         }
     }
 
     if (totalResults === 0) {
-        html = '<div class="no-results">Aucun résultat trouvé</div>';
+        resultsContainer.innerHTML = '<div class="no-results">Aucun résultat trouvé</div>';
+        return;
     }
 
-    resultsContainer.innerHTML = html;
+    // Wait for all cards to be rendered
+    const htmlSegments = await Promise.all(htmlPromises);
+    resultsContainer.innerHTML = htmlSegments.join('');
 
-    // Auto-load seasons (for Anime-Sama) or episodes for each anime
+    // Auto-load seasons for providers that support them
     // Stagger the requests to avoid overwhelming the server
     let delayCounter = 0;
     for (const [providerId, results] of Object.entries(data.results)) {
@@ -37,7 +41,7 @@ async function displaySearchResults(data, lang) {
             results.forEach((anime, index) => {
                 // Stagger requests: 500ms delay between each anime
                 setTimeout(() => {
-                    // Try to load seasons first (for Anime-Sama)
+                    // Try to load seasons first (if provider supports them)
                     if (anime.url) {
                         loadSeasonsForAnime(providerId, encodeURIComponent(anime.url));
                     }
@@ -51,14 +55,14 @@ async function displaySearchResults(data, lang) {
 /**
  * Render anime card HTML
  */
-function renderAnimeCard(anime, providerId, providerInfo, lang) {
+async function renderAnimeCard(anime, providerId, providerInfo, lang) {
     const metadataHtml = renderAnimeMetadata(anime.metadata);
 
-    // Check if this is Anime-Sama (for season support)
-    const isAnimeSama = providerId === 'animesama' || anime.url?.includes('anime-sama');
+    // Check if provider supports seasons using helper function
+    const supportsSeasons = await providerSupportsSeasons(providerId, anime.url);
 
-    const seasonSelectHtml = isAnimeSama ? `
-        <select id="seasons-${providerId}-${encodeURIComponent(anime.url)}" onchange="handleSeasonChange('${providerId}', '${encodeURIComponent(anime.url)}', '${lang}')" style="margin-bottom: 8px;">
+    const seasonSelectHtml = supportsSeasons ? `
+        <select id="seasons-${providerId}-${encodeURIComponent(anime.url)}" onchange="handleSeasonChange('${providerId}', '${encodeURIComponent(anime.url)}', '${lang}')" style="margin-bottom: 8px; width: 100%; padding: 8px; background: rgba(0,0,0,0.3); border: 1px solid rgba(255,255,255,0.2); border-radius: 6px; color: #fff; font-size: 14px;">
             <option value="">Chargement des saisons...</option>
         </select>
     ` : '';
@@ -72,8 +76,10 @@ function renderAnimeCard(anime, providerId, providerInfo, lang) {
             ${metadataHtml}
             <div class="anime-card-actions">
                 ${seasonSelectHtml}
-                <select id="episodes-${providerId}-${encodeURIComponent(anime.url)}">
-                    <option value="">${isAnimeSama ? 'Sélectionner une saison d\'abord' : 'Charger les épisodes...'}</option>
+                <select id="episodes-${providerId}-${encodeURIComponent(anime.url)}"
+                        onclick="${!supportsSeasons ? `loadEpisodesForAnime('${providerId}', '${encodeURIComponent(anime.url)}', '${lang}')` : ''}"
+                        onchange="${!supportsSeasons ? `loadEpisodesForAnime('${providerId}', '${encodeURIComponent(anime.url)}', '${lang}')` : ''}">
+                    <option value="">${supportsSeasons ? 'Sélectionner une saison d\'abord' : 'Cliquez pour charger les épisodes...'}</option>
                 </select>
             </div>
             <div class="anime-card-actions" id="actions-${providerId}-${encodeURIComponent(anime.url)}" style="display:none;">
@@ -89,6 +95,16 @@ function renderAnimeCard(anime, providerId, providerInfo, lang) {
                     </svg>
                     Toute la saison
                 </button>
+                <button class="btn-secondary" onclick="handleAddToWatchlist('${encodeURIComponent(anime.url)}', '${providerId}')"
+                        data-watchlist-url="${encodeURIComponent(anime.url)}"
+                        style="background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border: none; padding: 6px 16px; font-size: 13px; border-radius: 6px; cursor: pointer; transition: all 0.2s;"
+                        onmouseover="this.style.transform='scale(1.05)'"
+                        onmouseout="this.style.transform='scale(1)'">
+                    <svg fill="none" stroke="currentColor" viewBox="0 0 24 24" style="width:14px;height:14px;margin-right:4px;vertical-align:middle;">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4.318 6.318a4.5 4.5 0 000 6.364L12 20.364l7.682-7.682a4.5 4.5 0 00-6.364 0z"></path>
+                    </svg>
+                    <span style="font-weight:500;">+ Suivre</span>
+                </button>
             </div>
         </div>
     `;
@@ -131,21 +147,28 @@ function renderAnimeMetadata(metadata) {
 }
 
 /**
- * Load seasons for Anime-Sama anime
+ * Load seasons for anime (if provider supports it)
  */
 async function loadSeasonsForAnime(providerId, encodedUrl) {
     const url = decodeURIComponent(encodedUrl);
     const seasonSelectId = `seasons-${providerId}-${encodedUrl}`;
 
     const seasonSelectElement = document.getElementById(seasonSelectId);
-    if (!seasonSelectElement) return;
+    if (!seasonSelectElement) {
+        console.log('Season select element not found:', seasonSelectId);
+        return;
+    }
 
-    // Only proceed if this is Anime-Sama
-    if (!url.includes('anime-sama')) {
+    // Check if provider supports seasons
+    const supportsSeasons = await providerSupportsSeasons(providerId, url);
+    if (!supportsSeasons) {
+        console.log('Provider does not support seasons:', providerId);
         seasonSelectElement.style.display = 'none';
         return;
     }
 
+    console.log('Loading seasons for:', url, 'Element:', seasonSelectId);
+
     // Mark as loading to prevent duplicate requests
     if (seasonSelectElement.dataset.loading === 'true') {
         console.log('Season loading already in progress, skipping...');
@@ -181,8 +204,10 @@ async function loadSeasonsForAnime(providerId, encodedUrl) {
                 });
 
                 console.log(`Loaded ${data.seasons.length} seasons`);
+                seasonSelectElement.style.display = 'block';
             } else {
                 // No seasons found, hide season selector and load episodes directly
+                console.log('No seasons found, hiding selector');
                 seasonSelectElement.style.display = 'none';
                 loadEpisodesForAnime(providerId, encodedUrl, 'vostfr');
             }
@@ -363,6 +388,195 @@ async function handleDownloadSeason(encodedUrl, lang) {
     }
 }
 
+/**
+ * Load all seasons and episodes and display them
+ */
+async function loadAllSeasonsAndEpisodes(providerId, encodedUrl, lang) {
+    const url = decodeURIComponent(encodedUrl);
+    const cardId = `anime-${providerId}-${encodedUrl}`;
+    const card = document.getElementById(cardId);
+
+    if (!card) {
+        console.error('Card not found:', cardId);
+        return;
+    }
+
+    // Remove existing all-seasons container if present
+    const existingContainer = document.getElementById(`all-seasons-${providerId}-${encodedUrl}`);
+    if (existingContainer) {
+        existingContainer.remove();
+        return;
+    }
+
+    // Create container for all seasons
+    const container = document.createElement('div');
+    container.id = `all-seasons-${providerId}-${encodedUrl}`;
+    container.style.cssText = 'margin-top: 16px;';
+
+    try {
+        // Fetch all seasons
+        const response = await fetch(`${API_BASE}/anime/seasons?url=${encodeURIComponent(url)}`);
+
+        if (!response.ok) {
+            throw new Error('Failed to fetch seasons');
+        }
+
+        const data = await response.json();
+
+        if (!data.seasons || data.seasons.length === 0) {
+            container.innerHTML = '<div style="padding: 10px; color: #888;">Aucune saison disponible</div>';
+            card.appendChild(container);
+            return;
+        }
+
+        // Create HTML for all seasons
+        let html = '<div style="margin-bottom: 12px;"><strong>Toutes les saisons</strong></div>';
+
+        for (const season of data.seasons) {
+            const seasonId = `season-${encodeURIComponent(season.url)}`;
+
+            html += `
+                <div class="season-block" style="margin-bottom: 12px; padding: 12px; background: rgba(255, 255, 255, 0.05); border-radius: 8px; border: 1px solid rgba(255, 255, 255, 0.1);">
+                    <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 8px;">
+                        <div style="font-weight: 600; color: #00d9ff;">${escapeHtml(season.title)}</div>
+                        <div style="font-size: 12px; color: #888;">${season.episode_count || '?'} épisodes</div>
+                    </div>
+                    <div id="${seasonId}-episodes" style="display: none;">
+                        <select class="episode-select" data-season-url="${escapeHtml(season.url)}" style="width: 100%; margin-bottom: 8px;">
+                            <option value="">Cliquez pour charger les épisodes...</option>
+                        </select>
+                        <div class="season-actions" style="display: none; gap: 8px;">
+                            <button class="btn-primary btn-small" onclick="downloadSeasonEpisode('${encodeURIComponent(season.url)}', '${providerId}', '${lang}')">
+                                📥 Télécharger
+                            </button>
+                            <button class="btn-secondary btn-small" onclick="downloadEntireSeason('${encodeURIComponent(season.url)}', '${lang}')" style="background: linear-gradient(45deg, #ff6b6b, #ffa500);">
+                                📦 Saison complète
+                            </button>
+                        </div>
+                    </div>
+                    <button class="btn-secondary btn-small" onclick="toggleSeasonEpisodes('${seasonId}')" style="width: 100%;">
+                        ▼ Afficher les épisodes
+                    </button>
+                </div>
+            `;
+        }
+
+        container.innerHTML = html;
+        card.appendChild(container);
+
+    } catch (error) {
+        console.error('Error loading all seasons:', error);
+        container.innerHTML = '<div style="padding: 10px; color: #ff6b6b;">Erreur de chargement des saisons</div>';
+        card.appendChild(container);
+    }
+}
+
+/**
+ * Toggle season episodes visibility
+ */
+function toggleSeasonEpisodes(seasonId) {
+    const episodesDiv = document.getElementById(`${seasonId}-episodes`);
+    const button = episodesDiv.parentElement.querySelector('button[onclick^="toggleSeasonEpisodes"]');
+
+    if (episodesDiv.style.display === 'none') {
+        episodesDiv.style.display = 'block';
+        button.textContent = '▲ Masquer les épisodes';
+
+        // Load episodes if not already loaded
+        const select = episodesDiv.querySelector('.episode-select');
+        if (select && select.options.length <= 1) {
+            const seasonUrl = select.dataset.seasonUrl;
+            loadSeasonEpisodes(seasonUrl, select);
+        }
+    } else {
+        episodesDiv.style.display = 'none';
+        button.textContent = '▼ Afficher les épisodes';
+    }
+}
+
+/**
+ * Load episodes for a specific season
+ */
+async function loadSeasonEpisodes(seasonUrl, selectElement) {
+    try {
+        selectElement.innerHTML = '<option value="">Chargement...</option>';
+        selectElement.disabled = true;
+
+        const data = await loadEpisodes(decodeURIComponent(seasonUrl), 'vostfr');
+
+        if (data.episodes && data.episodes.length > 0) {
+            selectElement.innerHTML = '<option value="">Sélectionner un épisode</option>';
+            data.episodes.forEach(ep => {
+                const option = document.createElement('option');
+                option.value = ep.url;
+                option.textContent = `Épisode ${ep.episode}`;
+                selectElement.appendChild(option);
+            });
+            selectElement.disabled = false;
+
+            // Show action buttons
+            const actionsDiv = selectElement.parentElement.querySelector('.season-actions');
+            if (actionsDiv) {
+                actionsDiv.style.display = 'flex';
+            }
+        } else {
+            selectElement.innerHTML = '<option value="">Aucun épisode disponible</option>';
+        }
+    } catch (error) {
+        console.error('Error loading episodes:', error);
+        selectElement.innerHTML = '<option value="">Erreur de chargement</option>';
+    }
+}
+
+/**
+ * Download selected episode from season
+ */
+async function downloadSeasonEpisode(encodedSeasonUrl, providerId, lang) {
+    const seasonUrl = decodeURIComponent(encodedSeasonUrl);
+    const selectElement = document.querySelector(`[data-season-url="${seasonUrl}"]`);
+
+    if (!selectElement) {
+        console.error('Select element not found');
+        return;
+    }
+
+    const episodeUrl = selectElement.value;
+    if (!episodeUrl) {
+        alert('Veuillez sélectionner un épisode');
+        return;
+    }
+
+    try {
+        await downloadEpisode(episodeUrl);
+        loadDownloads();
+        alert('Téléchargement démarré!');
+        selectElement.value = '';
+    } catch (error) {
+        console.error('Download error:', error);
+        alert('Erreur lors du démarrage du téléchargement');
+    }
+}
+
+/**
+ * Download entire season
+ */
+async function downloadEntireSeason(encodedSeasonUrl, lang) {
+    const seasonUrl = decodeURIComponent(encodedSeasonUrl);
+
+    if (!confirm(`⚠️ Attention: Vous allez télécharger toute cette saison. Cela peut prendre du temps et utiliser beaucoup d'espace disque.\n\nVoulez-vous continuer ?`)) {
+        return;
+    }
+
+    try {
+        const data = await downloadSeason(seasonUrl, lang);
+        loadDownloads();
+        alert(`✅ ${data.message}\n\n${data.total_episodes} épisodes ont été ajoutés à la file de téléchargement!`);
+    } catch (error) {
+        console.error('Season download error:', error);
+        alert('Erreur lors du démarrage du téléchargement de la saison');
+    }
+}
+
 /**
  * Handle search form submission
  */
@@ -419,3 +633,8 @@ window.handleDownloadEpisode = handleDownloadEpisode;
 window.handleDownloadSeason = handleDownloadSeason;
 window.handleSearch = handleSearch;
 window.handleDirectDownload = handleDirectDownload;
+window.loadAllSeasonsAndEpisodes = loadAllSeasonsAndEpisodes;
+window.toggleSeasonEpisodes = toggleSeasonEpisodes;
+window.loadSeasonEpisodes = loadSeasonEpisodes;
+window.downloadSeasonEpisode = downloadSeasonEpisode;
+window.downloadEntireSeason = downloadEntireSeason;

static/js/api.js

@@ -15,6 +15,50 @@ async function getProvidersInfo() {
     return searchResultsCache.providers;
 }
 
+/**
+ * Check if a provider supports seasons (helper function)
+ * @param {string} providerId - The provider ID (e.g., 'animesama')
+ * @param {string} url - Optional URL to check for provider support
+ * @returns {Promise<boolean>} - True if provider supports seasons
+ */
+async function providerSupportsSeasons(providerId, url = null) {
+    try {
+        const providers = await getProvidersInfo();
+
+        // Check if provider ID exists in anime_providers
+        if (providers.anime_providers && providers.anime_providers[providerId]) {
+            const provider = providers.anime_providers[providerId];
+            // Check if provider has explicit supports_seasons flag
+            if (typeof provider.supports_seasons === 'boolean') {
+                return provider.supports_seasons;
+            }
+            // Otherwise, check by provider ID (known season-supporting providers)
+            return ['anime-sama', 'anime-ultime', 'french-manga'].includes(providerId);
+        }
+
+        // Fallback: check URL if provided
+        if (url) {
+            const lowerUrl = url.toLowerCase();
+            // Check all anime provider domains
+            for (const [pid, provider] of Object.entries(providers.anime_providers || {})) {
+                if (provider.domains) {
+                    for (const domain of provider.domains) {
+                        if (lowerUrl.includes(domain.toLowerCase())) {
+                            // Re-check with detected provider ID
+                            return providerSupportsSeasons(pid);
+                        }
+                    }
+                }
+            }
+        }
+
+        return false;
+    } catch (error) {
+        console.error('Error checking provider season support:', error);
+        return false;
+    }
+}
+
 /**
  * Search anime across all providers
  */
@@ -152,6 +196,7 @@ async function cancelDownload(id) {
 
 // Make functions available globally
 window.getProvidersInfo = getProvidersInfo;
+window.providerSupportsSeasons = providerSupportsSeasons;
 window.searchAnime = searchAnime;
 window.loadEpisodes = loadEpisodes;
 window.downloadEpisode = downloadEpisode;

static/js/tabs.js

@@ -385,6 +385,9 @@ document.addEventListener('DOMContentLoaded', () => {
                             loadProvidersGrid();
                             window.providersTabLoaded = true;
                         }
+                    } else if (tabName === 'watchlist') {
+                        // Watchlist is handled by its own page
+                        window.location.href = '/watchlist';
                     }
                 }, 100);
             };

static/js/watchlist-ui.js

@@ -0,0 +1,331 @@
+/**
+ * Watchlist UI functions
+ */
+
+/**
+ * Display watchlist items
+ */
+async function displayWatchlist(status = null) {
+    const container = document.getElementById('watchlistContainer');
+    if (!container) return;
+
+    try {
+        container.innerHTML = '<div class="loading">Chargement de la watchlist...</div>';
+
+        const items = await getWatchlist(status);
+        const stats = await getWatchlistStats();
+
+        if (items.length === 0) {
+            container.innerHTML = `
+                <div class="empty-watchlist">
+                    <div style="text-align: center; padding: 60px 20px;">
+                        <svg style="width:80px;height:80px;margin:0 auto 20px;opacity:0.3" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="1" d="M15 17h5l-1.405-1.405A2.032 2.032 0 018.138 7.702 10.78 1.478 1.482-1.478-10.78-1.478 1.478-8.138 1.478-1.478 1.478-1.478-8.138 1.478-1.478 1.478-8.138 1.478z"></path>
+                        </svg>
+                        <h3 style="color: #666; margin-bottom: 10px;">Aucun anime dans votre watchlist</h3>
+                        <p style="color: #999;">Ajoutez des animes depuis la recherche pour commencer le suivi automatique</p>
+                    </div>
+                </div>
+            `;
+            return;
+        }
+
+        // Render stats
+        let statsHtml = '';
+        if (stats && stats.total > 0) {
+            statsHtml = `
+                <div class="watchlist-stats" style="display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 15px; margin-bottom: 30px;">
+                    <div class="stat-card" style="background: rgba(0, 217, 255, 0.1); padding: 15px; border-radius: 10px; text-align: center;">
+                        <div class="stat-value" style="font-size: 32px; font-weight: bold; color: #00d9ff;">${stats.total}</div>
+                        <div class="stat-label" style="font-size: 12px; color: #999; text-transform: uppercase; margin-top: 5px;">Total</div>
+                    </div>
+                    <div class="stat-card" style="background: rgba(76, 175, 80, 0.1); padding: 15px; border-radius: 10px; text-align: center;">
+                        <div class="stat-value" style="font-size: 32px; font-weight: bold; color: #4caf50;">${stats.active}</div>
+                        <div class="stat-label" style="font-size: 12px; color: #999; text-transform: uppercase; margin-top: 5px;">Actifs</div>
+                    </div>
+                    <div class="stat-card" style="background: rgba(255, 152, 0, 0.1); padding: 15px; border-radius: 10px; text-align: center;">
+                        <div class="stat-value" style="font-size: 32px; font-weight: bold; color: #ff9800;">${stats.paused}</div>
+                        <div class="stat-label" style="font-size: 12px; color: #999; text-transform: uppercase; margin-top: 5px;">En pause</div>
+                    </div>
+                    <div class="stat-card" style="background: rgba(158, 158, 158, 0.1); padding: 15px; border-radius: 10px; text-align: center;">
+                        <div class="stat-value" style="font-size: 32px; font-weight: bold; color: #9e9e9e;">${stats.completed}</div>
+                        <div class="stat-label" style="font-size: 12px; color: #999; text-transform: uppercase; margin-top: 5px;">Terminés</div>
+                    </div>
+                </div>
+            `;
+        }
+
+        // Render items
+        let itemsHtml = '';
+        items.forEach(item => {
+            const statusIcon = getStatusIcon(item.status);
+            const statusBadge = getStatusBadge(item.status);
+            const lastEpInfo = item.last_episode_downloaded > 0
+                ? `<span style="color: #999;">Dernier épisode: ${item.last_episode_downloaded}</span>`
+                : '';
+
+            itemsHtml += `
+                <div class="watchlist-item" id="watchlist-${item.id}" style="background: rgba(255,255,255,0.05); border-radius: 12px; padding: 20px; margin-bottom: 15px; border: 1px solid rgba(255,255,255,0.1);">
+                    <div style="display: flex; justify-content: space-between; align-items: start; gap: 20px;">
+                        <div style="flex: 1;">
+                            <div style="display: flex; align-items: center; gap: 10px; margin-bottom: 10px;">
+                                <h3 style="color: #fff; margin: 0; font-size: 18px;">${escapeHtml(item.anime_title)}</h3>
+                                ${statusBadge}
+                            </div>
+
+                            <div style="font-size: 13px; color: #999; margin-bottom: 8px;">
+                                ${statusIcon} ${item.provider_id} • ${item.lang.toUpperCase()}
+                            </div>
+
+                            ${lastEpInfo ? `
+                                <div style="font-size: 12px; color: #999; margin-bottom: 8px;">
+                                    ${lastEpInfo}
+                                </div>
+                            ` : ''}
+
+                            ${item.last_checked ? `
+                                <div style="font-size: 12px; color: #666;">
+                                    Dernière vérification: ${new Date(item.last_checked).toLocaleString('fr-FR')}
+                                </div>
+                            ` : '<div style="font-size: 12px; color: #666;">Jamais vérifié</div>'}
+                        </div>
+
+                        <div style="display: flex; flex-direction: column; gap: 8px;">
+                            ${item.status === 'active' && item.auto_download ? `
+                                <button class="btn-secondary btn-small" onclick="handlePauseWatchlist('${item.id}')" style="padding: 6px 12px; font-size: 12px;" title="Mettre en pause">
+                                    ⏸️ Pause
+                                </button>
+                            ` : item.status === 'paused' ? `
+                                <button class="btn-primary btn-small" onclick="handleResumeWatchlist('${item.id}')" style="padding: 6px 12px; font-size: 12px;" title="Reprendre">
+                                    ▶️ Reprendre
+                                </button>
+                            ` : ''}
+
+                            <button class="btn-secondary btn-small" onclick="handleCheckItem('${item.id}')" style="padding: 6px 12px; font-size: 12px;" title="Vérifier maintenant">
+                                🔍 Vérifier
+                            </button>
+
+                            <button class="btn-secondary btn-small" onclick="handleDeleteWatchlist('${item.id}')" style="padding: 6px 12px; font-size: 12px; background: rgba(244, 67, 54, 0.2); border-color: rgba(244, 67, 54, 0.5);" title="Supprimer">
+                                🗑️
+                            </button>
+                        </div>
+                    </div>
+
+                    ${item.synopsis ? `
+                        <details style="margin-top: 15px;">
+                            <summary style="cursor: pointer; color: #999; font-size: 13px; padding: 5px 0;">📖 Synopsis</summary>
+                            <p style="color: #ccc; font-size: 13px; line-height: 1.5; margin-top: 10px;">${escapeHtml(item.synopsis)}</p>
+                        </details>
+                    ` : ''}
+                </div>
+            `;
+        });
+
+        container.innerHTML = statsHtml + itemsHtml;
+
+    } catch (error) {
+        console.error('Error loading watchlist:', error);
+        container.innerHTML = `
+            <div class="error-message" style="text-align: center; padding: 40px; color: #f44;">
+                ❌ Erreur lors du chargement: ${error.message}
+            </div>
+        `;
+    }
+}
+
+/**
+ * Get status icon
+ */
+function getStatusIcon(status) {
+    const icons = {
+        'active': '✅',
+        'paused': '⏸️',
+        'completed': '✨',
+        'archived': '📦'
+    };
+    return icons[status] || '📌';
+}
+
+/**
+ * Get status badge
+ */
+function getStatusBadge(status) {
+    const badges = {
+        'active': '<span style="background: rgba(76, 175, 80, 0.2); color: #4caf50; padding: 3px 10px; border-radius: 12px; font-size: 11px; text-transform: uppercase;">Actif</span>',
+        'paused': '<span style="background: rgba(255, 152, 0, 0.2); color: #ff9800; padding: 3px 10px; border-radius: 12px; font-size: 11px; text-transform: uppercase;">En pause</span>',
+        'completed': '<span style="background: rgba(158, 158, 158, 0.2); color: #9e9e9e; padding: 3px 10px; border-radius: 12px; font-size: 11px; text-transform: uppercase;">Terminé</span>',
+        'archived': '<span style="background: rgba(33, 150, 243, 0.2); color: #2196f3; padding: 3px 10px; border-radius: 12px; font-size: 11px; text-transform: uppercase;">Archivé</span>'
+    };
+    return badges[status] || '';
+}
+
+/**
+ * Add anime to watchlist from search results
+ */
+async function handleAddToWatchlist(animeUrl, providerId) {
+    try {
+        // Get anime details from the DOM or API
+        const response = await fetch(`${API_BASE}/anime/metadata?url=${encodeURIComponent(animeUrl)}`);
+
+        if (!response.ok) {
+            throw new Error('Failed to fetch anime details');
+        }
+
+        const metadata = await response.json();
+
+        const itemData = {
+            anime_title: metadata.title || 'Unknown Anime',
+            anime_url: animeUrl,
+            provider_id: providerId,
+            lang: 'vostfr',
+            auto_download: true,
+            quality_preference: 'auto',
+            poster_image: metadata.poster_image || null,
+            cover_image: metadata.cover_image || null,
+            synopsis: metadata.synopsis || null,
+            genres: metadata.genres || []
+        };
+
+        const result = await addToWatchlist(itemData);
+
+        alert(`✅ "${result.anime_title}" a été ajouté à votre watchlist!`);
+
+        // Update button to show it's already in watchlist
+        updateAddButton(animeUrl, true);
+
+    } catch (error) {
+        console.error('Error adding to watchlist:', error);
+        alert(`❌ Erreur: ${error.message}`);
+    }
+}
+
+/**
+ * Update add button state
+ */
+function updateAddButton(animeUrl, isInWatchlist) {
+    // Find all buttons for this anime
+    const buttons = document.querySelectorAll(`[data-watchlist-url="${encodeURIComponent(animeUrl)}"]`);
+
+    buttons.forEach(button => {
+        if (isInWatchlist) {
+            button.innerHTML = '✓ Suivi';
+            button.disabled = true;
+            button.style.opacity = '0.6';
+        } else {
+            button.innerHTML = '+ Suivre';
+            button.disabled = false;
+            button.style.opacity = '1';
+        }
+    });
+}
+
+/**
+ * Pause watchlist item
+ */
+async function handlePauseWatchlist(itemId) {
+    try {
+        await pauseWatchlistItem(itemId);
+        await displayWatchlist();
+        alert('✅ Anime mis en pause');
+    } catch (error) {
+        console.error('Error pausing item:', error);
+        alert(`❌ Erreur: ${error.message}`);
+    }
+}
+
+/**
+ * Resume watchlist item
+ */
+async function handleResumeWatchlist(itemId) {
+    try {
+        await resumeWatchlistItem(itemId);
+        await displayWatchlist();
+        alert('✅ Anime réactivé');
+    } catch (error) {
+        console.error('Error resuming item:', error);
+        alert(`❌ Erreur: ${error.message}`);
+    }
+}
+
+/**
+ * Check specific item
+ */
+async function handleCheckItem(itemId) {
+    const button = event.target;
+    const originalText = button.innerHTML;
+
+    try {
+        button.disabled = true;
+        button.innerHTML = '⏳...';
+
+        const result = await checkWatchlistItem(itemId);
+
+        if (result.new_episodes_found > 0) {
+            alert(`🎉 ${result.new_episodes_found} nouveau(x) épisode(s) trouvé(s)!\n\n${result.episodes_downloaded.length} téléchargé(s)`);
+        } else {
+            alert('ℹ️ Aucun nouvel épisode trouvé');
+        }
+
+        await displayWatchlist();
+
+    } catch (error) {
+        console.error('Error checking item:', error);
+        alert(`❌ Erreur: ${error.message}`);
+    } finally {
+        button.disabled = false;
+        button.innerHTML = originalText;
+    }
+}
+
+/**
+ * Delete watchlist item
+ */
+async function handleDeleteWatchlist(itemId) {
+    if (!confirm('⚠️ Êtes-vous sûr de vouloir supprimer cet anime de votre watchlist ?')) {
+        return;
+    }
+
+    try {
+        await deleteFromWatchlist(itemId);
+        await displayWatchlist();
+        alert('✅ Anime supprimé de la watchlist');
+    } catch (error) {
+        console.error('Error deleting item:', error);
+        alert(`❌ Erreur: ${error.message}`);
+    }
+}
+
+/**
+ * Check all items
+ */
+async function handleCheckAll() {
+    const button = event.target;
+    const originalText = button.innerHTML;
+
+    try {
+        button.disabled = true;
+        button.innerHTML = '⏳ Vérification...';
+
+        const result = await checkAllWatchlistItems();
+
+        alert(`✅ Vérification terminée!\n\n${result.checked} animes vérifiés\n${result.total_new_episodes} nouveaux épisodes trouvés\n${result.total_downloaded} téléchargés`);
+
+        await displayWatchlist();
+
+    } catch (error) {
+        console.error('Error checking all:', error);
+        alert(`❌ Erreur: ${error.message}`);
+    } finally {
+        button.disabled = false;
+        button.innerHTML = originalText;
+    }
+}
+
+// Make functions available globally
+window.displayWatchlist = displayWatchlist;
+window.handleAddToWatchlist = handleAddToWatchlist;
+window.handlePauseWatchlist = handlePauseWatchlist;
+window.handleResumeWatchlist = handleResumeWatchlist;
+window.handleCheckItem = handleCheckItem;
+window.handleDeleteWatchlist = handleDeleteWatchlist;
+window.handleCheckAll = handleCheckAll;

static/js/watchlist.js

@@ -0,0 +1,318 @@
+/**
+ * Watchlist management and auto-download UI
+ * Note: API_BASE is defined in api.js (loaded before this file)
+ */
+
+/**
+ * Get user's watchlist
+ */
+async function getWatchlist(status = null) {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    let url = `${API_BASE}/watchlist`;
+    if (status) {
+        url += `?status=${status}`;
+    }
+
+    const response = await fetch(url, {
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch watchlist');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Add anime to watchlist
+ */
+async function addToWatchlist(animeData) {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(animeData)
+    });
+
+    if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.detail || 'Failed to add to watchlist');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Update watchlist item
+ */
+async function updateWatchlistItem(itemId, updateData) {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/${itemId}`, {
+        method: 'PUT',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(updateData)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to update watchlist item');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Delete from watchlist
+ */
+async function deleteFromWatchlist(itemId) {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/${itemId}`, {
+        method: 'DELETE',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to delete from watchlist');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Pause watchlist item
+ */
+async function pauseWatchlistItem(itemId) {
+    return await updateWatchlistItem(itemId, { status: 'paused' });
+}
+
+/**
+ * Resume watchlist item
+ */
+async function resumeWatchlistItem(itemId) {
+    return await updateWatchlistItem(itemId, { status: 'active' });
+}
+
+/**
+ * Check specific anime for new episodes
+ */
+async function checkWatchlistItem(itemId) {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/${itemId}/check`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to check for new episodes');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Check all watchlist items
+ */
+async function checkAllWatchlistItems() {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/check-all`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to check all items');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Get watchlist settings
+ */
+async function getWatchlistSettings() {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/settings`, {
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch settings');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Update watchlist settings
+ */
+async function updateWatchlistSettings(settings) {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/settings`, {
+        method: 'PUT',
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(settings)
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to update settings');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Get watchlist statistics
+ */
+async function getWatchlistStats() {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/stats`, {
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch statistics');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Get scheduler status
+ */
+async function getSchedulerStatus() {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/scheduler/status`, {
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to fetch scheduler status');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Start scheduler
+ */
+async function startScheduler() {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/scheduler/start`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to start scheduler');
+    }
+
+    return await response.json();
+}
+
+/**
+ * Stop scheduler
+ */
+async function stopScheduler() {
+    const token = localStorage.getItem('auth_token');
+    if (!token) {
+        throw new Error('Not authenticated');
+    }
+
+    const response = await fetch(`${API_BASE}/watchlist/scheduler/stop`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${token}`
+        }
+    });
+
+    if (!response.ok) {
+        throw new Error('Failed to stop scheduler');
+    }
+
+    return await response.json();
+}
+
+// Make functions available globally
+window.getWatchlist = getWatchlist;
+window.addToWatchlist = addToWatchlist;
+window.updateWatchlistItem = updateWatchlistItem;
+window.deleteFromWatchlist = deleteFromWatchlist;
+window.pauseWatchlistItem = pauseWatchlistItem;
+window.resumeWatchlistItem = resumeWatchlistItem;
+window.checkWatchlistItem = checkWatchlistItem;
+window.checkAllWatchlistItems = checkAllWatchlistItems;
+window.getWatchlistSettings = getWatchlistSettings;
+window.updateWatchlistSettings = updateWatchlistSettings;
+window.getWatchlistStats = getWatchlistStats;
+window.getSchedulerStatus = getSchedulerStatus;
+window.startScheduler = startScheduler;
+window.stopScheduler = stopScheduler;

templates/base.html

@@ -9,16 +9,18 @@
     <link rel="stylesheet" href="/static/css/style.css">
 
     <!-- JavaScript -->
-    <script src="/static/js/auth.js?v=1.9" defer></script>
-    <script src="/static/js/api.js?v=1.9" defer></script>
-    <script src="/static/js/utils.js?v=1.9" defer></script>
-    <script src="/static/js/downloads.js?v=1.9" defer></script>
-    <script src="/static/js/anime.js?v=1.9" defer></script>
-    <script src="/static/js/anime-details.js?v=1.9" defer></script>
-    <script src="/static/js/series-search.js?v=1.9" defer></script>
-    <script src="/static/js/recommendations.js?v=1.9" defer></script>
-    <script src="/static/js/tabs.js?v=1.9" defer></script>
-    <script src="/static/js/main.js?v=1.9" defer></script>
+    <script src="/static/js/auth.js?v=1.10" defer></script>
+    <script src="/static/js/api.js?v=1.11" defer></script>
+    <script src="/static/js/utils.js?v=1.11" defer></script>
+    <script src="/static/js/downloads.js?v=1.11" defer></script>
+    <script src="/static/js/anime.js?v=1.11" defer></script>
+    <script src="/static/js/anime-details.js?v=1.11" defer></script>
+    <script src="/static/js/series-search.js?v=1.11" defer></script>
+    <script src="/static/js/recommendations.js?v=1.11" defer></script>
+    <script src="/static/js/tabs.js?v=1.11" defer></script>
+    <script src="/static/js/watchlist.js?v=1.11" defer></script>
+    <script src="/static/js/watchlist-ui.js?v=1.11" defer></script>
+    <script src="/static/js/main.js?v=1.11" defer></script>
 </head>
 <body>
     <div class="container">

templates/components/header.html

@@ -44,5 +44,11 @@
         </svg>
         Fournisseurs
     </button>
+    <button class="tab" data-tab-type="watchlist" onclick="switchTab('watchlist')">
+        <svg style="width:16px;height:16px;vertical-align:middle;margin-right:5px" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 5H7a2 2 0 00-2 2v12a2 2 0 002 2h10a2 2 0 002-2V7a2 2 0 00-2-2h-2M9 5a2 2 0 002 2h2a2 2 0 002-2M9 5a2 2 0 012-2m0 0a2 2 0 00-2 2h10a2 2 0 002-2V7a2 2 0 00-2-2"></path>
+        </svg>
+        Watchlist
+    </button>
     <!-- Provider tabs will be loaded dynamically after the static tabs -->
 </div>

templates/watchlist.html

@@ -0,0 +1,553 @@
+<!DOCTYPE html>
+<html lang="fr">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Watchlist - Ohm Stream Downloader</title>
+    <link rel="stylesheet" href="/static/css/style.css">
+    <style>
+        body {
+            background: linear-gradient(135deg, #1e1e2e 0%, #2d1b69 0%, #1e1e2e 100%);
+            min-height: 100vh;
+            color: #e0e0e0;
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+        }
+
+        .watchlist-header {
+            background: rgba(0, 217, 255, 0.1);
+            border: 1px solid rgba(0, 217, 255, 0.3);
+            border-radius: 12px;
+            padding: 30px;
+            margin-bottom: 30px;
+            text-align: center;
+        }
+
+        .watchlist-header h1 {
+            color: #00d9ff;
+            margin: 0 0 10px 0;
+            font-size: 28px;
+            font-weight: 600;
+        }
+
+        .watchlist-header p {
+            color: #999;
+            margin: 0;
+            font-size: 14px;
+        }
+
+        .watchlist-controls {
+            display: flex;
+            gap: 15px;
+            justify-content: center;
+            margin-bottom: 30px;
+            flex-wrap: wrap;
+        }
+
+        .watchlist-container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 0 20px 40px;
+        }
+
+        .scheduler-status {
+            background: rgba(0, 217, 255, 0.05);
+            border: 1px solid rgba(0, 217, 255, 0.2);
+            border-radius: 10px;
+            padding: 20px;
+            margin-bottom: 30px;
+        }
+
+        .scheduler-status-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 15px;
+        }
+
+        .scheduler-status h3 {
+            margin: 0;
+            color: #00d9ff;
+            font-size: 18px;
+        }
+
+        .scheduler-controls {
+            display: flex;
+            gap: 10px;
+        }
+
+        .status-indicator {
+            display: inline-flex;
+            align-items: center;
+            gap: 8px;
+            padding: 5px 12px;
+            border-radius: 12px;
+            font-size: 13px;
+        }
+
+        .status-indicator.running {
+            background: rgba(76, 175, 80, 0.2);
+            color: #4caf50;
+        }
+
+        .status-indicator.stopped {
+            background: rgba(244, 67, 54, 0.2);
+            color: #f44;
+        }
+
+        .status-dot {
+            width: 8px;
+            height: 8px;
+            border-radius: 50%;
+        }
+
+        .status-dot.running {
+            background: #4caf50;
+            animation: pulse 2s infinite;
+        }
+
+        .status-dot.stopped {
+            background: #f44;
+        }
+
+        @keyframes pulse {
+            0%, 100% { opacity: 1; }
+            50% { opacity: 0.5; }
+        }
+
+        .next-run-info {
+            font-size: 13px;
+            color: #999;
+            margin-top: 10px;
+        }
+
+        .filter-tabs {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 20px;
+            justify-content: center;
+        }
+
+        .filter-tab {
+            padding: 8px 16px;
+            background: rgba(255, 255, 255, 0.05);
+            border: 1px solid rgba(255, 255, 255, 0.1);
+            border-radius: 8px;
+            color: #ccc;
+            cursor: pointer;
+            transition: all 0.2s;
+        }
+
+        .filter-tab:hover {
+            background: rgba(255, 255, 255, 0.1);
+        }
+
+        .filter-tab.active {
+            background: rgba(0, 217, 255, 0.2);
+            border-color: rgba(0, 217, 255, 0.5);
+            color: #00d9ff;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 60px;
+            color: #999;
+        }
+
+        .empty-watchlist {
+            text-align: center;
+            padding: 80px 20px;
+        }
+
+        .error-message {
+            text-align: center;
+            padding: 40px;
+            color: #f44;
+        }
+
+        .watchlist-item {
+            transition: all 0.3s ease;
+        }
+
+        .watchlist-item:hover {
+            background: rgba(255, 255, 255, 0.08);
+            transform: translateY(-2px);
+        }
+
+        .btn-small {
+            padding: 6px 12px;
+            font-size: 12px;
+        }
+
+        /* Filter tabs at top */
+        .watchlist-header-filter {
+            margin-top: 20px;
+        }
+    </style>
+</head>
+<body>
+    <div class="watchlist-container">
+        <!-- Header -->
+        <div class="watchlist-header">
+            <h1>📋 Ma Watchlist</h1>
+            <p>Suivez vos animes préférés et téléchargez automatiquement les nouveaux épisodes</p>
+        </div>
+
+        <!-- Scheduler Status -->
+        <div class="scheduler-status" id="schedulerStatus">
+            <div class="scheduler-status-header">
+                <div>
+                    <h3>⏰ Planificateur Automatique</h3>
+                    <div id="nextRunInfo" class="next-run-info">Chargement...</div>
+                </div>
+                <div class="scheduler-controls">
+                    <button id="startSchedulerBtn" class="btn-primary btn-small" onclick="handleStartScheduler()" style="display:none;">
+                        ▶️ Démarrer
+                    </button>
+                    <button id="stopSchedulerBtn" class="btn-secondary btn-small" onclick="handleStopScheduler()" style="display:none;">
+                        ⏸️ Arrêter
+                    </button>
+                    <button class="btn-secondary btn-small" onclick="handleCheckAll()">
+                        🔍 Vérifier tout
+                    </button>
+                    <button class="btn-secondary btn-small" onclick="handleOpenSettings()">
+                        ⚙️ Paramètres
+                    </button>
+                </div>
+            </div>
+        </div>
+
+        <!-- Filter Tabs -->
+        <div class="filter-tabs">
+            <button class="filter-tab active" onclick="filterWatchlist('all', this)">Tous</button>
+            <button class="filter-tab" onclick="filterWatchlist('active', this)">Actifs</button>
+            <button class="filter-tab" onclick="filterWatchlist('paused', this)">En pause</button>
+            <button class="filter-tab" onclick="filterWatchlist('completed', this)">Terminés</button>
+        </div>
+
+        <!-- Watchlist Items -->
+        <div id="watchlistContainer">
+            <div class="loading">Chargement de la watchlist...</div>
+        </div>
+    </div>
+
+    <!-- Scripts -->
+    <script src="/static/js/api.js"></script>
+    <script src="/static/js/utils.js"></script>
+    <script src="/static/js/watchlist.js"></script>
+    <script src="/static/js/watchlist-ui.js"></script>
+    <script src="/static/js/auth.js"></script>
+
+    <script>
+        // Current filter
+        let currentFilter = 'all';
+
+        // Load watchlist on page load
+        document.addEventListener('DOMContentLoaded', async () => {
+            await checkAuth();
+            await loadSchedulerStatus();
+            await displayWatchlist();
+        });
+
+        /**
+         * Check authentication
+         */
+        async function checkAuth() {
+            const token = localStorage.getItem('auth_token');
+            if (!token) {
+                window.location.href = '/login';
+                return false;
+            }
+
+            // Verify token with server
+            try {
+                const response = await fetch('/api/auth/me', {
+                    headers: {
+                        'Authorization': `Bearer ${token}`
+                    }
+                });
+
+                if (!response.ok) {
+                    // Token invalid, remove it and redirect
+                    localStorage.removeItem('auth_token');
+                    localStorage.removeItem('user');
+                    window.location.href = '/login';
+                    return false;
+                }
+                return true;
+            } catch (error) {
+                console.error('Auth check error:', error);
+                window.location.href = '/login';
+                return false;
+            }
+        }
+
+        /**
+         * Load scheduler status
+         */
+        async function loadSchedulerStatus() {
+            try {
+                const status = await getSchedulerStatus();
+                updateSchedulerUI(status);
+            } catch (error) {
+                console.error('Error loading scheduler status:', error);
+            }
+        }
+
+        /**
+         * Update scheduler UI
+         */
+        function updateSchedulerUI(status) {
+            const startBtn = document.getElementById('startSchedulerBtn');
+            const stopBtn = document.getElementById('stopSchedulerBtn');
+            const nextRunInfo = document.getElementById('nextRunInfo');
+
+            if (status.running) {
+                startBtn.style.display = 'none';
+                stopBtn.style.display = 'inline-block';
+
+                if (status.next_run) {
+                    const nextRun = new Date(status.next_run);
+                    nextRunInfo.innerHTML = `✓ En cours<br>Prochaine vérification: ${nextRun.toLocaleString('fr-FR')}`;
+                }
+            } else {
+                startBtn.style.display = 'inline-block';
+                stopBtn.style.display = 'none';
+                nextRunInfo.innerHTML = '⏸️ Arrêté';
+            }
+        }
+
+        /**
+         * Filter watchlist
+         */
+        async function filterWatchlist(status, tabElement) {
+            currentFilter = status;
+
+            // Update tab styles
+            document.querySelectorAll('.filter-tab').forEach(tab => {
+                tab.classList.remove('active');
+            });
+            tabElement.classList.add('active');
+
+            // Reload with filter
+            await displayWatchlist(status === 'all' ? null : status);
+        }
+
+        /**
+         * Handle start scheduler
+         */
+        async function handleStartScheduler() {
+            try {
+                await startScheduler();
+                await loadSchedulerStatus();
+                alert('✅ Planificateur démarré!');
+            } catch (error) {
+                console.error('Error starting scheduler:', error);
+                alert(`❌ Erreur: ${error.message}`);
+            }
+        }
+
+        /**
+         * Handle stop scheduler
+         */
+        async function handleStopScheduler() {
+            try {
+                await stopScheduler();
+                await loadSchedulerStatus();
+                alert('✅ Planificateur arrêté!');
+            } catch (error) {
+                console.error('Error stopping scheduler:', error);
+                alert(`❌ Erreur: ${error.message}`);
+            }
+        }
+
+        /**
+         * Handle check all
+         */
+        async function handleCheckAll() {
+            try {
+                await checkAllWatchlistItems();
+                await loadSchedulerStatus();
+            } catch (error) {
+                console.error('Error checking all:', error);
+                alert(`❌ Erreur: ${error.message}`);
+            }
+        }
+
+        /**
+         * Handle open settings
+         */
+        async function handleOpenSettings() {
+            try {
+                const settings = await getWatchlistSettings();
+
+                // Create modal HTML
+                const modalHtml = `
+                    <div id="settingsModal" style="position: fixed; top: 0; left: 0; width: 100%; height: 100%; background: rgba(0,0,0,0.8); display: flex; align-items: center; justify-content: center; z-index: 1000;">
+                        <div style="background: linear-gradient(135deg, #1e1e2e 0%, #2d1b69 100%); border-radius: 16px; padding: 30px; max-width: 500px; width: 90%; border: 1px solid rgba(0, 217, 255, 0.3);">
+                            <div style="display: flex; justify-content: space-between; align-items: center; margin-bottom: 25px;">
+                                <h2 style="margin: 0; color: #00d9ff;">⚙️ Paramètres Watchlist</h2>
+                                <button onclick="closeSettingsModal()" style="background: none; border: none; color: #999; font-size: 24px; cursor: pointer;">×</button>
+                            </div>
+
+                            <div style="display: flex; flex-direction: column; gap: 20px;">
+                                <!-- Check Interval -->
+                                <div>
+                                    <label style="display: block; color: #fff; margin-bottom: 8px; font-weight: 500;">
+                                        🔄 Fréquence de vérification (heures)
+                                    </label>
+                                    <input type="number" id="checkInterval" value="${settings.check_interval_hours}" min="1" max="168"
+                                        style="width: 100%; padding: 10px; background: rgba(0,0,0,0.3); border: 1px solid rgba(255,255,255,0.2); border-radius: 8px; color: #fff; font-size: 14px;">
+                                    <p style="font-size: 12px; color: #999; margin-top: 5px;">Entre 1 et 168 heures (1 semaine)</p>
+                                </div>
+
+                                <!-- Auto-download enabled -->
+                                <div style="display: flex; align-items: center; justify-content: space-between;">
+                                    <div>
+                                        <div style="color: #fff; font-weight: 500;">📥 Téléchargement automatique</div>
+                                        <p style="font-size: 12px; color: #999; margin: 0;">Télécharger automatiquement les nouveaux épisodes</p>
+                                    </div>
+                                    <label class="switch">
+                                        <input type="checkbox" id="autoDownloadEnabled" ${settings.auto_download_enabled ? 'checked' : ''}>
+                                        <span class="slider"></span>
+                                    </label>
+                                </div>
+
+                                <!-- Max concurrent downloads -->
+                                <div>
+                                    <label style="display: block; color: #fff; margin-bottom: 8px; font-weight: 500;">
+                                        ⚡ Téléchargements simultanés max
+                                    </label>
+                                    <input type="number" id="maxConcurrent" value="${settings.max_concurrent_auto_downloads}" min="1" max="5"
+                                        style="width: 100%; padding: 10px; background: rgba(0,0,0,0.3); border: 1px solid rgba(255,255,255,0.2); border-radius: 8px; color: #fff; font-size: 14px;">
+                                    <p style="font-size: 12px; color: #999; margin-top: 5px;">Maximum 5 téléchargements en parallèle</p>
+                                </div>
+
+                                <!-- Notifications -->
+                                <div style="display: flex; align-items: center; justify-content: space-between;">
+                                    <div>
+                                        <div style="color: #fff; font-weight: 500;">🔔 Notifications</div>
+                                        <p style="font-size: 12px; color: #999; margin: 0;">Être notifié des nouveaux épisodes</p>
+                                    </div>
+                                    <label class="switch">
+                                        <input type="checkbox" id="notifyEnabled" ${settings.notify_on_new_episodes ? 'checked' : ''}>
+                                        <span class="slider"></span>
+                                    </label>
+                                </div>
+                            </div>
+
+                            <div style="display: flex; gap: 10px; margin-top: 30px;">
+                                <button class="btn-primary" onclick="saveSettings()" style="flex: 1; padding: 12px; border: none; border-radius: 8px; font-size: 14px; cursor: pointer;">
+                                    💾 Enregistrer
+                                </button>
+                                <button class="btn-secondary" onclick="closeSettingsModal()" style="flex: 1; padding: 12px; background: rgba(255,255,255,0.1); border: 1px solid rgba(255,255,255,0.2); border-radius: 8px; color: #fff; font-size: 14px; cursor: pointer;">
+                                    Annuler
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+
+                    <style>
+                        .switch {
+                            position: relative;
+                            display: inline-block;
+                            width: 50px;
+                            height: 26px;
+                        }
+                        .switch input {
+                            opacity: 0;
+                            width: 0;
+                            height: 0;
+                        }
+                        .slider {
+                            position: absolute;
+                            cursor: pointer;
+                            top: 0;
+                            left: 0;
+                            right: 0;
+                            bottom: 0;
+                            background-color: rgba(255,255,255,0.2);
+                            transition: .4s;
+                            border-radius: 26px;
+                        }
+                        .slider:before {
+                            position: absolute;
+                            content: "";
+                            height: 20px;
+                            width: 20px;
+                            left: 3px;
+                            bottom: 3px;
+                            background-color: white;
+                            transition: .4s;
+                            border-radius: 50%;
+                        }
+                        input:checked + .slider {
+                            background-color: #00d9ff;
+                        }
+                        input:checked + .slider:before {
+                            transform: translateX(24px);
+                        }
+                    </style>
+                `;
+
+                // Add modal to body
+                const modalContainer = document.createElement('div');
+                modalContainer.innerHTML = modalHtml;
+                document.body.appendChild(modalContainer);
+
+            } catch (error) {
+                console.error('Error loading settings:', error);
+                alert(`❌ Erreur: ${error.message}`);
+            }
+        }
+
+        /**
+         * Close settings modal
+         */
+        function closeSettingsModal() {
+            const modal = document.getElementById('settingsModal');
+            if (modal) {
+                modal.remove();
+            }
+        }
+
+        /**
+         * Save settings
+         */
+        async function saveSettings() {
+            try {
+                const checkInterval = parseInt(document.getElementById('checkInterval').value);
+                const autoDownloadEnabled = document.getElementById('autoDownloadEnabled').checked;
+                const maxConcurrent = parseInt(document.getElementById('maxConcurrent').value);
+                const notifyEnabled = document.getElementById('notifyEnabled').checked;
+
+                const settings = {
+                    check_interval_hours: checkInterval,
+                    auto_download_enabled: autoDownloadEnabled,
+                    max_concurrent_auto_downloads: maxConcurrent,
+                    notify_on_new_episodes: notifyEnabled
+                };
+
+                await updateWatchlistSettings(settings);
+
+                // Restart scheduler if it's running to apply new interval
+                const status = await getSchedulerStatus();
+                if (status.running) {
+                    await stopScheduler();
+                    await startScheduler();
+                }
+
+                closeSettingsModal();
+                alert('✅ Paramètres enregistrés avec succès!');
+                await loadSchedulerStatus();
+
+            } catch (error) {
+                console.error('Error saving settings:', error);
+                alert(`❌ Erreur: ${error.message}`);
+            }
+        }
+
+        // Auto-refresh scheduler status every 30 seconds
+        setInterval(loadSchedulerStatus, 30000);
+    </script>
+</body>
+</html>

test_watchlist.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""
+Test script for the watchlist & auto-download system
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add project to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from app.watchlist import watchlist_manager
+from app.episode_checker import episode_checker
+from app.auto_download_scheduler import auto_download_scheduler
+from app.models.watchlist import (
+    WatchlistItemCreate,
+    WatchlistStatus,
+    QualityPreference
+)
+
+
+async def test_watchlist_manager():
+    """Test basic watchlist operations"""
+    print("\n" + "="*60)
+    print("🧪 TEST 1: Watchlist Manager")
+    print("="*60)
+
+    # Test user ID
+    test_user = "test_user_1"
+
+    # Create a test item
+    print("\n1. Creating watchlist item...")
+    item_data = WatchlistItemCreate(
+        anime_title="Test Anime",
+        anime_url="https://anime-sama.si/catalogue/test/vostfr/",
+        provider_id="animesama",
+        lang="vostfr",
+        auto_download=True,
+        quality_preference=QualityPreference.AUTO
+    )
+
+    try:
+        item = watchlist_manager.create(test_user, item_data)
+        print(f"   ✅ Item created: {item.id}")
+        print(f"   Title: {item.anime_title}")
+        print(f"   Status: {item.status}")
+    except Exception as e:
+        print(f"   ❌ Create failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+    # Get all items
+    print("\n2. Getting all items...")
+    try:
+        items = watchlist_manager.get_all(test_user)
+        print(f"   ✅ Found {len(items)} items")
+    except Exception as e:
+        print(f"   ❌ Get all failed: {e}")
+        return False
+
+    # Get stats
+    print("\n3. Getting statistics...")
+    try:
+        stats = watchlist_manager.get_stats(test_user)
+        print(f"   ✅ Stats: {stats}")
+    except Exception as e:
+        print(f"   ❌ Stats failed: {e}")
+        return False
+
+    # Update item
+    print("\n4. Updating item...")
+    try:
+        updated = watchlist_manager.update(item.id, {"status": WatchlistStatus.PAUSED})
+        print(f"   ✅ Item updated to status: {updated.status}")
+    except Exception as e:
+        print(f"   ❌ Update failed: {e}")
+        return False
+
+    # Delete item
+    print("\n5. Deleting item...")
+    try:
+        result = watchlist_manager.delete(item.id)
+        print(f"   ✅ Item deleted: {result}")
+    except Exception as e:
+        print(f"   ❌ Delete failed: {e}")
+        return False
+
+    print("\n✅ Watchlist Manager tests PASSED")
+    return True
+
+
+async def test_episode_checker():
+    """Test episode checker (without actual downloads)"""
+    print("\n" + "="*60)
+    print("🧪 TEST 2: Episode Checker")
+    print("="*60)
+
+    print("\n1. Testing EpisodeChecker initialization...")
+    try:
+        # Episode checker should be initialized
+        print(f"   ✅ EpisodeChecker ready")
+        print(f"   Note: Actual episode checking requires valid anime URLs")
+    except Exception as e:
+        print(f"   ❌ EpisodeChecker failed: {e}")
+        return False
+
+    print("\n✅ Episode Checker tests PASSED")
+    return True
+
+
+async def test_scheduler():
+    """Test scheduler controls"""
+    print("\n" + "="*60)
+    print("🧪 TEST 3: Auto-Download Scheduler")
+    print("="*60)
+
+    print("\n1. Testing scheduler initialization...")
+    try:
+        # Get settings
+        settings = watchlist_manager.get_settings()
+        print(f"   ✅ Settings loaded: check_interval={settings.check_interval_hours}h")
+    except Exception as e:
+        print(f"   ❌ Settings failed: {e}")
+        return False
+
+    print("\n2. Testing scheduler status...")
+    try:
+        status = auto_download_scheduler.get_status()
+        print(f"   ✅ Scheduler status: running={status['running']}")
+    except Exception as e:
+        print(f"   ❌ Status failed: {e}")
+        return False
+
+    print("\n3. Testing scheduler start/stop...")
+    try:
+        # Start scheduler
+        await auto_download_scheduler.start()
+        print("   ✅ Scheduler started")
+
+        status = auto_download_scheduler.get_status()
+        if not status['running']:
+            print("   ❌ Scheduler not running after start")
+            return False
+
+        # Stop scheduler
+        await auto_download_scheduler.stop()
+        print("   ✅ Scheduler stopped")
+
+        status = auto_download_scheduler.get_status()
+        if status['running']:
+            print("   ❌ Scheduler still running after stop")
+            return False
+
+    except Exception as e:
+        print(f"   ❌ Start/stop failed: {e}")
+        return False
+
+    print("\n✅ Scheduler tests PASSED")
+    return True
+
+
+async def test_settings():
+    """Test settings management"""
+    print("\n" + "="*60)
+    print("🧪 TEST 4: Settings Management")
+    print("="*60)
+
+    print("\n1. Testing settings update...")
+    try:
+        # Update settings
+        new_settings = {
+            "check_interval_hours": 12,
+            "auto_download_enabled": True,
+            "max_concurrent_auto_downloads": 3
+        }
+        watchlist_manager.update_settings(new_settings)
+        print(f"   ✅ Settings updated")
+
+        # Verify
+        settings = watchlist_manager.get_settings()
+        if settings.check_interval_hours != 12:
+            print(f"   ❌ Settings not saved correctly")
+            return False
+
+        print(f"   ✅ Settings verified: check_interval={settings.check_interval_hours}h")
+
+    except Exception as e:
+        print(f"   ❌ Settings failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+    print("\n✅ Settings tests PASSED")
+    return True
+
+
+async def run_all_tests():
+    """Run all tests"""
+    print("\n" + "="*60)
+    print("🚀 WATCHLIST SYSTEM TEST SUITE")
+    print("="*60)
+
+    tests = [
+        ("Watchlist Manager", test_watchlist_manager),
+        ("Episode Checker", test_episode_checker),
+        ("Scheduler", test_scheduler),
+        ("Settings", test_settings)
+    ]
+
+    results = []
+
+    for name, test_func in tests:
+        try:
+            result = await test_func()
+            results.append((name, result))
+        except Exception as e:
+            print(f"\n❌ {name} test crashed: {e}")
+            import traceback
+            traceback.print_exc()
+            results.append((name, False))
+
+    # Summary
+    print("\n" + "="*60)
+    print("📊 TEST SUMMARY")
+    print("="*60)
+
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+
+    for name, result in results:
+        status = "✅ PASSED" if result else "❌ FAILED"
+        print(f"{status}: {name}")
+
+    print(f"\nTotal: {passed}/{total} tests passed")
+
+    if passed == total:
+        print("\n🎉 ALL TESTS PASSED! The watchlist system is ready to use.")
+        return True
+    else:
+        print("\n⚠️  Some tests failed. Please review the errors above.")
+        return False
+
+
+if __name__ == "__main__":
+    success = asyncio.run(run_all_tests())
+    sys.exit(0 if success else 1)

test_watchlist_simple.py

@@ -0,0 +1,287 @@
+#!/usr/bin/env python3
+"""
+Simple test script for the watchlist & auto-download system
+"""
+
+import asyncio
+import sys
+from pathlib import Path
+
+# Add project to path
+sys.path.insert(0, str(Path(__file__).parent))
+
+from app.watchlist import watchlist_manager
+from app.episode_checker import episode_checker
+from app.auto_download_scheduler import auto_download_scheduler
+from app.models.watchlist import (
+    WatchlistItemCreate,
+    WatchlistStatus,
+    QualityPreference,
+    WatchlistSettings
+)
+
+
+def test_watchlist_basics():
+    """Test basic watchlist operations"""
+    print("\n" + "="*60)
+    print("🧪 TEST 1: Watchlist Manager Basics")
+    print("="*60)
+
+    # Test user ID
+    test_user = "test_user_simple"
+
+    # Clean up any existing test items first
+    print("\n0. Cleaning up any existing test items...")
+    all_items = watchlist_manager.get_all()
+    for item in all_items:
+        if item.user_id == test_user:
+            watchlist_manager.delete(item.id)
+            print(f"   ✓ Deleted old test item: {item.id}")
+
+    # Create a test item
+    print("\n1. Creating watchlist item...")
+    item_data = WatchlistItemCreate(
+        anime_title="Test Anime Simple",
+        anime_url="https://anime-sama.si/catalogue/test-simple/vostfr/",
+        provider_id="animesama",
+        lang="vostfr",
+        auto_download=True,
+        quality_preference=QualityPreference.AUTO
+    )
+
+    try:
+        item = watchlist_manager.create(test_user, item_data)
+        print(f"   ✅ Item created: {item.id}")
+        print(f"   Title: {item.anime_title}")
+        print(f"   Status: {item.status}")
+        print(f"   Auto-download: {item.auto_download}")
+    except Exception as e:
+        print(f"   ❌ Create failed: {e}")
+        return False
+
+    # Get all items for user
+    print("\n2. Getting user's items...")
+    try:
+        items = watchlist_manager.get_all(test_user)
+        print(f"   ✅ Found {len(items)} items for user")
+        if len(items) > 0:
+            print(f"   First item: {items[0].anime_title}")
+    except Exception as e:
+        print(f"   ❌ Get all failed: {e}")
+        return False
+
+    # Get stats
+    print("\n3. Getting statistics...")
+    try:
+        stats = watchlist_manager.get_stats(test_user)
+        print(f"   ✅ Stats: total={stats['total']}, active={stats['active']}, paused={stats['paused']}")
+    except Exception as e:
+        print(f"   ❌ Stats failed: {e}")
+        return False
+
+    # Update item
+    print("\n4. Updating item to paused...")
+    try:
+        updated = watchlist_manager.update(item.id, {"status": WatchlistStatus.PAUSED})
+        print(f"   ✅ Item updated to status: {updated.status}")
+    except Exception as e:
+        print(f"   ❌ Update failed: {e}")
+        return False
+
+    # Update check time
+    print("\n5. Updating check time...")
+    try:
+        updated = watchlist_manager.update_check_time(item.id, 5)
+        print(f"   ✅ Check time updated")
+        print(f"   Last episode: {updated.last_episode_downloaded}")
+    except Exception as e:
+        print(f"   ❌ Update check time failed: {e}")
+        return False
+
+    # Delete item (cleanup)
+    print("\n6. Cleaning up - deleting test item...")
+    try:
+        result = watchlist_manager.delete(item.id)
+        print(f"   ✅ Item deleted: {result}")
+    except Exception as e:
+        print(f"   ❌ Delete failed: {e}")
+        return False
+
+    print("\n✅ Watchlist Manager tests PASSED")
+    return True
+
+
+def test_settings():
+    """Test settings management"""
+    print("\n" + "="*60)
+    print("🧪 TEST 2: Settings Management")
+    print("="*60)
+
+    print("\n1. Getting current settings...")
+    try:
+        settings = watchlist_manager.get_settings()
+        print(f"   ✅ Current settings:")
+        print(f"   - Check interval: {settings.check_interval_hours}h")
+        print(f"   - Auto-download: {settings.auto_download_enabled}")
+        print(f"   - Max concurrent: {settings.max_concurrent_auto_downloads}")
+        print(f"   - Notifications: {settings.notify_on_new_episodes}")
+    except Exception as e:
+        print(f"   ❌ Get settings failed: {e}")
+        return False
+
+    print("\n2. Updating settings...")
+    try:
+        new_settings = WatchlistSettings(
+            check_interval_hours=12,
+            auto_download_enabled=True,
+            max_concurrent_auto_downloads=3,
+            notify_on_new_episodes=False
+        )
+        watchlist_manager.update_settings(new_settings)
+        print(f"   ✅ Settings updated")
+    except Exception as e:
+        print(f"   ❌ Update settings failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+    print("\n3. Verifying settings...")
+    try:
+        settings = watchlist_manager.get_settings()
+        if settings.check_interval_hours != 12:
+            print(f"   ❌ Settings not saved correctly: check_interval is {settings.check_interval_hours}, expected 12")
+            return False
+
+        print(f"   ✅ Settings verified:")
+        print(f"   - Check interval: {settings.check_interval_hours}h ✓")
+    except Exception as e:
+        print(f"   ❌ Verify settings failed: {e}")
+        return False
+
+    # Reset to defaults
+    print("\n4. Resetting to default settings...")
+    try:
+        default_settings = WatchlistSettings()
+        watchlist_manager.update_settings(default_settings)
+        print(f"   ✅ Settings reset to defaults")
+    except Exception as e:
+        print(f"   ❌ Reset settings failed: {e}")
+        return False
+
+    print("\n✅ Settings tests PASSED")
+    return True
+
+
+async def test_scheduler():
+    """Test scheduler controls"""
+    print("\n" + "="*60)
+    print("🧪 TEST 3: Auto-Download Scheduler")
+    print("="*60)
+
+    print("\n1. Testing scheduler start (async)...")
+    try:
+        auto_download_scheduler.start()
+        print(f"   ✅ Scheduler started")
+        print(f"   Status: running={auto_download_scheduler.is_running()}")
+    except Exception as e:
+        print(f"   ❌ Start failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+    if not auto_download_scheduler.is_running():
+        print(f"   ❌ Scheduler not running after start")
+        return False
+
+    print("\n2. Testing scheduler stop...")
+    try:
+        auto_download_scheduler.stop()
+        print(f"   ✅ Scheduler stopped")
+        print(f"   Status: running={auto_download_scheduler.is_running()}")
+    except Exception as e:
+        print(f"   ❌ Stop failed: {e}")
+        return False
+
+    if auto_download_scheduler.is_running():
+        print(f"   ❌ Scheduler still running after stop")
+        return False
+
+    print("\n3. Testing scheduler restart...")
+    try:
+        auto_download_scheduler.start()
+        print(f"   ✅ Scheduler restarted")
+
+        # Get next run time
+        next_run = auto_download_scheduler.get_next_run_time()
+        if next_run:
+            print(f"   Next run: {next_run}")
+
+        auto_download_scheduler.stop()
+        print(f"   ✅ Scheduler stopped again")
+    except Exception as e:
+        print(f"   ❌ Restart failed: {e}")
+        return False
+
+    print("\n✅ Scheduler tests PASSED")
+    return True
+
+
+async def run_all_tests():
+    """Run all tests"""
+    print("\n" + "="*60)
+    print("🚀 WATCHLIST SYSTEM TEST SUITE")
+    print("="*60)
+
+    tests = [
+        ("Watchlist Manager", lambda: test_watchlist_basics()),
+        ("Settings", lambda: test_settings()),
+        ("Scheduler", test_scheduler)  # This one is async
+    ]
+
+    results = []
+
+    for name, test_func in tests:
+        try:
+            # Check if it's a coroutine function
+            import asyncio
+            if asyncio.iscoroutinefunction(test_func):
+                result = await test_func()
+            else:
+                result = test_func()
+            results.append((name, result))
+        except Exception as e:
+            print(f"\n❌ {name} test crashed: {e}")
+            import traceback
+            traceback.print_exc()
+            results.append((name, False))
+
+    # Summary
+    print("\n" + "="*60)
+    print("📊 TEST SUMMARY")
+    print("="*60)
+
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+
+    for name, result in results:
+        status = "✅ PASSED" if result else "❌ FAILED"
+        print(f"{status}: {name}")
+
+    print(f"\nTotal: {passed}/{total} tests passed")
+
+    if passed == total:
+        print("\n🎉 ALL TESTS PASSED! The watchlist system is ready to use.")
+        print("\n📝 Next steps:")
+        print("   1. Start the server: uvicorn main:app --reload")
+        print("   2. Open http://localhost:3000/watchlist")
+        print("   3. Add anime to your watchlist")
+        print("   4. Start the scheduler")
+        return True
+    else:
+        print("\n⚠️  Some tests failed. Please review the errors above.")
+        return False
+
+
+if __name__ == "__main__":
+    success = asyncio.run(run_all_tests())
+    sys.exit(0 if success else 1)

tests/conftest.py

@@ -126,6 +126,8 @@ async def favorites_manager(temp_dir):
     """Create a FavoritesManager instance with temporary storage"""
     storage_path = temp_dir / "test_favorites.json"
     manager = FavoritesManager(storage_path=str(storage_path))
+    # Initialize asynchronously
+    await manager._load()
     yield manager
     # Cleanup
     if storage_path.exists():

tests/test_anime_sama_seasons.py

@@ -12,7 +12,7 @@ class TestAnimeSamaSeasons:
     @pytest.mark.asyncio
     async def test_get_seasons_no_seasons_available(self):
         """Test get_seasons when no seasons exist"""
-        from app.downloaders.animesama import AnimeSamaDownloader
+        from app.downloaders.anime_sites.animesama import AnimeSamaDownloader
 
         downloader = AnimeSamaDownloader()
 
@@ -54,7 +54,7 @@ class TestAnimeSamaSeasons:
     @pytest.mark.asyncio
     async def test_get_seasons_with_multiple_seasons(self):
         """Test get_seasons when multiple seasons exist"""
-        from app.downloaders.animesama import AnimeSamaDownloader
+        from app.downloaders.anime_sites.animesama import AnimeSamaDownloader
 
         downloader = AnimeSamaDownloader()
 
@@ -103,7 +103,7 @@ class TestAnimeSamaSeasons:
     @pytest.mark.asyncio
     async def test_get_seasons_url_parsing(self):
         """Test that get_seasons correctly parses URLs"""
-        from app.downloaders.animesama import AnimeSamaDownloader
+        from app.downloaders.anime_sites.animesama import AnimeSamaDownloader
 
         downloader = AnimeSamaDownloader()
 
@@ -131,7 +131,7 @@ class TestAnimeSamaSeasons:
     @pytest.mark.asyncio
     async def test_get_seasons_sorting(self):
         """Test that seasons are returned in correct order"""
-        from app.downloaders.animesama import AnimeSamaDownloader
+        from app.downloaders.anime_sites.animesama import AnimeSamaDownloader
 
         downloader = AnimeSamaDownloader()
 
@@ -153,7 +153,7 @@ class TestAnimeSamaSeasons:
     @pytest.mark.asyncio
     async def test_get_seasons_with_season_links_in_html(self):
         """Test get_seasons when season links are present in HTML"""
-        from app.downloaders.animesama import AnimeSamaDownloader
+        from app.downloaders.anime_sites.animesama import AnimeSamaDownloader
 
         downloader = AnimeSamaDownloader()
 

tests/test_auth.py

@@ -0,0 +1,370 @@
+"""
+Unit tests for authentication system (app/auth.py)
+Tests JWT tokens, user management, and password hashing
+"""
+import pytest
+import json
+from pathlib import Path
+from datetime import datetime, timedelta
+from unittest.mock import patch, Mock
+from app.auth import UserManager, create_access_token, verify_token, get_user_from_token
+
+
+class TestUserManager:
+    """Tests for UserManager class"""
+
+    @pytest.fixture
+    def temp_users_file(self, temp_dir):
+        """Create a temporary users.json file"""
+        return temp_dir / "users.json"
+
+    @pytest.fixture
+    def user_manager(self, temp_users_file):
+        """Create a UserManager instance with temporary storage"""
+        manager = UserManager(json_path=str(temp_users_file))
+        yield manager
+        # Cleanup
+        if temp_users_file.exists():
+            temp_users_file.unlink()
+
+    def test_user_manager_init_creates_file(self, user_manager, temp_users_file):
+        """Test that UserManager creates the users file on init"""
+        assert temp_users_file.exists()
+        data = json.loads(temp_users_file.read_text())
+        assert "users" in data
+        assert isinstance(data["users"], dict)
+
+    def test_user_manager_init_existing_file(self, temp_users_file):
+        """Test UserManager initialization with existing file"""
+        # Create a file with existing data
+        existing_data = {
+            "users": {
+                "existing_user": {
+                    "username": "existing_user",
+                    "password_hash": "hash",
+                    "created_at": "2024-01-01T00:00:00",
+                    "last_login": None
+                }
+            }
+        }
+        temp_users_file.write_text(json.dumps(existing_data))
+
+        manager = UserManager(json_path=str(temp_users_file))
+        # Should load existing data
+        assert "existing_user" in manager.users
+
+    def test_create_user_success(self, user_manager):
+        """Test successful user creation"""
+        user = user_manager.create_user("testuser", "password123")
+        assert user["username"] == "testuser"
+        assert "password_hash" in user
+        assert "created_at" in user
+        assert user["last_login"] is None
+        assert "testuser" in user_manager.users
+
+    def test_create_user_hashing(self, user_manager):
+        """Test that passwords are properly hashed with bcrypt"""
+        user = user_manager.create_user("testuser", "password123")
+        # Hash should not be the plain password
+        assert user["password_hash"] != "password123"
+        # Bcrypt hashes start with $2b$
+        assert user["password_hash"].startswith("$2b$")
+        # Hash should be 60 characters (bcrypt standard)
+        assert len(user["password_hash"]) == 60
+
+    def test_create_user_duplicate(self, user_manager):
+        """Test that duplicate usernames are rejected"""
+        user_manager.create_user("testuser", "password123")
+        with pytest.raises(ValueError, match="already exists"):
+            user_manager.create_user("testuser", "different456")
+
+    def test_create_user_short_password(self, user_manager):
+        """Test that short passwords are rejected"""
+        with pytest.raises(ValueError, match="at least 6 characters"):
+            user_manager.create_user("testuser", "short")
+
+    def test_create_user_password_truncation(self, user_manager):
+        """Test that passwords longer than 72 bytes are truncated"""
+        # Bcrypt has a 72-byte limit
+        long_password = "a" * 100
+        user = user_manager.create_user("testuser", long_password)
+        # Should succeed (password truncated internally)
+        assert user["username"] == "testuser"
+
+    def test_authenticate_user_success(self, user_manager):
+        """Test successful user authentication"""
+        user_manager.create_user("testuser", "password123")
+        user = user_manager.authenticate_user("testuser", "password123")
+        assert user is not None
+        assert user["username"] == "testuser"
+        assert user["last_login"] is not None
+
+    def test_authenticate_user_wrong_password(self, user_manager):
+        """Test authentication with wrong password"""
+        user_manager.create_user("testuser", "password123")
+        user = user_manager.authenticate_user("testuser", "wrongpassword")
+        assert user is None
+
+    def test_authenticate_user_nonexistent(self, user_manager):
+        """Test authentication with non-existent user"""
+        user = user_manager.authenticate_user("nonexistent", "password")
+        assert user is None
+
+    def test_authenticate_updates_last_login(self, user_manager):
+        """Test that authentication updates last_login timestamp"""
+        user_manager.create_user("testuser", "password123")
+        user_before = user_manager.users["testuser"]
+        assert user_before["last_login"] is None
+
+        user_manager.authenticate_user("testuser", "password123")
+        user_after = user_manager.users["testuser"]
+        assert user_after["last_login"] is not None
+
+    def test_get_user(self, user_manager):
+        """Test getting a user by username"""
+        user_manager.create_user("testuser", "password123")
+        user = user_manager.get_user("testuser")
+        assert user is not None
+        assert user["username"] == "testuser"
+
+    def test_get_user_nonexistent(self, user_manager):
+        """Test getting a non-existent user"""
+        user = user_manager.get_user("nonexistent")
+        assert user is None
+
+    def test_update_user_last_login(self, user_manager):
+        """Test updating user's last login timestamp"""
+        user_manager.create_user("testuser", "password123")
+        user_manager.update_last_login("testuser")
+        user = user_manager.users["testuser"]
+        assert user["last_login"] is not None
+
+    def test_deprecated_scheme_migration(self, user_manager):
+        """Test migration from deprecated password schemes"""
+        # This tests the passlib auto-migration feature
+        # In practice, this is handled by passlib automatically
+        user_manager.create_user("testuser", "password123")
+        user = user_manager.users["testuser"]
+        # Should use bcrypt scheme
+        assert user["password_hash"].startswith("$2b$")
+
+
+class TestJWTTokens:
+    """Tests for JWT token creation and verification"""
+
+    def test_create_access_token(self):
+        """Test JWT token creation"""
+        token = create_access_token(data={"sub": "testuser"}, expires_delta=timedelta(minutes=30))
+        assert isinstance(token, str)
+        # JWT tokens have 3 parts separated by dots
+        assert len(token.split(".")) == 3
+
+    def test_create_token_default_expiration(self):
+        """Test token creation with default expiration"""
+        token = create_access_token(data={"sub": "testuser"})
+        assert isinstance(token, str)
+
+    def test_verify_token_valid(self):
+        """Test verifying a valid token"""
+        token = create_access_token(data={"sub": "testuser"})
+        payload = verify_token(token)
+        assert payload is not None
+        assert payload.get("sub") == "testuser"
+
+    def test_verify_token_invalid(self):
+        """Test verifying an invalid token"""
+        payload = verify_token("invalid.token.here")
+        assert payload is None
+
+    def test_verify_token_expired(self):
+        """Test verifying an expired token"""
+        # Create a token that's already expired
+        token = create_access_token(
+            data={"sub": "testuser"},
+            expires_delta=timedelta(seconds=-1)  # Expired
+        )
+        payload = verify_token(token)
+        # Should return None for expired token
+        assert payload is None
+
+    def test_token_contains_username(self):
+        """Test that token contains the username in 'sub' claim"""
+        token = create_access_token(data={"sub": "testuser"})
+        payload = verify_token(token)
+        assert payload["sub"] == "testuser"
+
+    def test_token_with_custom_claims(self):
+        """Test token creation with custom claims"""
+        token = create_access_token(data={"sub": "testuser", "role": "admin"})
+        payload = verify_token(token)
+        assert payload["sub"] == "testuser"
+        assert payload["role"] == "admin"
+
+    def test_get_user_from_token_valid(self):
+        """Test getting user from valid token"""
+        token = create_access_token(data={"sub": "testuser"})
+        username = get_user_from_token(token)
+        assert username == "testuser"
+
+    def test_get_user_from_token_invalid(self):
+        """Test getting user from invalid token"""
+        username = get_user_from_token("invalid.token")
+        assert username is None
+
+    def test_get_user_from_token_no_sub(self):
+        """Test getting user from token without 'sub' claim"""
+        # Create token without 'sub' claim
+        token = create_access_token(data={"user": "testuser"})
+        username = get_user_from_token(token)
+        assert username is None
+
+    def test_different_secrets(self):
+        """Test that tokens can't be verified with different secrets"""
+        token = create_access_token(data={"sub": "testuser"})
+
+        # Try to verify with different secret (by mocking)
+        with patch('app.auth.JWT_SECRET_KEY', 'different-secret'):
+            payload = verify_token(token)
+            # Should fail verification
+            assert payload is None
+
+
+class TestTokenExpiration:
+    """Tests for token expiration handling"""
+
+    def test_token_expiration_time(self):
+        """Test that token expiration time is correct"""
+        from app.auth import ACCESS_TOKEN_EXPIRE_MINUTES
+        # Create token with custom expiration
+        expires = timedelta(minutes=30)
+        token = create_access_token(data={"sub": "testuser"}, expires_delta=expires)
+        # Token should be valid immediately
+        payload = verify_token(token)
+        assert payload is not None
+
+    def test_default_expiration_from_config(self):
+        """Test that default expiration matches configuration"""
+        from app.config import get_settings
+        settings = get_settings()
+        # Just verify the setting exists
+        assert hasattr(settings, 'ACCESS_TOKEN_EXPIRE_MINUTES') or 'ACCESS_TOKEN_EXPIRE_MINUTES' in dir(settings)
+
+
+class TestPasswordSecurity:
+    """Tests for password handling security"""
+
+    def test_password_not_stored_plaintext(self, user_manager):
+        """Test that passwords are never stored in plain text"""
+        user_manager.create_user("testuser", "password123")
+        user_data = user_manager.users["testuser"]
+        assert "password" not in user_data
+        assert "password_hash" in user_data
+        assert user_data["password_hash"] != "password123"
+
+    def test_password_case_sensitive(self, user_manager):
+        """Test that password authentication is case-sensitive"""
+        user_manager.create_user("testuser", "Password123")
+        # Wrong case should fail
+        user = user_manager.authenticate_user("testuser", "password123")
+        assert user is None
+
+    def test_different_users_same_password(self, user_manager):
+        """Test that different users with same password have different hashes"""
+        # Bcrypt uses salt, so hashes should be different
+        user1 = user_manager.create_user("user1", "samepassword")
+        user2 = user_manager.create_user("user2", "samepassword")
+        assert user1["password_hash"] != user2["password_hash"]
+
+    def test_password_hash_algorithm(self, user_manager):
+        """Test that bcrypt is used for password hashing"""
+        user = user_manager.create_user("testuser", "password123")
+        # Bcrypt hashes start with $2b$
+        assert user["password_hash"].startswith("$2b$")
+
+
+class TestUserDataPersistence:
+    """Tests for user data persistence and file operations"""
+
+    @pytest.fixture
+    def user_manager_with_file(self, temp_dir):
+        """Create a UserManager and allow file operations"""
+        users_file = temp_dir / "test_users.json"
+        manager = UserManager(json_path=str(users_file))
+        yield manager
+        if users_file.exists():
+            users_file.unlink()
+
+    def test_user_saved_to_file(self, user_manager_with_file, temp_dir):
+        """Test that users are saved to file"""
+        users_file = temp_dir / "test_users.json"
+        manager = user_manager_with_file
+
+        manager.create_user("testuser", "password123")
+
+        # Read file directly
+        data = json.loads(users_file.read_text())
+        assert "testuser" in data["users"]
+
+    def test_multiple_users_persisted(self, user_manager_with_file, temp_dir):
+        """Test that multiple users are persisted correctly"""
+        users_file = temp_dir / "test_users.json"
+        manager = user_manager_with_file
+
+        manager.create_user("user1", "password1")
+        manager.create_user("user2", "password2")
+        manager.create_user("user3", "password3")
+
+        data = json.loads(users_file.read_text())
+        assert len(data["users"]) == 3
+        assert "user1" in data["users"]
+        assert "user2" in data["users"]
+        assert "user3" in data["users"]
+
+    def test_user_data_has_required_fields(self, user_manager_with_file):
+        """Test that user data contains all required fields"""
+        manager = user_manager_with_file
+        user = manager.create_user("testuser", "password123")
+
+        required_fields = ["username", "password_hash", "created_at", "last_login"]
+        for field in required_fields:
+            assert field in user
+
+    def test_created_at_is_iso_format(self, user_manager_with_file):
+        """Test that created_at is in ISO format"""
+        manager = user_manager_with_file
+        user = manager.create_user("testuser", "password123")
+        # Should be parseable as ISO datetime
+        datetime.fromisoformat(user["created_at"])
+
+
+class TestUsernameValidation:
+    """Tests for username validation"""
+
+    @pytest.fixture
+    def user_manager(self, temp_dir):
+        users_file = temp_dir / "users.json"
+        manager = UserManager(json_path=str(users_file))
+        yield manager
+        if users_file.exists():
+            users_file.unlink()
+
+    def test_username_case_sensitive(self, user_manager):
+        """Test that usernames are case-sensitive"""
+        user_manager.create_user("TestUser", "password123")
+        # Different case should be treated as different user
+        user2 = user_manager.create_user("testuser", "password456")
+        assert user2["username"] == "testuser"
+        # Both should exist
+        assert "TestUser" in user_manager.users
+        assert "testuser" in user_manager.users
+
+    def test_username_with_special_chars(self, user_manager):
+        """Test usernames with special characters"""
+        # Should accept most characters
+        user = user_manager.create_user("user-123", "password123")
+        assert user["username"] == "user-123"
+
+    def test_username_with_spaces(self, user_manager):
+        """Test usernames with spaces"""
+        user = user_manager.create_user("test user", "password123")
+        assert user["username"] == "test user"

tests/test_metadata_enrichment.py

@@ -0,0 +1,442 @@
+"""
+Tests for metadata enrichment with Kitsu API fallback.
+"""
+import pytest
+from unittest.mock import AsyncMock, MagicMock, patch
+from datetime import datetime, timedelta
+
+from app.metadata_enrichment import MetadataEnricher
+from app.models import AnimeMetadata
+
+
+@pytest.fixture
+async def enricher(temp_dir):
+    """Create a MetadataEnricher instance with temp cache dir."""
+    enricher = MetadataEnricher(cache_dir=temp_dir)
+    yield enricher
+    await enricher.close()
+
+
+@pytest.fixture
+def mock_kitsu_api():
+    """Mock Kitsu API responses in raw Kitsu format."""
+    mock_data = {
+        'title': 'Naruto',
+        'title_japanese': 'ナルト',
+        'title_english': 'Naruto',
+        'synopsis': 'A test synopsis from Kitsu',
+        'genres': ['Action', 'Adventure'],
+        'score': 8.5,
+        'year': 2002,
+        'episodes': 220,
+        'status': 'Finished Airing',
+        'images': {
+            'jpg': {
+                'large_image_url': 'https://kitsu.io/naruto-poster.jpg',
+                'image_url': 'https://kitsu.io/naruto-poster-small.jpg'
+            },
+            'webp': {
+                'large_image_url': 'https://kitsu.io/naruto-banner.jpg'
+            }
+        }
+    }
+    return mock_data
+
+
+@pytest.fixture
+def mock_kitsu_api_raw():
+    """Mock raw Kitsu API response format."""
+    return {
+        'mal_id': 123,
+        'title': 'Naruto',
+        'title_japanese': 'ナルト',
+        'title_english': 'Naruto',
+        'episodes': 220,
+        'status': 'Finished Airing',
+        'score': 8.5,
+        'synopsis': 'A test synopsis from Kitsu',
+        'genres': ['Action', 'Adventure'],
+        'images': {
+            'jpg': {
+                'image_url': 'https://kitsu.io/naruto-poster-small.jpg',
+                'large_image_url': 'https://kitsu.io/naruto-poster.jpg'
+            },
+            'webp': {
+                'image_url': 'https://kitsu.io/naruto-poster-small.webp',
+                'large_image_url': 'https://kitsu.io/naruto-banner.jpg'
+            }
+        },
+        'url': 'https://kitsu.io/anime/123',
+        'subtype': 'TV',
+        'year': 2002
+    }
+
+
+class TestMetadataEnricher:
+    """Test MetadataEnricher functionality."""
+
+    def test_init_creates_cache_dir(self, enricher, temp_dir):
+        """Test that enricher creates cache directory."""
+        assert enricher.cache_dir == temp_dir
+        assert enricher.cache_file == temp_dir / "metadata_cache.json"
+
+    def test_get_cache_key(self, enricher):
+        """Test cache key generation."""
+        key1 = enricher._get_cache_key("Naruto", "https://example.com/naruto")
+        key2 = enricher._get_cache_key("Naruto", "https://example.com/naruto")
+        key3 = enricher._get_cache_key("Naruto", "https://example.com/sasuke")
+
+        # Same inputs should produce same key
+        assert key1 == key2
+
+        # Different URL should produce different key
+        assert key1 != key3
+
+    def test_get_missing_fields(self, enricher):
+        """Test identification of missing fields."""
+        # Complete metadata
+        complete = {
+            'synopsis': 'Test synopsis',
+            'genres': ['Action'],
+            'rating': '8.5/10',
+            'release_year': 2020,
+            'studio': 'Studio Pierrot',
+            'poster_image': 'https://example.com/poster.jpg',
+            'banner_image': 'https://example.com/banner.jpg',
+            'total_episodes': 12,
+            'status': 'Completed',
+            'alternative_titles': ['Japanese Title']  # Now required for completeness
+        }
+
+        missing = enricher._get_missing_fields(complete)
+        assert len(missing) == 0
+
+        # Incomplete metadata
+        incomplete = {
+            'synopsis': 'Test synopsis',
+            'genres': []  # Empty list counts as missing
+        }
+
+        missing = enricher._get_missing_fields(incomplete)
+        assert 'rating' in missing
+        assert 'release_year' in missing
+        # Note: studio is not in KITSU_FIELDS, so it won't be detected as missing
+        assert 'status' in missing
+        assert 'genres' in missing  # Empty list is considered missing
+        assert len(missing) >= 4
+
+    def test_convert_kitsu_to_metadata(self, enricher, mock_kitsu_api):
+        """Test conversion of Kitsu API response to metadata format."""
+        metadata = enricher._convert_kitsu_to_metadata(mock_kitsu_api)
+
+        assert metadata['synopsis'] == 'A test synopsis from Kitsu'
+        assert metadata['genres'] == ['Action', 'Adventure']
+        assert metadata['rating'] == '8.5/10'
+        assert metadata['release_year'] == 2002
+        assert metadata['poster_image'] == 'https://kitsu.io/naruto-poster.jpg'
+        assert metadata['banner_image'] == 'https://kitsu.io/naruto-banner.jpg'
+        assert metadata['total_episodes'] == 220
+        assert metadata['status'] == 'Completed'
+        assert 'ナルト' in metadata['alternative_titles']
+        assert 'Naruto' in metadata['alternative_titles']
+
+    def test_convert_kitsu_status_translation(self, enricher):
+        """Test Kitsu status translation."""
+        test_cases = [
+            ('Airing', 'Ongoing'),
+            ('Finished Airing', 'Completed'),
+            ('To Be Aired', 'Upcoming'),
+        ]
+
+        for kitsu_status, expected_status in test_cases:
+            metadata = enricher._convert_kitsu_to_metadata({
+                'status': kitsu_status
+            })
+            assert metadata['status'] == expected_status
+
+    def test_merge_metadata_prefer_provider(self, enricher, mock_kitsu_api):
+        """Test that provider metadata takes priority over Kitsu."""
+        provider_meta = {
+            'synopsis': 'Provider synopsis (better)',
+            'genres': ['Action'],
+            'rating': '9.0/10',  # Different from Kitsu
+            'release_year': 2002,
+            'studio': 'Studio Pierrot',  # Not in Kitsu
+        }
+
+        kitsu_meta = enricher._convert_kitsu_to_metadata(mock_kitsu_api)
+
+        merged = enricher._merge_metadata(provider_meta, kitsu_meta)
+
+        # Provider data should be preserved
+        assert merged['synopsis'] == 'Provider synopsis (better)'
+        assert merged['rating'] == '9.0/10'
+        assert merged['studio'] == 'Studio Pierrot'
+
+        # Kitsu data should fill gaps
+        assert merged['total_episodes'] == 220
+        assert merged['status'] == 'Completed'
+
+    def test_calculate_quality_score(self, enricher):
+        """Test metadata quality score calculation."""
+        # Complete metadata should have high score
+        complete = {
+            'synopsis': 'A detailed synopsis of the anime with lots of information',
+            'genres': ['Action', 'Adventure', 'Fantasy'],
+            'rating': '8.5/10',
+            'release_year': 2020,
+            'studio': 'Studio Pierrot',
+            'poster_image': 'https://example.com/poster.jpg',
+            'banner_image': 'https://example.com/banner.jpg',
+            'total_episodes': 12,
+            'status': 'Completed',
+            'alternative_titles': ['Japanese Title']
+        }
+
+        score = enricher._calculate_quality_score(complete)
+        assert score > 0.8  # Should be high quality
+
+        # Minimal metadata should have low score
+        minimal = {
+            'synopsis': 'Short',
+            'genres': ['Action']
+        }
+
+        score = enricher._calculate_quality_score(minimal)
+        assert score < 0.5  # Should be low quality
+
+    @pytest.mark.asyncio
+    async def test_enrich_metadata_with_kitsu_fallback(self, enricher, mock_kitsu_api_raw):
+        """Test enrichment with Kitsu API fallback."""
+        provider_metadata = {
+            'synopsis': 'Provider synopsis',
+            'genres': ['Action'],
+            # Missing: rating, release_year, poster_image, etc.
+        }
+
+        # Mock the Kitsu API search to return raw format
+        with patch.object(enricher.kitsu_api, 'search_anime', return_value=[mock_kitsu_api_raw]):
+            result = await enricher.enrich_metadata(
+                provider_metadata=provider_metadata,
+                title='Naruto',
+                url='https://example.com/naruto',
+                use_kitsu_fallback=True
+            )
+
+            # Should have Kitsu data
+            assert result.rating == '8.5/10'
+            assert result.release_year == 2002
+            assert result.poster_image is not None
+            assert result.total_episodes == 220
+            assert result.status == 'Completed'
+
+            # Should preserve provider data
+            assert result.synopsis == 'Provider synopsis'
+
+    @pytest.mark.asyncio
+    async def test_enrich_metadata_without_kitsu_fallback(self, enricher):
+        """Test enrichment without Kitsu fallback."""
+        provider_metadata = {
+            'synopsis': 'Provider synopsis',
+            'genres': ['Action'],
+        }
+
+        result = await enricher.enrich_metadata(
+            provider_metadata=provider_metadata,
+            title='Naruto',
+            url='https://example.com/naruto',
+            use_kitsu_fallback=False
+        )
+
+        # Should only have provider data
+        assert result.synopsis == 'Provider synopsis'
+        assert result.genres == ['Action']
+        assert result.rating is None  # No Kitsu fallback
+        assert result.release_year is None
+
+    @pytest.mark.asyncio
+    async def test_enrich_metadata_caching(self, enricher, mock_kitsu_api_raw):
+        """Test that enriched metadata is cached."""
+        provider_metadata = {
+            'synopsis': 'Provider synopsis',
+            'genres': ['Action'],
+        }
+
+        with patch.object(enricher.kitsu_api, 'search_anime', return_value=[mock_kitsu_api_raw]) as mock_search:
+            # First call should fetch from Kitsu
+            result1 = await enricher.enrich_metadata(
+                provider_metadata=provider_metadata,
+                title='Naruto',
+                url='https://example.com/naruto',
+                use_kitsu_fallback=True
+            )
+            assert mock_search.call_count == 1
+
+            # Second call should use cache
+            result2 = await enricher.enrich_metadata(
+                provider_metadata=provider_metadata,
+                title='Naruto',
+                url='https://example.com/naruto',
+                use_kitsu_fallback=True
+            )
+            assert mock_search.call_count == 1  # No additional call
+
+            # Results should be identical
+            assert result1.model_dump() == result2.model_dump()
+
+    @pytest.mark.asyncio
+    async def test_enrich_search_results(self, enricher, mock_kitsu_api_raw):
+        """Test enrichment of multiple search results."""
+        search_results = [
+            {
+                'title': 'Naruto',
+                'url': 'https://example.com/naruto',
+                'metadata': {
+                    'synopsis': 'Brief synopsis',
+                    'genres': ['Action']
+                }
+            },
+            {
+                'title': 'One Piece',
+                'url': 'https://example.com/onepiece',
+                'metadata': {
+                    'synopsis': 'Another synopsis',
+                    'genres': ['Adventure']
+                }
+            },
+            {
+                'title': 'No Metadata',
+                'url': 'https://example.com/nometa'
+            }
+        ]
+
+        with patch.object(enricher.kitsu_api, 'search_anime', return_value=[mock_kitsu_api_raw]):
+            enriched = await enricher.enrich_search_results(
+                results=search_results,
+                use_kitsu_fallback=True
+            )
+
+            # Should enrich results with metadata
+            assert len(enriched) == 3
+
+            # First result should be enriched
+            assert enriched[0]['metadata']['rating'] == '8.5/10'
+            assert enriched[0]['metadata']['release_year'] == 2002
+
+            # Second result should also be enriched
+            assert enriched[1]['metadata']['rating'] == '8.5/10'
+
+            # Third result should have no metadata field
+            assert 'metadata' not in enriched[2] or enriched[2].get('metadata') is None
+
+    @pytest.mark.asyncio
+    async def test_cache_expiry(self, enricher, mock_kitsu_api_raw):
+        """Test that expired cache entries are removed."""
+        provider_metadata = {'synopsis': 'Test'}
+
+        # Add an expired entry to cache
+        cache_key = enricher._get_cache_key('Test', 'https://example.com/test')
+        enricher._cache[cache_key] = {
+            'metadata': provider_metadata,
+            'cached_at': (datetime.now() - timedelta(hours=25)).isoformat()  # Expired
+        }
+        enricher._cache_dirty = True
+
+        with patch.object(enricher.kitsu_api, 'search_anime', return_value=[mock_kitsu_api_raw]) as mock_search:
+            # Should fetch from Kitsu since cache is expired
+            result = await enricher.enrich_metadata(
+                provider_metadata=provider_metadata,
+                title='Test',
+                url='https://example.com/test',
+                use_kitsu_fallback=True
+            )
+
+            assert mock_search.call_count == 1
+            assert result.rating == '8.5/10'
+
+    @pytest.mark.asyncio
+    async def test_close_saves_cache(self, enricher):
+        """Test that closing the enricher saves the cache."""
+        # Add something to cache
+        cache_key = 'test_key'
+        enricher._cache[cache_key] = {
+            'metadata': {'test': 'data'},
+            'cached_at': datetime.now().isoformat()
+        }
+        enricher._cache_dirty = True
+
+        await enricher.close()
+
+        # Cache file should exist
+        assert enricher.cache_file.exists()
+
+    @pytest.mark.asyncio
+    async def test_fetch_from_kitsu_error_handling(self, enricher):
+        """Test error handling when Kitsu API fails."""
+        provider_metadata = {'synopsis': 'Test'}
+
+        with patch.object(enricher, '_fetch_from_kitsu', side_effect=Exception("API Error")):
+            result = await enricher.enrich_metadata(
+                provider_metadata=provider_metadata,
+                title='NonExistent Anime',
+                url='https://example.com/nonexistent',
+                use_kitsu_fallback=True
+            )
+
+            # Should return provider metadata despite error
+            assert result.synopsis == 'Test'
+            assert result.rating is None
+
+
+class TestMetadataEnrichmentIntegration:
+    """Integration tests for metadata enrichment."""
+
+    @pytest.mark.asyncio
+    @pytest.mark.slow
+    async def test_kitsu_api_integration(self):
+        """Test actual Kitsu API integration (marked as slow)."""
+        enricher = MetadataEnricher()
+
+        try:
+            # Search for a well-known anime
+            results = await enricher.kitsu_api.search_anime('Naruto', limit=1)
+
+            assert len(results) > 0
+            assert 'title' in results[0]
+            assert 'synopsis' in results[0] or 'genres' in results[0]
+
+        finally:
+            await enricher.close()
+
+    @pytest.mark.asyncio
+    @pytest.mark.slow
+    async def test_full_enrichment_flow(self):
+        """Test complete enrichment flow with real data (marked as slow)."""
+        enricher = MetadataEnricher()
+
+        try:
+            # Simulate provider metadata with gaps
+            provider_metadata = {
+                'synopsis': 'Naruto Uzumaki wants to be the best ninja.',
+                'genres': ['Action'],
+                # Missing many fields
+            }
+
+            result = await enricher.enrich_metadata(
+                provider_metadata=provider_metadata,
+                title='Naruto',
+                url='https://test.com/naruto',
+                use_kitsu_fallback=True
+            )
+
+            # Should have enriched data
+            assert result.synopsis is not None
+            assert len(result.genres) > 0
+
+            # Kitsu might have filled some gaps
+            # (We can't assert specific fields as Kitsu responses may vary)
+            quality_score = result.model_dump().get('_quality_score', 0)
+            assert quality_score >= 0
+
+        finally:
+            await enricher.close()

tests/test_provider_detection.py

@@ -0,0 +1,479 @@
+"""
+Unit tests for provider detection and routing
+Tests URL-to-provider matching and downloader factory
+"""
+import pytest
+from app.providers import (
+    detect_provider_from_url,
+    ANIME_PROVIDERS,
+    FILE_HOSTS
+)
+from app.downloaders import get_downloader, get_anime_site, get_series_site, get_video_player
+
+
+class TestDetectProviderFromURL:
+    """Tests for detect_provider_from_url function"""
+
+    def test_detect_anime_sama(self):
+        """Test detection of Anime-Sama provider"""
+        urls = [
+            "https://anime-sama.si/catalogue/naruto/s1/vostfr/",
+            "https://www.anime-sama.fi/anime/test",
+            "https://anime-sama.pw/test",
+        ]
+        for url in urls:
+            provider = detect_provider_from_url(url)
+            assert provider is not None
+            assert provider["name"] == "anime-sama"
+
+    def test_detect_neko_sama(self):
+        """Test detection of Neko-Sama provider"""
+        urls = [
+            "https://neko-sama.fr/anime/naruto",
+            "https://www.neko-sama.fr/anime/one-piece",
+        ]
+        for url in urls:
+            provider = detect_provider_from_url(url)
+            assert provider is not None
+            assert provider["name"] == "neko-sama"
+
+    def test_detect_anime_ultime(self):
+        """Test detection of Anime-Ultime provider"""
+        urls = [
+            "https://anime-ultime.net/fiche-anime/naruto",
+            "https://www.anime-ultime.net/anime/test",
+        ]
+        for url in urls:
+            provider = detect_provider_from_url(url)
+            assert provider is not None
+            assert provider["name"] == "anime-ultime"
+
+    def test_detect_vostfree(self):
+        """Test detection of Vostfree provider"""
+        urls = [
+            "https://vostfree.cc/anime/naruto",
+            "https://www.vostfree.cc/anime/test",
+        ]
+        for url in urls:
+            provider = detect_provider_from_url(url)
+            assert provider is not None
+            assert provider["name"] == "vostfree"
+
+    def test_detect_french_manga(self):
+        """Test detection of French-Manga provider"""
+        urls = [
+            "https://french-manga.net/anime/naruto",
+            "https://www.french-manga.net/anime/test",
+        ]
+        for url in urls:
+            provider = detect_provider_from_url(url)
+            assert provider is not None
+            assert provider["name"] == "french-manga"
+
+    def test_detect_fs7(self):
+        """Test detection of FS7 (French Stream) provider"""
+        urls = [
+            "https://fs7.space/series/test",
+            "https://www.fs7.space/series/breaking-bad",
+        ]
+        for url in urls:
+            provider = detect_provider_from_url(url)
+            assert provider is not None
+            assert provider["name"] == "fs7"
+
+    def test_detect_file_hosts(self):
+        """Test detection of file hosting services"""
+        test_cases = [
+            ("https://doodstream.com/test/abc", "doodstream"),
+            ("https://ds2play.com/test/abc", "doodstream"),
+            ("https://rapidfile.com/test/abc", "rapidfile"),
+            ("https://uptobox.com/test/abc", "uptobox"),
+            ("https://1fichier.com/test", "unfichier"),
+            ("https://vidmoly.to/test", "vidmoly"),
+            ("https://sendvid.com/test", "sendvid"),
+            ("https://sibnet.ru/test", "sibnet"),
+            ("https://lpayer.com/test", "lpayer"),
+            ("https://vidzy.com/test", "vidzy"),
+            ("https://luluv.com/test", "luluv"),
+            ("https://uqload.com/test", "uqload"),
+        ]
+        for url, expected_name in test_cases:
+            provider = detect_provider_from_url(url)
+            assert provider is not None, f"Failed to detect {expected_name} from {url}"
+            assert provider["name"] == expected_name
+
+    def test_detect_unknown_provider(self):
+        """Test that unknown URLs return None"""
+        unknown_urls = [
+            "https://unknown-site.com/test",
+            "https://google.com/search",
+            "https://example.com/anime",
+        ]
+        for url in unknown_urls:
+            provider = detect_provider_from_url(url)
+            assert provider is None
+
+    def test_detect_empty_url(self):
+        """Test detection with empty URL"""
+        assert detect_provider_from_url("") is None
+        assert detect_provider_from_url(None) is None
+
+    def test_detect_case_insensitive(self):
+        """Test that detection is case-insensitive for domains"""
+        url = "https://Anime-Sama.si/test"
+        provider = detect_provider_from_url(url)
+        assert provider is not None
+        assert provider["name"] == "anime-sama"
+
+    def test_detect_with_path_and_query(self):
+        """Test detection with complex paths and query strings"""
+        urls = [
+            "https://anime-sama.si/catalogue/naruto/s1/vostfr/?page=1",
+            "https://neko-sama.fr/anime/one-piece?ep=1",
+            "https://doodstream.com/e/abc123#start=0",
+        ]
+        for url in urls:
+            provider = detect_provider_from_url(url)
+            assert provider is not None
+
+    def test_provider_structure(self):
+        """Test that detected provider has correct structure"""
+        provider = detect_provider_from_url("https://anime-sama.si/test")
+        assert "name" in provider
+        assert "icon" in provider
+        assert "color" in provider
+        assert "domains" in provider
+        assert isinstance(provider["domains"], list)
+
+
+class TestAnimeProvidersConfig:
+    """Tests for ANIME_PROVIDERS configuration"""
+
+    def test_anime_providers_structure(self):
+        """Test that all anime providers have required fields"""
+        for provider_name, provider_data in ANIME_PROVIDERS.items():
+            assert "name" in provider_data
+            assert "domains" in provider_data
+            assert "icon" in provider_data
+            assert "color" in provider_data
+            assert "url_pattern" in provider_data
+            assert isinstance(provider_data["domains"], list)
+
+    def test_known_anime_providers_exist(self):
+        """Test that known anime providers are configured"""
+        known_providers = [
+            "anime-sama",
+            "neko-sama",
+            "anime-ultime",
+            "vostfree",
+            "french-manga"
+        ]
+        for provider in known_providers:
+            assert provider in ANIME_PROVIDERS
+
+    def test_anime_provider_domains(self):
+        """Test that anime providers have valid domains"""
+        for provider_data in ANIME_PROVIDERS.values():
+            assert len(provider_data["domains"]) > 0
+            for domain in provider_data["domains"]:
+                assert isinstance(domain, str)
+                assert "." in domain  # Basic domain validation
+
+    def test_anime_provider_url_patterns(self):
+        """Test that URL patterns are valid"""
+        for provider_data in ANIME_PROVIDERS.values():
+            pattern = provider_data["url_pattern"]
+            assert isinstance(pattern, str)
+            assert len(pattern) > 0
+
+
+class TestFileHostsConfig:
+    """Tests for FILE_HOSTS configuration"""
+
+    def test_file_hosts_structure(self):
+        """Test that all file hosts have required fields"""
+        for host_name, host_data in FILE_HOSTS.items():
+            assert "name" in host_data
+            assert "domains" in host_data
+            assert "icon" in host_data
+            assert "color" in host_data
+            assert isinstance(host_data["domains"], list)
+
+    def test_known_file_hosts_exist(self):
+        """Test that known file hosts are configured"""
+        known_hosts = [
+            "unfichier",
+            "doodstream",
+            "rapidfile",
+            "uptobox",
+            "vidmoly",
+            "sendvid",
+            "sibnet",
+            "lpayer",
+            "vidzy",
+            "luluv",
+            "uqload"
+        ]
+        for host in known_hosts:
+            assert host in FILE_HOSTS
+
+    def test_file_host_domains(self):
+        """Test that file hosts have valid domains"""
+        for host_data in FILE_HOSTS.values():
+            assert len(host_data["domains"]) > 0
+            for domain in host_data["domains"]:
+                assert isinstance(domain, str)
+                assert "." in domain
+
+
+class TestGetDownloader:
+    """Tests for get_downloader factory function"""
+
+    @pytest.mark.asyncio
+    async def test_get_anime_site_downloader(self):
+        """Test getting anime site downloader"""
+        url = "https://anime-sama.si/catalogue/naruto/"
+        downloader = await get_downloader(url)
+        assert downloader is not None
+        # Should return an anime site downloader
+
+    @pytest.mark.asyncio
+    async def test_get_series_site_downloader(self):
+        """Test getting series site downloader"""
+        url = "https://fs7.space/series/test"
+        downloader = await get_downloader(url)
+        assert downloader is not None
+        # Should return a series site downloader
+
+    @pytest.mark.asyncio
+    async def test_get_video_player_downloader(self):
+        """Test getting video player downloader"""
+        url = "https://doodstream.com/e/abc123"
+        downloader = await get_downloader(url)
+        assert downloader is not None
+        # Should return a video player downloader
+
+    @pytest.mark.asyncio
+    async def test_get_unknown_url_downloader(self):
+        """Test getting generic downloader for unknown URL"""
+        url = "https://unknown-site.com/video"
+        downloader = await get_downloader(url)
+        assert downloader is not None
+        # Should return GenericDownloader
+
+
+class TestGetAnimeSite:
+    """Tests for get_anime_site factory function"""
+
+    @pytest.mark.asyncio
+    async def test_get_anime_sama_site(self):
+        """Test getting Anime-Sama site"""
+        from app.downloaders.anime_sites import AnimeSamaDownloader
+        url = "https://anime-sama.si/catalogue/naruto/"
+        downloader = await get_anime_site(url)
+        assert isinstance(downloader, AnimeSamaDownloader)
+
+    @pytest.mark.asyncio
+    async def test_get_neko_sama_site(self):
+        """Test getting Neko-Sama site"""
+        from app.downloaders.anime_sites import NekoSamaDownloader
+        url = "https://neko-sama.fr/anime/one-piece"
+        downloader = await get_anime_site(url)
+        assert isinstance(downloader, NekoSamaDownloader)
+
+    @pytest.mark.asyncio
+    async def test_get_anime_site_with_series_url(self):
+        """Test that series URL returns None for anime site"""
+        url = "https://fs7.space/series/test"
+        downloader = await get_anime_site(url)
+        assert downloader is None
+
+    @pytest.mark.asyncio
+    async def test_get_anime_site_with_video_player_url(self):
+        """Test that video player URL returns None for anime site"""
+        url = "https://doodstream.com/e/abc123"
+        downloader = await get_anime_site(url)
+        assert downloader is None
+
+
+class TestGetSeriesSite:
+    """Tests for get_series_site factory function"""
+
+    @pytest.mark.asyncio
+    async def test_get_fs7_site(self):
+        """Test getting FS7 series site"""
+        from app.downloaders.series_sites import FS7Downloader
+        url = "https://fs7.space/series/test"
+        downloader = await get_series_site(url)
+        assert isinstance(downloader, FS7Downloader)
+
+    @pytest.mark.asyncio
+    async def test_get_series_site_with_anime_url(self):
+        """Test that anime URL returns None for series site"""
+        url = "https://anime-sama.si/catalogue/naruto/"
+        downloader = await get_series_site(url)
+        assert downloader is None
+
+    @pytest.mark.asyncio
+    async def test_get_series_site_with_video_player_url(self):
+        """Test that video player URL returns None for series site"""
+        url = "https://doodstream.com/e/abc123"
+        downloader = await get_series_site(url)
+        assert downloader is None
+
+
+class TestGetVideoPlayer:
+    """Tests for get_video_player factory function"""
+
+    @pytest.mark.asyncio
+    async def test_get_doodstream_player(self):
+        """Test getting Doodstream player"""
+        from app.downloaders.video_players import DoodstreamDownloader
+        url = "https://doodstream.com/e/abc123"
+        player = await get_video_player(url)
+        assert isinstance(player, DoodstreamDownloader)
+
+    @pytest.mark.asyncio
+    async def test_get_unfichier_player(self):
+        """Test getting 1fichier player"""
+        from app.downloaders.video_players import UnFichierDownloader
+        url = "https://1fichier.com/?abc123"
+        player = await get_video_player(url)
+        assert isinstance(player, UnFichierDownloader)
+
+    @pytest.mark.asyncio
+    async def test_get_vidmoly_player(self):
+        """Test getting VidMoly player"""
+        from app.downloaders.video_players import VidMolyDownloader
+        url = "https://vidmoly.to/abc123"
+        player = await get_video_player(url)
+        assert isinstance(player, VidMolyDownloader)
+
+    @pytest.mark.asyncio
+    async def test_get_video_player_with_anime_url(self):
+        """Test that anime site URL returns None for video player"""
+        url = "https://anime-sama.si/catalogue/naruto/"
+        player = await get_video_player(url)
+        assert player is None
+
+    @pytest.mark.asyncio
+    async def test_get_video_player_with_unknown_url(self):
+        """Test that unknown URL returns None for video player"""
+        url = "https://unknown-site.com/video"
+        player = await get_video_player(url)
+        assert player is None
+
+
+class TestDownloaderPriority:
+    """Tests for downloader priority and routing"""
+
+    @pytest.mark.asyncio
+    async def test_anime_site_has_priority_over_series(self):
+        """Test that anime sites are checked before series sites"""
+        # This is implicit in the get_downloader implementation
+        # We just verify it works correctly
+        url = "https://anime-sama.si/catalogue/naruto/"
+        downloader = await get_downloader(url)
+        assert downloader is not None
+        # Should be an anime site, not series site or video player
+        from app.downloaders.anime_sites import BaseAnimeSite
+        assert isinstance(downloader, BaseAnimeSite)
+
+    @pytest.mark.asyncio
+    async def test_series_site_has_priority_over_video_player(self):
+        """Test that series sites are checked before video players"""
+        url = "https://fs7.space/series/test"
+        downloader = await get_downloader(url)
+        assert downloader is not None
+        # Should be a series site, not video player
+        from app.downloaders.series_sites import BaseSeriesSite
+        assert isinstance(downloader, BaseSeriesSite)
+
+
+class TestProviderDomains:
+    """Tests for provider domain matching"""
+
+    def test_anime_sama_domains(self):
+        """Test Anime-Sama domain variations"""
+        from app.downloaders.anime_sites import AnimeSamaDownloader
+        downloader = AnimeSamaDownloader()
+
+        # These should be handled
+        assert downloader.can_handle("https://anime-sama.si/test")
+        assert downloader.can_handle("https://www.anime-sama.fi/test")
+
+        # These should not
+        assert not downloader.can_handle("https://neko-sama.fr/test")
+        assert not downloader.can_handle("https://doodstream.com/test")
+
+    def test_neko_sama_domains(self):
+        """Test Neko-Sama domain variations"""
+        from app.downloaders.anime_sites import NekoSamaDownloader
+        downloader = NekoSamaDownloader()
+
+        assert downloader.can_handle("https://neko-sama.fr/anime/test")
+        assert not downloader.can_handle("https://anime-sama.si/test")
+
+    def test_doodstream_domains(self):
+        """Test Doodstream domain variations"""
+        from app.downloaders.video_players import DoodstreamDownloader
+        downloader = DoodstreamDownloader()
+
+        assert downloader.can_handle("https://doodstream.com/e/abc")
+        assert downloader.can_handle("https://ds2play.com/e/abc")
+        assert not downloader.can_handle("https://vidmoly.to/abc")
+
+    def test_subdomain_handling(self):
+        """Test that subdomains are handled correctly"""
+        from app.downloaders.anime_sites import AnimeSamaDownloader
+        downloader = AnimeSamaDownloader()
+
+        # With and without www
+        assert downloader.can_handle("https://anime-sama.si/test")
+        assert downloader.can_handle("https://www.anime-sama.si/test")
+
+    def test_protocol_handling(self):
+        """Test that both HTTP and HTTPS are handled"""
+        from app.downloaders.anime_sites import AnimeSamaDownloader
+        downloader = AnimeSamaDownloader()
+
+        assert downloader.can_handle("https://anime-sama.si/test")
+        # HTTP should also work (though less secure)
+        assert downloader.can_handle("http://anime-sama.si/test")
+
+
+class TestProviderEdgeCases:
+    """Tests for edge cases in provider detection"""
+
+    def test_url_with_port(self):
+        """Test URL with port number"""
+        provider = detect_provider_from_url("https://anime-sama.si:443/test")
+        assert provider is not None
+        assert provider["name"] == "anime-sama"
+
+    def test_url_with_fragment(self):
+        """Test URL with fragment identifier"""
+        provider = detect_provider_from_url("https://anime-sama.si/test#section")
+        assert provider is not None
+        assert provider["name"] == "anime-sama"
+
+    def test_url_with_auth(self):
+        """Test URL with authentication (should not happen in practice)"""
+        # URLs with auth @ should still be detected
+        provider = detect_provider_from_url("https://user:pass@anime-sama.si/test")
+        # Detection might fail due to parsing, but shouldn't crash
+        assert provider is not None or provider is None
+
+    def test_idn_domains(self):
+        """Test internationalized domain names"""
+        # Most providers use ASCII domains, but let's test the logic
+        url = "https://xn--anime-sama-test.si/catalogue/test"
+        provider = detect_provider_from_url(url)
+        # Should not crash
+
+    def test_punycode_domains(self):
+        """Test punycode-encoded domains"""
+        # ASCII encoding of international domains
+        url = "https://anime-sama.si/catalogue/test"
+        provider = detect_provider_from_url(url)
+        assert provider is not None

tests/test_utils.py

@@ -0,0 +1,238 @@
+"""
+Unit tests for utility functions (app/utils.py)
+Tests filename sanitization and security validation
+"""
+import pytest
+from app.utils import sanitize_filename, is_safe_filename
+
+
+class TestSanitizeFilename:
+    """Tests for sanitize_filename function"""
+
+    def test_sanitize_simple_filename(self):
+        """Test sanitizing a simple, safe filename"""
+        filename = "simple_video.mp4"
+        result = sanitize_filename(filename)
+        assert result == "simple_video.mp4"
+
+    def test_sanitize_with_dangerous_chars(self):
+        """Test removal of dangerous characters"""
+        # Test each dangerous character
+        assert sanitize_filename("file\\name.mp4") == "file_name.mp4"
+        assert sanitize_filename("file/name.mp4") == "file_name.mp4"
+        assert sanitize_filename("file:name.mp4") == "file_name.mp4"
+        assert sanitize_filename("file*name.mp4") == "file_name.mp4"
+        assert sanitize_filename("file?name.mp4") == "file_name.mp4"
+        assert sanitize_filename('file"name.mp4') == "file_name.mp4"
+        assert sanitize_filename("file<name>.mp4") == "file_name_.mp4"
+        assert sanitize_filename("file|name.mp4") == "file_name.mp4"
+
+    def test_sanitize_all_dangerous_chars(self):
+        """Test filename with all dangerous characters"""
+        filename = 'file\\/:*?"<>|name.mp4'
+        result = sanitize_filename(filename)
+        assert result == "file________name.mp4"
+
+    def test_sanitize_path_traversal(self):
+        """Test path traversal attempts are blocked"""
+        # Parent directory traversal
+        assert sanitize_filename("../../../etc/passwd") == "______etc_passwd"
+        assert sanitize_filename("../../secret.txt") == "____secret.txt"
+
+        # Current directory reference
+        assert sanitize_filename("./file.txt") == "file.txt"
+        assert sanitize_filename(".hidden") == "hidden"
+
+        # Absolute path attempts
+        assert sanitize_filename("/etc/passwd") == "passwd"
+        assert sanitize_filename("\\windows\\system32") == "system32"
+
+    def test_sanitize_leading_dots_and_dashes(self):
+        """Test removal of leading dots and dashes"""
+        assert sanitize_filename(".hidden") == "hidden"
+        assert sanitize_filename("..hidden") == "hidden"
+        assert sanitize_filename("---file.txt") == "file.txt"
+        assert sanitize_filename("...test...mp4") == "test...mp4"  # Only leading
+
+    def test_sanitize_empty_filename(self):
+        """Test empty filename returns default"""
+        assert sanitize_filename("") == "download"
+        assert sanitize_filename("   ") == "download"
+
+    def test_sanitize_only_dangerous_chars(self):
+        """Test filename with only dangerous characters"""
+        assert sanitize_filename("\\/:*?\"<>|") == "download"
+
+    def test_sanitize_length_limit(self):
+        """Test filename length is limited"""
+        # Create a very long filename
+        long_name = "a" * 300 + ".mp4"
+        result = sanitize_filename(long_name, max_length=255)
+        assert len(result) <= 255
+        assert result.endswith(".mp4")
+
+    def test_sanitize_length_limit_preserves_extension(self):
+        """Test that extension is preserved when limiting length"""
+        long_name = "x" * 260 + ".mp4"
+        result = sanitize_filename(long_name, max_length=255)
+        assert result.endswith(".mp4")
+        # Name part is truncated but extension kept
+        name, ext = result.rsplit(".", 1)
+        assert len(name) + len(ext) + 1 == 255
+
+    def test_sanitize_unicode(self):
+        """Test sanitization with unicode characters"""
+        # Japanese characters
+        assert sanitize_filename("アニメ.mp4") == "アニメ.mp4"
+        # Accented characters
+        assert sanitize_filename("café.mp4") == "café.mp4"
+        # Emoji
+        assert sanitize_filename("video🎬.mp4") == "video🎬.mp4"
+
+    def test_sanitize_multiple_extensions(self):
+        """Test filename with multiple dots"""
+        assert sanitize_filename("file.name.with.dots.tar.gz") == "file.name.with.dots.tar.gz"
+        # Only the last part is used for extension in length limit
+
+    def test_sanitize_no_extension(self):
+        """Test filename without extension"""
+        assert sanitize_filename("README") == "README"
+        assert sanitize_filename("file\\name") == "file_name"
+
+    def test_sanitize_custom_max_length(self):
+        """Test custom max length parameter"""
+        filename = "very_long_filename_here.txt"
+        result = sanitize_filename(filename, max_length=10)
+        assert len(result) <= 10
+        # Truncates name but keeps extension
+        assert result.endswith(".txt")
+
+    def test_sanitize_special_cases(self):
+        """Test various special cases"""
+        # CON, PRN, AUX etc (Windows reserved names) - not handled currently
+        # but we document behavior
+        assert sanitize_filename("CON.txt") == "CON.txt"
+
+        # Filenames with spaces
+        assert sanitize_filename("my video file.mp4") == "my video file.mp4"
+
+        # Mixed case
+        assert sanitize_filename("ViDeO.Mp4") == "ViDeO.Mp4"
+
+
+class TestIsSafeFilename:
+    """Tests for is_safe_filename function"""
+
+    def test_safe_filenames(self):
+        """Test that safe filenames return True"""
+        assert is_safe_filename("file.txt") is True
+        assert is_safe_filename("my_video.mp4") is True
+        assert is_safe_filename("document.pdf") is True
+        assert is_safe_filename("archive.tar.gz") is True
+        assert is_safe_filename("README") is True
+        assert is_safe_filename("file with spaces.txt") is True
+        assert is_safe_filename("file-with-dashes.txt") is True
+        assert is_safe_filename("file_with_underscores.txt") is True
+
+    def test_unsafe_path_traversal(self):
+        """Test that path traversal attempts return False"""
+        assert is_safe_filename("../etc/passwd") is False
+        assert is_safe_filename("../../secret") is False
+        assert is_safe_filename("../../../file.txt") is False
+        assert is_safe_filename("....\\....\\file.txt") is False
+
+    def test_unsafe_absolute_paths(self):
+        """Test that absolute paths return False"""
+        assert is_safe_filename("/etc/passwd") is False
+        assert is_safe_filename("/var/log/file.txt") is False
+        assert is_safe_filename("\\windows\\system32") is False
+        assert is_safe_filename("\\\\network\\share") is False
+
+    def test_unsafe_current_directory(self):
+        """Test that current directory references return False"""
+        assert is_safe_filename("./file.txt") is False
+        assert is_safe_filename(".hidden") is False  # Leading dot
+        assert is_safe_filename("././file.txt") is False
+
+    def test_unsafe_windows_drives(self):
+        """Test that Windows drive letters return False"""
+        assert is_safe_filename("C:\\file.txt") is False
+        assert is_safe_filename("D:\\data\\file.txt") is False
+        assert is_safe_filename("E:/file.txt") is False
+        assert is_safe_filename("c:file.txt") is False
+
+    def test_empty_filename(self):
+        """Test that empty filename returns False"""
+        assert is_safe_filename("") is False
+        assert is_safe_filename("   ") is False
+
+    def test_mixed_slashes(self):
+        """Test mixed forward and backward slashes"""
+        assert is_safe_filename("folder\\file/name.txt") is False
+        assert is_safe_filename("folder/sub\\file.txt") is False
+
+    def test_unicode_safe(self):
+        """Test unicode filenames are considered safe if no path traversal"""
+        assert is_safe_filename("ファイル.txt") is True
+        assert is_safe_filename("café.txt") is True
+        assert is_safe_filename("файл.txt") is True
+
+    def test_edge_cases(self):
+        """Test edge cases"""
+        # Just a dot
+        assert is_safe_filename(".") is False
+
+        # Multiple dots
+        assert is_safe_filename("...") is False
+
+        # Dots in middle are OK
+        assert is_safe_filename("file.name.txt") is True
+
+        # Slash at end
+        assert is_safe_filename("file.txt/") is False
+
+        # Backslash at end
+        assert is_safe_filename("file.txt\\") is False
+
+        # Spaces only
+        assert is_safe_filename("   ") is False
+
+
+class TestUtilityIntegration:
+    """Integration tests for utility functions working together"""
+
+    def test_sanitize_then_is_safe(self):
+        """Test that sanitized filenames are always safe"""
+        unsafe_filenames = [
+            "../../../etc/passwd",
+            "/absolute/path/file.txt",
+            "C:\\windows\\file.txt",
+            "./local/file.txt",
+            ".hidden",
+            "file\\with:bad*chars?.txt",
+        ]
+
+        for filename in unsafe_filenames:
+            sanitized = sanitize_filename(filename)
+            assert is_safe_filename(sanitized), f"Sanitized '{filename}' -> '{sanitized}' is not safe"
+
+    def test_roundtrip_safe_filenames(self):
+        """Test that safe filenames remain unchanged"""
+        safe_filenames = [
+            "file.txt",
+            "my_video.mp4",
+            "document.pdf",
+            "archive.tar.gz",
+            "README",
+            "file with spaces.txt",
+        ]
+
+        for filename in safe_filenames:
+            sanitized = sanitize_filename(filename)
+            assert sanitized == filename, f"Safe filename '{filename}' was changed to '{sanitized}'"
+
+    def test_empty_string_handling(self):
+        """Test that empty string is handled consistently"""
+        sanitized = sanitize_filename("")
+        assert sanitized == "download"
+        assert is_safe_filename(sanitized) is True

tests/test_watchlist.py

@@ -0,0 +1,474 @@
+"""
+Unit tests for Watchlist system (app/watchlist.py, app/models/watchlist.py)
+Tests watchlist CRUD operations, episode checking, and scheduler
+"""
+import pytest
+import json
+from pathlib import Path
+from datetime import datetime
+from unittest.mock import AsyncMock, Mock, patch
+from app.watchlist import WatchlistManager
+from app.models.watchlist import (
+    WatchlistItem,
+    WatchlistItemCreate,
+    WatchlistItemUpdate,
+    WatchlistStatus,
+    QualityPreference,
+    WatchlistSettings
+)
+
+
+class TestWatchlistManager:
+    """Tests for WatchlistManager class"""
+
+    @pytest.fixture
+    def temp_watchlist_file(self, temp_dir):
+        """Create a temporary watchlist.json file"""
+        return temp_dir / "watchlist.json"
+
+    @pytest.fixture
+    def watchlist_manager(self, temp_watchlist_file):
+        """Create a WatchlistManager instance with temporary storage"""
+        manager = WatchlistManager(json_path=str(temp_watchlist_file))
+        yield manager
+        # Cleanup
+        if temp_watchlist_file.exists():
+            temp_watchlist_file.unlink()
+
+    @pytest.fixture
+    def sample_watchlist_item(self):
+        """Create a sample watchlist item"""
+        return WatchlistItemCreate(
+            anime_url="https://anime-sama.si/catalogue/test/s1/vostfr/",
+            anime_title="Test Anime",
+            provider="anime-sama",
+            lang="vostfr",
+            quality_preference=QualityPreference.AUTO,
+            auto_download=True
+        )
+
+    def test_watchlist_manager_init_creates_file(self, watchlist_manager, temp_watchlist_file):
+        """Test that WatchlistManager creates the file on init"""
+        assert temp_watchlist_file.exists()
+        data = json.loads(temp_watchlist_file.read_text())
+        assert "items" in data
+
+    def test_add_item_success(self, watchlist_manager, sample_watchlist_item):
+        """Test adding an item to watchlist"""
+        item = watchlist_manager.add_item(
+            user_id="test_user",
+            item_data=sample_watchlist_item
+        )
+        assert item.id is not None
+        assert item.anime_title == "Test Anime"
+        assert item.status == WatchlistStatus.ACTIVE
+        assert item.user_id == "test_user"
+
+    def test_add_item_duplicate(self, watchlist_manager, sample_watchlist_item):
+        """Test that duplicate items are rejected"""
+        watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+        with pytest.raises(ValueError, match="already exists"):
+            watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+
+    def test_get_items_empty(self, watchlist_manager):
+        """Test getting items when watchlist is empty"""
+        items = watchlist_manager.get_items("test_user")
+        assert items == []
+
+    def test_get_items_with_data(self, watchlist_manager, sample_watchlist_item):
+        """Test getting items after adding one"""
+        watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+        items = watchlist_manager.get_items("test_user")
+        assert len(items) == 1
+        assert items[0].anime_title == "Test Anime"
+
+    def test_get_items_by_status(self, watchlist_manager):
+        """Test filtering items by status"""
+        from app.models.watchlist import WatchlistItemCreate
+
+        # Add items with different statuses
+        item1 = WatchlistItemCreate(
+            anime_url="https://anime-sama.si/test1/",
+            anime_title="Anime 1",
+            provider="anime-sama",
+            lang="vostfr"
+        )
+        item2 = WatchlistItemCreate(
+            anime_url="https://anime-sama.si/test2/",
+            anime_title="Anime 2",
+            provider="anime-sama",
+            lang="vostfr"
+        )
+
+        watchlist_manager.add_item(user_id="test_user", item_data=item1)
+        item2_id = watchlist_manager.add_item(user_id="test_user", item_data=item2).id
+
+        # Pause one item
+        watchlist_manager.update_item(
+            user_id="test_user",
+            item_id=item2_id,
+            item_data=WatchlistItemUpdate(status=WatchlistStatus.PAUSED)
+        )
+
+        # Get only active items
+        active_items = watchlist_manager.get_items("test_user", status=WatchlistStatus.ACTIVE)
+        assert len(active_items) == 1
+        assert active_items[0].anime_title == "Anime 1"
+
+        # Get only paused items
+        paused_items = watchlist_manager.get_items("test_user", status=WatchlistStatus.PAUSED)
+        assert len(paused_items) == 1
+        assert paused_items[0].anime_title == "Anime 2"
+
+    def test_get_item_by_id(self, watchlist_manager, sample_watchlist_item):
+        """Test getting a specific item by ID"""
+        item = watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+        retrieved = watchlist_manager.get_item(user_id="test_user", item_id=item.id)
+        assert retrieved is not None
+        assert retrieved.id == item.id
+        assert retrieved.anime_title == "Test Anime"
+
+    def test_get_item_by_id_not_found(self, watchlist_manager):
+        """Test getting non-existent item"""
+        item = watchlist_manager.get_item(user_id="test_user", item_id="nonexistent")
+        assert item is None
+
+    def test_update_item(self, watchlist_manager, sample_watchlist_item):
+        """Test updating an item"""
+        item = watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+
+        updated = watchlist_manager.update_item(
+            user_id="test_user",
+            item_id=item.id,
+            item_data=WatchlistItemUpdate(
+                quality_preference=QualityPreference.FULLHD
+            )
+        )
+
+        assert updated.quality_preference == QualityPreference.FULLHD
+        assert updated.anime_title == "Test Anime"  # Unchanged
+
+    def test_update_item_not_found(self, watchlist_manager):
+        """Test updating non-existent item"""
+        with pytest.raises(ValueError, match="not found"):
+            watchlist_manager.update_item(
+                user_id="test_user",
+                item_id="nonexistent",
+                item_data=WatchlistItemUpdate()
+            )
+
+    def test_delete_item(self, watchlist_manager, sample_watchlist_item):
+        """Test deleting an item"""
+        item = watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+        watchlist_manager.delete_item(user_id="test_user", item_id=item.id)
+
+        # Should be deleted
+        items = watchlist_manager.get_items("test_user")
+        assert len(items) == 0
+
+    def test_delete_item_not_found(self, watchlist_manager):
+        """Test deleting non-existent item"""
+        with pytest.raises(ValueError, match="not found"):
+            watchlist_manager.delete_item(user_id="test_user", item_id="nonexistent")
+
+    def test_pause_item(self, watchlist_manager, sample_watchlist_item):
+        """Test pausing an item"""
+        item = watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+        paused = watchlist_manager.pause_item(user_id="test_user", item_id=item.id)
+
+        assert paused.status == WatchlistStatus.PAUSED
+
+    def test_resume_item(self, watchlist_manager, sample_watchlist_item):
+        """Test resuming a paused item"""
+        item = watchlist_manager.add_item(user_id="test_user", item_data=sample_watchlist_item)
+        # Pause first
+        watchlist_manager.pause_item(user_id="test_user", item_id=item.id)
+
+        # Resume
+        resumed = watchlist_manager.resume_item(user_id="test_user", item_id=item.id)
+        assert resumed.status == WatchlistStatus.ACTIVE
+
+    def test_get_stats(self, watchlist_manager):
+        """Test getting watchlist statistics"""
+        from app.models.watchlist import WatchlistItemCreate
+
+        # Add multiple items
+        for i in range(3):
+            item = WatchlistItemCreate(
+                anime_url=f"https://anime-sama.si/test{i}/",
+                anime_title=f"Anime {i}",
+                provider="anime-sama",
+                lang="vostfr"
+            )
+            watchlist_manager.add_item(user_id="test_user", item_data=item)
+
+        stats = watchlist_manager.get_stats("test_user")
+        assert stats["total"] == 3
+        assert stats["by_status"]["active"] == 3
+
+    def test_multi_user_isolation(self, watchlist_manager):
+        """Test that different users have separate watchlists"""
+        from app.models.watchlist import WatchlistItemCreate
+
+        item1 = WatchlistItemCreate(
+            anime_url="https://anime-sama.si/test1/",
+            anime_title="Anime 1",
+            provider="anime-sama",
+            lang="vostfr"
+        )
+        item2 = WatchlistItemCreate(
+            anime_url="https://anime-sama.si/test2/",
+            anime_title="Anime 2",
+            provider="anime-sama",
+            lang="vostfr"
+        )
+
+        watchlist_manager.add_item(user_id="user1", item_data=item1)
+        watchlist_manager.add_item(user_id="user2", item_data=item2)
+
+        # Each user should only see their own items
+        user1_items = watchlist_manager.get_items("user1")
+        user2_items = watchlist_manager.get_items("user2")
+
+        assert len(user1_items) == 1
+        assert len(user2_items) == 1
+        assert user1_items[0].anime_title == "Anime 1"
+        assert user2_items[0].anime_title == "Anime 2"
+
+
+class TestWatchlistItemModel:
+    """Tests for WatchlistItem Pydantic model"""
+
+    def test_watchlist_item_creation(self):
+        """Test creating a WatchlistItem"""
+        item = WatchlistItem(
+            id="test-id",
+            user_id="test_user",
+            anime_url="https://anime-sama.si/test/",
+            anime_title="Test Anime",
+            provider="anime-sama",
+            lang="vostfr",
+            quality_preference=QualityPreference.AUTO,
+            auto_download=True,
+            status=WatchlistStatus.ACTIVE,
+            last_checked=None,
+            created_at=datetime.now()
+        )
+        assert item.anime_title == "Test Anime"
+        assert item.status == WatchlistStatus.ACTIVE
+
+    def test_quality_preference_enum(self):
+        """Test QualityPreference enum values"""
+        assert QualityPreference.AUTO == "auto"
+        assert QualityPreference.FULLHD == "1080p"
+        assert QualityPreference.HD == "720p"
+        assert QualityPreference.SD == "480p"
+
+    def test_watchlist_status_enum(self):
+        """Test WatchlistStatus enum values"""
+        assert WatchlistStatus.ACTIVE == "active"
+        assert WatchlistStatus.PAUSED == "paused"
+        assert WatchlistStatus.COMPLETED == "completed"
+        assert WatchlistStatus.ARCHIVED == "archived"
+
+
+class TestWatchlistSettings:
+    """Tests for WatchlistSettings model and management"""
+
+    @pytest.fixture
+    def temp_settings_file(self, temp_dir):
+        """Create a temporary watchlist_settings.json file"""
+        return temp_dir / "watchlist_settings.json"
+
+    def test_watchlist_settings_defaults(self):
+        """Test default values for WatchlistSettings"""
+        settings = WatchlistSettings()
+        assert settings.auto_download_enabled is True
+        assert settings.check_interval_hours >= 1
+        assert settings.check_interval_hours <= 168
+
+    def test_watchlist_settings_validation(self):
+        """Test WatchlistSettings validation"""
+        # Valid settings
+        settings = WatchlistSettings(
+            auto_download_enabled=True,
+            check_interval_hours=24,
+            default_quality=QualityPreference.AUTO
+        )
+        assert settings.check_interval_hours == 24
+
+    def test_watchlist_settings_invalid_interval(self):
+        """Test that invalid check intervals are rejected"""
+        # Less than 1 hour
+        with pytest.raises(ValueError):
+            WatchlistSettings(check_interval_hours=0)
+
+        # More than 168 hours (1 week)
+        with pytest.raises(ValueError):
+            WatchlistSettings(check_interval_hours=200)
+
+
+class TestEpisodeChecker:
+    """Tests for EpisodeChecker functionality"""
+
+    @pytest.mark.asyncio
+    async def test_check_new_episodes(self):
+        """Test checking for new episodes"""
+        from app.episode_checker import EpisodeChecker
+
+        # Mock the downloader
+        with patch('app.episode_checker.get_downloader') as mock_get_downloader:
+            mock_downloader = AsyncMock()
+            mock_downloader.get_episodes.return_value = [
+                {"episode_number": 1, "url": "ep1"},
+                {"episode_number": 2, "url": "ep2"},
+                {"episode_number": 3, "url": "ep3"}
+            ]
+            mock_get_downloader.return_value = mock_downloader
+
+            checker = EpisodeChecker()
+            # Test episode checking logic
+            episodes = await mock_downloader.get_episodes(
+                "https://anime-sama.si/test/",
+                "vostfr"
+            )
+            assert len(episodes) == 3
+            assert episodes[2]["episode_number"] == 3
+
+    @pytest.mark.asyncio
+    async def test_episode_download_creation(self):
+        """Test that new episodes trigger downloads when auto_download is enabled"""
+        # This would test the integration with download_manager
+        # For now, just test the logic flow
+        pass
+
+
+class TestAutoDownloadScheduler:
+    """Tests for AutoDownloadScheduler functionality"""
+
+    def test_scheduler_initialization(self):
+        """Test scheduler initialization"""
+        from app.auto_download_scheduler import AutoDownloadScheduler
+        scheduler = AutoDownloadScheduler()
+        assert scheduler.is_running() is False
+
+    def test_scheduler_start_stop(self):
+        """Test starting and stopping scheduler"""
+        from app.auto_download_scheduler import AutoDownloadScheduler
+        scheduler = AutoDownloadScheduler()
+
+        # Start
+        scheduler.start()
+        assert scheduler.is_running() is True
+
+        # Stop
+        scheduler.stop()
+        assert scheduler.is_running() is False
+
+    def test_scheduler_interval_validation(self):
+        """Test that scheduler validates intervals"""
+        from app.auto_download_scheduler import AutoDownloadScheduler
+        scheduler = AutoDownloadScheduler()
+
+        # Valid interval
+        scheduler.set_interval(24)  # 24 hours
+        assert scheduler.get_interval() == 24
+
+        # Invalid interval (should raise or clamp)
+        with pytest.raises(ValueError):
+            scheduler.set_interval(0)  # Too small
+
+        with pytest.raises(ValueError):
+            scheduler.set_interval(200)  # Too large
+
+
+class TestWatchlistIntegration:
+    """Integration tests for watchlist system"""
+
+    @pytest.fixture
+    def temp_watchlist_file(self, temp_dir):
+        """Create a temporary watchlist.json file"""
+        return temp_dir / "watchlist.json"
+
+    @pytest.fixture
+    def watchlist_manager(self, temp_watchlist_file):
+        """Create a WatchlistManager instance"""
+        manager = WatchlistManager(json_path=str(temp_watchlist_file))
+        yield manager
+        if temp_watchlist_file.exists():
+            temp_watchlist_file.unlink()
+
+    def test_full_workflow(self, watchlist_manager):
+        """Test complete workflow: add -> pause -> resume -> delete"""
+        from app.models.watchlist import WatchlistItemCreate
+
+        # Add
+        item_data = WatchlistItemCreate(
+            anime_url="https://anime-sama.si/test/",
+            anime_title="Test Anime",
+            provider="anime-sama",
+            lang="vostfr"
+        )
+        item = watchlist_manager.add_item(user_id="test_user", item_data=item_data)
+        assert item.status == WatchlistStatus.ACTIVE
+
+        # Pause
+        paused = watchlist_manager.pause_item(user_id="test_user", item_id=item.id)
+        assert paused.status == WatchlistStatus.PAUSED
+
+        # Resume
+        resumed = watchlist_manager.resume_item(user_id="test_user", item_id=item.id)
+        assert resumed.status == WatchlistStatus.ACTIVE
+
+        # Delete
+        watchlist_manager.delete_item(user_id="test_user", item_id=item.id)
+        items = watchlist_manager.get_items("test_user")
+        assert len(items) == 0
+
+    def test_update_quality_preference_workflow(self, watchlist_manager):
+        """Test updating quality preference"""
+        from app.models.watchlist import WatchlistItemCreate
+
+        item_data = WatchlistItemCreate(
+            anime_url="https://anime-sama.si/test/",
+            anime_title="Test Anime",
+            provider="anime-sama",
+            lang="vostfr",
+            quality_preference=QualityPreference.AUTO
+        )
+        item = watchlist_manager.add_item(user_id="test_user", item_data=item_data)
+
+        # Update to 1080p
+        updated = watchlist_manager.update_item(
+            user_id="test_user",
+            item_id=item.id,
+            item_data=WatchlistItemUpdate(quality_preference=QualityPreference.FULLHD)
+        )
+        assert updated.quality_preference == QualityPreference.FULLHD
+
+    def test_filter_by_status_workflow(self, watchlist_manager):
+        """Test filtering items by different statuses"""
+        from app.models.watchlist import WatchlistItemCreate
+
+        # Add multiple items
+        for i, status in enumerate([WatchlistStatus.ACTIVE, WatchlistStatus.PAUSED, WatchlistStatus.COMPLETED]):
+            item_data = WatchlistItemCreate(
+                anime_url=f"https://anime-sama.si/test{i}/",
+                anime_title=f"Anime {i}",
+                provider="anime-sama",
+                lang="vostfr"
+            )
+            item = watchlist_manager.add_item(user_id="test_user", item_data=item_data)
+            # Update status
+            watchlist_manager.update_item(
+                user_id="test_user",
+                item_id=item.id,
+                item_data=WatchlistItemUpdate(status=status)
+            )
+
+        # Count by status
+        stats = watchlist_manager.get_stats("test_user")
+        assert stats["total"] == 3
+        assert stats["by_status"]["active"] == 1
+        assert stats["by_status"]["paused"] == 1
+        assert stats["by_status"]["completed"] == 1