diff --git a/.env.example b/.env.example index 78d64a2..f783f85 100644 --- a/.env.example +++ b/.env.example @@ -18,3 +18,8 @@ CATALOG_REFRESH_INTERVAL_SECONDS=21600 # 6*60*60 every ~6 hours # AI Catalog name generation GEMINI_API_KEY= # Optional DEFAULT_GEMINI_MODEL="gemma-3-27b-it" + +# Trakt OAuth (optional - enables Trakt login on the configure page) +# Register your app at https://trakt.tv/oauth/applications +TRAKT_CLIENT_ID= +TRAKT_CLIENT_SECRET= diff --git a/README.md b/README.md index a20ffda..7030285 100644 --- a/README.md +++ b/README.md @@ -15,7 +15,8 @@ ## Features -- **Personalized Recommendations**: Analyzes your Stremio library to understand your viewing preferences. +- **Personalized Recommendations**: Analyzes your Stremio or Trakt library to understand your viewing preferences. +- **Trakt Integration**: Log in with Trakt instead of Stremio — no Stremio account required. - **Smart Filtering**: Automatically excludes content you've already watched. - **Advanced Scoring**: Recommendations are intelligently weighted by recency and relevance. - **Genre-Based Discovery**: Offers genre-specific catalogs based on your viewing history. @@ -67,7 +68,7 @@ You can pull the latest image from the GitHub Container Registry. ```env # Required TMDB_API_KEY=your_tmdb_api_key_here - TOKEN_SALT=generate_a_random_secure_string_here + TOKEN_SALT=generate_a_random_secure_string_here # python3 -c "import secrets; print(secrets.token_hex(32))" HOST_NAME=your_addon_url # Optional @@ -77,6 +78,12 @@ You can pull the latest image from the GitHub Container Registry. ADDON_NAME=Watchly TOKEN_TTL_SECONDS=0 AUTO_UPDATE_CATALOGS=true + + # Trakt Integration (optional — enables Trakt login on the configure page) + # Register your app at https://trakt.tv/oauth/applications/new + # Set the redirect URI to: https://your_addon_url/tokens/trakt/callback + TRAKT_CLIENT_ID=your_trakt_client_id + TRAKT_CLIENT_SECRET=your_trakt_client_secret ``` 3. **Start the application:** @@ -86,7 +93,7 @@ You can pull the latest image from the GitHub Container Registry. ``` 4. **Configure the addon:** - Open `http://localhost:8000/configure` in your browser to set up your Stremio credentials and install the addon. + Open `http://localhost:8000/configure` in your browser. Log in with either your **Stremio** credentials or your **Trakt** account, then configure your preferences and install the addon. ## Development diff --git a/app/api/endpoints/catalogs.py b/app/api/endpoints/catalogs.py index f1f0763..68baea1 100644 --- a/app/api/endpoints/catalogs.py +++ b/app/api/endpoints/catalogs.py @@ -13,7 +13,7 @@ async def get_catalog(response: Response, type: str, id: str, token: str, extra: if type not in ("movie", "series"): raise HTTPException(status_code=400, detail="Invalid content type. Must be 'movie' or 'series'.") - if len(token) > 30: # normal stremio tokens are 24 length. But we are using this just to be safe. + if len(token) > 80: # Stremio tokens are ~24 chars; Trakt hashed tokens are 40 chars. 80 is a safe upper bound. raise HTTPException(status_code=400, detail="Invalid token.") try: diff --git a/app/api/endpoints/trakt.py b/app/api/endpoints/trakt.py new file mode 100644 index 0000000..63579f4 --- /dev/null +++ b/app/api/endpoints/trakt.py @@ -0,0 +1,330 @@ +""" +Trakt OAuth and token-creation endpoints. + +Flow: +1. GET /tokens/trakt/config → returns client_id + whether Trakt is configured +2. GET /tokens/trakt/authorize → returns the Trakt OAuth2 URL for the popup +3. GET /tokens/trakt/callback → Trakt redirects here after user approves; + exchanges code for tokens, then posts a + message to the opener window and closes. +4. POST /tokens/trakt → Creates/updates a Watchly account using a + Trakt access_token (same body shape as + the main /tokens/ endpoint plus trakt_access_token). +5. POST /tokens/trakt/identity → Lightweight identity-check (returns user info + + existing settings if account exists). +""" + +import secrets +from datetime import datetime, timezone +from typing import Any + +from fastapi import APIRouter, HTTPException, Request +from fastapi.responses import HTMLResponse +from loguru import logger +from pydantic import BaseModel, Field + +from app.core.config import settings +from app.core.security import redact_token +from app.core.settings import CatalogConfig, PosterRatingConfig, UserSettings, get_default_settings +from app.services.manifest import manifest_service +from app.services.token_store import token_store +from app.services.trakt.service import TraktBundle + +router = APIRouter(prefix="/tokens/trakt", tags=["trakt"]) + +# OAuth state values are stored in Redis with a short TTL so they work +# correctly across multiple workers and don't accumulate indefinitely. +_OAUTH_STATE_TTL = 600 # 10 minutes + + +async def _store_oauth_state(state: str) -> None: + from app.services.redis_service import redis_service + await redis_service.set(f"watchly:oauth_state:trakt:{state}", state, _OAUTH_STATE_TTL) + + +async def _consume_oauth_state(state: str) -> bool: + """Returns True and deletes the state if valid, False otherwise.""" + from app.services.redis_service import redis_service + key = f"watchly:oauth_state:trakt:{state}" + value = await redis_service.get(key) + if value: + await redis_service.delete(key) + return True + return False + + +def _get_bundle(access_token: str | None = None) -> TraktBundle: + client_id = settings.TRAKT_CLIENT_ID + client_secret = settings.TRAKT_CLIENT_SECRET + if not client_id or not client_secret: + raise HTTPException( + status_code=503, + detail="Trakt integration is not configured on this server. Set TRAKT_CLIENT_ID and TRAKT_CLIENT_SECRET.", + ) + redirect_uri = f"{settings.HOST_NAME}/tokens/trakt/callback" + return TraktBundle( + client_id=client_id, + client_secret=client_secret, + redirect_uri=redirect_uri, + access_token=access_token, + ) + + +# --------------------------------------------------------------------------- +# Request / Response models +# --------------------------------------------------------------------------- + + +class TraktTokenRequest(BaseModel): + trakt_access_token: str = Field(..., description="Trakt OAuth2 access token") + trakt_refresh_token: str | None = Field(default=None, description="Trakt OAuth2 refresh token") + trakt_expires_at: int | None = Field(default=None, description="Unix timestamp when access token expires") + catalogs: list[CatalogConfig] | None = Field(default=None) + language: str = Field(default="en-US") + poster_rating: PosterRatingConfig | None = Field(default=None) + excluded_movie_genres: list[str] = Field(default_factory=list) + excluded_series_genres: list[str] = Field(default_factory=list) + popularity: str = Field(default="balanced") + year_min: int = Field(default=2010) + year_max: int = Field(default=2025) + sorting_order: str = Field(default="default") + simkl_api_key: str | None = Field(default=None) + gemini_api_key: str | None = Field(default=None) + tmdb_api_key: str | None = Field(default=None) + + +class TraktTokenResponse(BaseModel): + token: str + manifestUrl: str + expiresInSeconds: int | None = None + + +# --------------------------------------------------------------------------- +# Endpoints +# --------------------------------------------------------------------------- + + +@router.get("/config") +async def trakt_config(): + """Return whether Trakt is configured and the client_id (needed for the popup).""" + configured = bool(settings.TRAKT_CLIENT_ID and settings.TRAKT_CLIENT_SECRET) + return { + "configured": configured, + "client_id": settings.TRAKT_CLIENT_ID if configured else None, + } + + +@router.get("/authorize") +async def trakt_authorize(): + """Return the Trakt OAuth2 authorization URL for the frontend popup.""" + bundle = _get_bundle() + state = secrets.token_urlsafe(16) + await _store_oauth_state(state) + url, _ = bundle.auth.get_authorize_url(state=state) + await bundle.close() + return {"url": url, "state": state} + + +@router.get("/callback", response_class=HTMLResponse) +async def trakt_callback(request: Request, code: str | None = None, state: str | None = None, error: str | None = None): + """ + Trakt redirects here after the user approves (or denies) the app. + We exchange the code for tokens and post a message back to the opener + window, then close the popup. + """ + # --- error from Trakt --- + if error or not code: + return HTMLResponse(_popup_close_html(success=False, error=error or "Authorization cancelled")) + + # --- verify state to prevent CSRF --- + if not state or not await _consume_oauth_state(state): + return HTMLResponse(_popup_close_html(success=False, error="Invalid OAuth state. Please try again.")) + + # --- exchange code for tokens --- + try: + bundle = _get_bundle() + token_data = await bundle.auth.exchange_code(code) + await bundle.close() + except Exception as exc: + logger.error(f"Trakt callback: token exchange failed: {exc}") + return HTMLResponse(_popup_close_html(success=False, error="Token exchange failed")) + + access_token = token_data.get("access_token") + refresh_token = token_data.get("refresh_token") + expires_in = token_data.get("expires_in", 7776000) # default 90 days + + if not access_token: + return HTMLResponse(_popup_close_html(success=False, error="No access token received")) + + # Calculate expiry unix timestamp + import time + expires_at = int(time.time()) + expires_in + + return HTMLResponse( + _popup_close_html( + success=True, + access_token=access_token, + refresh_token=refresh_token, + expires_at=expires_at, + ) + ) + + +@router.post("/identity", status_code=200) +async def trakt_identity(payload: TraktTokenRequest): + """ + Validate the Trakt access token, return user info and existing settings. + """ + bundle = _get_bundle(access_token=payload.trakt_access_token) + try: + user_info = await bundle.user.get_user_info() + except Exception as exc: + raise HTTPException(status_code=400, detail=f"Invalid Trakt access token: {exc}") from exc + finally: + await bundle.close() + + username = user_info.get("username") or user_info.get("name") or "trakt_user" + # Use a Trakt-namespaced user_id so it can't clash with Stremio IDs + user_id = f"trakt:{username}" + + token = token_store.get_token_from_user_id(user_id) + user_data = await token_store.get_user_data(token) + exists = bool(user_data) + + response: dict[str, Any] = { + "user_id": user_id, + "username": username, + "display": user_info.get("name") or username, + "exists": exists, + } + if exists and user_data: + raw_settings = user_data.get("settings", {}) + try: + user_settings = UserSettings(**raw_settings) + response["settings"] = user_settings.model_dump() + except Exception as e: + logger.warning(f"Failed to normalise settings for {user_id}: {e}") + response["settings"] = raw_settings + + return response + + +@router.post("/", response_model=TraktTokenResponse) +async def create_trakt_token(payload: TraktTokenRequest, request: Request): + """ + Create or update a Watchly account backed by a Trakt access token. + The library is fetched from Trakt; everything else behaves like the + Stremio-based token endpoint. + """ + bundle = _get_bundle(access_token=payload.trakt_access_token) + + try: + user_info = await bundle.user.get_user_info() + except Exception as exc: + await bundle.close() + raise HTTPException(status_code=400, detail=f"Invalid Trakt access token: {exc}") from exc + + username = user_info.get("username") or user_info.get("name") or "trakt_user" + user_id = f"trakt:{username}" + + token = token_store.get_token_from_user_id(user_id) + existing_data = await token_store.get_user_data(token) + + default_settings = get_default_settings() + user_settings = UserSettings( + language=payload.language or default_settings.language, + catalogs=payload.catalogs if payload.catalogs else default_settings.catalogs, + poster_rating=payload.poster_rating, + excluded_movie_genres=payload.excluded_movie_genres, + excluded_series_genres=payload.excluded_series_genres, + year_min=payload.year_min, + year_max=payload.year_max, + popularity=payload.popularity, + sorting_order=payload.sorting_order, + simkl_api_key=payload.simkl_api_key, + gemini_api_key=payload.gemini_api_key, + tmdb_api_key=payload.tmdb_api_key, + ) + + payload_to_store: dict[str, Any] = { + "auth_provider": "trakt", + # authKey stores the Trakt access token (encrypted by token_store) + "authKey": payload.trakt_access_token, + "trakt_refresh_token": payload.trakt_refresh_token, + "trakt_expires_at": payload.trakt_expires_at, + "trakt_username": username, + "email": user_info.get("name") or username, + "settings": user_settings.model_dump(), + "last_updated": existing_data.get("last_updated") if existing_data else datetime.now(timezone.utc).isoformat(), + } + + token = await token_store.store_user_data(user_id, payload_to_store) + account_status = "updated" if existing_data else "created" + logger.info(f"[{redact_token(token)}] Trakt account {account_status} for user {user_id}") + + # Pre-cache library using Trakt data + try: + library_items = await bundle.library.get_library_items() + # Use the shared manifest caching pathway, passing library_items directly + await manifest_service.cache_library_and_profiles_from_items(library_items, user_settings, token) + logger.info(f"[{redact_token(token)}] Trakt library cached ({len(library_items.get('watched', []))} items)") + except Exception as exc: + logger.warning(f"[{redact_token(token)}] Failed to pre-cache Trakt library: {exc}. Will cache on demand.") + finally: + await bundle.close() + + base_url = settings.HOST_NAME + manifest_url = f"{base_url}/{token}/manifest.json" + expires_in = settings.TOKEN_TTL_SECONDS if settings.TOKEN_TTL_SECONDS > 0 else None + + return TraktTokenResponse(token=token, manifestUrl=manifest_url, expiresInSeconds=expires_in) + + +# --------------------------------------------------------------------------- +# Helpers +# --------------------------------------------------------------------------- + + +def _popup_close_html( + success: bool, + error: str | None = None, + access_token: str | None = None, + refresh_token: str | None = None, + expires_at: int | None = None, +) -> str: + """ + Minimal HTML page that posts a message to the opener and closes itself. + The frontend listens for this message via window.addEventListener('message', ...). + """ + if success: + payload_js = ( + f"{{ type: 'trakt_auth_success', " + f"access_token: {_js_str(access_token)}, " + f"refresh_token: {_js_str(refresh_token)}, " + f"expires_at: {expires_at or 'null'} }}" + ) + else: + payload_js = f"{{ type: 'trakt_auth_error', error: {_js_str(error or 'Unknown error')} }}" + + return f""" + +Trakt Authorization + +

+ {'Authorization successful! You can close this window.' if success else f'Authorization failed: {error}'} +

+ + +""" + + +def _js_str(value: str | None) -> str: + import json + return json.dumps(value) diff --git a/app/api/router.py b/app/api/router.py index 72c99bc..0552cc0 100644 --- a/app/api/router.py +++ b/app/api/router.py @@ -7,6 +7,7 @@ from .endpoints.meta import router as meta_router from .endpoints.stats import router as stats_router from .endpoints.tokens import router as tokens_router +from .endpoints.trakt import router as trakt_router from .endpoints.validation import router as validation_router api_router = APIRouter() @@ -20,6 +21,7 @@ async def root(): api_router.include_router(manifest_router) api_router.include_router(catalogs_router) api_router.include_router(tokens_router) +api_router.include_router(trakt_router) api_router.include_router(health_router) api_router.include_router(meta_router) api_router.include_router(announcement_router) diff --git a/app/core/config.py b/app/core/config.py index 5ee7d29..64f24b6 100644 --- a/app/core/config.py +++ b/app/core/config.py @@ -45,6 +45,10 @@ class Settings(BaseSettings): DEFAULT_GEMINI_MODEL: str = "gemma-3-27b-it" GEMINI_API_KEY: str | None = None + # Trakt OAuth + TRAKT_CLIENT_ID: str | None = None + TRAKT_CLIENT_SECRET: str | None = None + settings = Settings() diff --git a/app/services/catalog.py b/app/services/catalog.py index 73cb55f..8a24f58 100644 --- a/app/services/catalog.py +++ b/app/services/catalog.py @@ -57,6 +57,53 @@ def build_catalog_entry(self, item, label, config_id, display_at_home: bool = Tr "extra": extra, } + async def _stabilize_catalog_ids(self, catalogs: list[dict], token: str) -> list[dict]: + """ + Replace dynamic content-encoded catalog IDs with stable positional slot IDs + and persist a slot→real_id map in Redis so catalog_service can resolve them. + + watchly.watched.tt0209144 → watchly.watched.slot0 + watchly.loved.tt0816692 → watchly.loved.slot0 + watchly.theme.a:g27... → watchly.theme.slot0 (per type) + + The slot numbers are per-prefix per-type so movie slot0 and series slot0 + are independent, matching the pattern users see in the UI. + """ + from app.services.user_cache import user_cache + + slot_map: dict[str, str] = {} # stable_id → real_id + counters: dict[str, int] = {} # prefix:type → counter + stabilized = [] + + for cat in catalogs: + real_id: str = cat["id"] + cat_type: str = cat.get("type", "") + + # Determine if this is a dynamic ID that needs stabilizing + dynamic_prefixes = ("watchly.watched.", "watchly.loved.", "watchly.theme.") + matched_prefix = next((p for p in dynamic_prefixes if real_id.startswith(p)), None) + + if matched_prefix: + # Strip the prefix to get the content part + content_part = real_id[len(matched_prefix):] + # Only stabilize if the content part looks like an ID (tt...) or theme params + # Fixed IDs like "watchly.rec", "watchly.creators" are left alone + if content_part and not content_part.startswith("slot"): + counter_key = f"{matched_prefix.rstrip('.')}:{cat_type}" + slot_num = counters.get(counter_key, 0) + counters[counter_key] = slot_num + 1 + stable_id = f"{matched_prefix.rstrip('.')}.slot{slot_num}" + slot_map[stable_id] = real_id + stabilized.append({**cat, "id": stable_id}) + continue + + stabilized.append(cat) + + if slot_map: + await user_cache.set_catalog_slot_map(token, slot_map) + + return stabilized + def _get_smart_scored_items(self, library_items: dict, content_type: str, max_items: int = 50) -> list: """ Get smart sampled items for profile building. @@ -236,6 +283,14 @@ async def get_dynamic_catalogs( # 4. Add watchly.rec catalog catalogs.extend(get_catalogs_from_config(user_settings, "watchly.rec", "Top Picks for You", True, True)) + # 5. Stabilize dynamic catalog IDs so external apps (Nuvio, aiostreams) can + # order them consistently. Replace content-encoded IDs like + # "watchly.watched.tt0209144" and "watchly.theme.a:g27..." with stable + # positional slot IDs like "watchly.watched.slot0", "watchly.theme.slot0". + # A Redis mapping records which real ID each slot resolves to at fetch time. + if token: + catalogs = await self._stabilize_catalog_ids(catalogs, token) + # 5. Add watchly.creators catalog catalogs.extend( get_catalogs_from_config(user_settings, "watchly.creators", "From your favourite Creators", False, False) diff --git a/app/services/catalog_updater.py b/app/services/catalog_updater.py index 15dd20f..55fb774 100644 --- a/app/services/catalog_updater.py +++ b/app/services/catalog_updater.py @@ -73,6 +73,10 @@ async def refresh_catalogs_for_credentials( logger.warning(f"[{redact_token(token)}] Attempted to refresh catalogs with no credentials.") raise HTTPException(status_code=401, detail="Invalid or expired token. Please reconfigure the addon.") + # Trakt-backed accounts use a different refresh path + if credentials.get("auth_provider") == "trakt": + return await self._refresh_trakt_catalogs(token, credentials, update_timestamp) + auth_key = credentials.get("authKey") # check if auth key is valid bundle = StremioBundle() @@ -165,6 +169,74 @@ async def refresh_catalogs_for_credentials( finally: await bundle.close() + async def _refresh_trakt_catalogs( + self, token: str, credentials: dict[str, Any], update_timestamp: bool = True + ) -> bool: + """Refresh catalogs for a Trakt-backed account.""" + from app.core.settings import resolve_tmdb_api_key + from app.services.trakt.service import TraktBundle + + user_settings = None + if credentials.get("settings"): + try: + user_settings = UserSettings(**credentials["settings"]) + except Exception as e: + logger.warning(f"[{redact_token(token)}] Failed to parse Trakt user settings: {e}") + return True + + access_token = credentials.get("authKey") # stored as authKey after decrypt + if not access_token or not settings.TRAKT_CLIENT_ID or not settings.TRAKT_CLIENT_SECRET: + logger.warning(f"[{redact_token(token)}] Trakt credentials missing, skipping refresh") + return True + + redirect_uri = f"{settings.HOST_NAME}/tokens/trakt/callback" + + # Refresh access token if near expiry (within 7 days) + import time + expires_at = credentials.get("trakt_expires_at") + refresh_token_value = credentials.get("trakt_refresh_token") + if expires_at and refresh_token_value and int(time.time()) > (int(expires_at) - 604800): + logger.info(f"[{redact_token(token)}] Trakt access token near expiry, refreshing...") + try: + from app.services.trakt.auth import TraktAuthService + auth_service = TraktAuthService( + client_id=settings.TRAKT_CLIENT_ID, + client_secret=settings.TRAKT_CLIENT_SECRET, + redirect_uri=redirect_uri, + ) + token_data = await auth_service.refresh_token(refresh_token_value) + access_token = token_data["access_token"] + credentials["authKey"] = access_token + credentials["trakt_refresh_token"] = token_data.get("refresh_token", refresh_token_value) + credentials["trakt_expires_at"] = int(time.time()) + token_data.get("expires_in", 7776000) + await token_store.update_user_data(token, credentials) + logger.info(f"[{redact_token(token)}] Trakt access token refreshed successfully") + except Exception as e: + logger.warning(f"[{redact_token(token)}] Failed to refresh Trakt token: {e}") + + trakt_bundle = TraktBundle( + client_id=settings.TRAKT_CLIENT_ID, + client_secret=settings.TRAKT_CLIENT_SECRET, + redirect_uri=redirect_uri, + access_token=access_token, + ) + try: + library_items = await trakt_bundle.library.get_library_items() + await manifest_service.cache_library_and_profiles_from_items(library_items, user_settings, token) + + if update_timestamp: + now = datetime.now(timezone.utc) + credentials["last_updated"] = now.replace(microsecond=0).isoformat() + await token_store.update_user_data(token, credentials) + + logger.info(f"[{redact_token(token)}] Trakt catalog refresh complete") + return True + except Exception as e: + logger.exception(f"[{redact_token(token)}] Trakt catalog refresh failed: {e}") + return False + finally: + await trakt_bundle.close() + async def trigger_update(self, token: str, credentials: dict[str, Any]) -> None: """ Trigger a catalog update if needed. diff --git a/app/services/manifest.py b/app/services/manifest.py index dc3c855..4176470 100644 --- a/app/services/manifest.py +++ b/app/services/manifest.py @@ -113,6 +113,32 @@ async def cache_library_and_profiles( return library_items + async def cache_library_and_profiles_from_items( + self, library_items: dict, user_settings: UserSettings, token: str + ) -> None: + """ + Cache library items and build profiles from an already-fetched library dict. + Used by Trakt (and any future non-Stremio provider) where library data is + obtained outside of the Stremio bundle. + """ + await user_cache.set_library_items(token, library_items) + logger.debug(f"[{redact_token(token)}] Cached library items (provider-agnostic)") + + language = user_settings.language + tmdb_key = resolve_tmdb_api_key(user_settings) + integration_service = ProfileIntegration(language=language, tmdb_api_key=tmdb_key) + + for content_type in ["movie", "series"]: + try: + profile, watched_tmdb, watched_imdb = await integration_service.build_profile_from_library( + library_items, content_type + ) + await user_cache.set_profile_and_watched_sets(token, content_type, profile, watched_tmdb, watched_imdb) + logger.debug(f"[{redact_token(token)}] Cached profile for {content_type}") + except Exception as e: + logger.warning(f"[{redact_token(token)}] Failed to cache profile for {content_type}: {e}") + + async def _ensure_library_and_profiles_cached( self, bundle: StremioBundle, auth_key: str, user_settings: UserSettings, token: str ) -> dict[str, Any]: @@ -163,6 +189,43 @@ def _sort_catalogs( return sort_catalogs(catalogs, user_settings) + async def _build_dynamic_catalogs_trakt( + self, creds: dict, user_settings: UserSettings | None, token: str + ) -> list[dict[str, Any]]: + """Build dynamic catalogs for a Trakt-backed account.""" + from app.core.config import settings as app_settings + from app.services.trakt.service import TraktBundle + + # Use cached library if available + library_items = await user_cache.get_library_items(token) + if not library_items: + access_token = creds.get("authKey") # stored as authKey after encryption/decryption + if not access_token or not app_settings.TRAKT_CLIENT_ID or not app_settings.TRAKT_CLIENT_SECRET: + logger.warning(f"[{redact_token(token)}] Trakt credentials missing, cannot fetch library") + return [] + redirect_uri = f"{app_settings.HOST_NAME}/tokens/trakt/callback" + trakt_bundle = TraktBundle( + client_id=app_settings.TRAKT_CLIENT_ID, + client_secret=app_settings.TRAKT_CLIENT_SECRET, + redirect_uri=redirect_uri, + access_token=access_token, + ) + try: + library_items = await trakt_bundle.library.get_library_items() + await user_cache.set_library_items(token, library_items) + finally: + await trakt_bundle.close() + + if not library_items: + return [] + + tmdb_key = resolve_tmdb_api_key(user_settings) + dynamic_catalog_service = DynamicCatalogService( + language=user_settings.language if user_settings else "en-US", + tmdb_api_key=tmdb_key, + ) + return await dynamic_catalog_service.get_dynamic_catalogs(library_items, user_settings, token=token) + async def get_manifest_for_token(self, token: str) -> dict[str, Any]: """ Generate manifest for a given token. @@ -194,19 +257,24 @@ async def get_manifest_for_token(self, token: str) -> dict[str, Any]: base_manifest = self.get_base_manifest() - bundle = StremioBundle() fetched_catalogs = [] try: - # Resolve auth key - auth_key = await self._resolve_auth_key(bundle, creds, token) - - if auth_key: - fetched_catalogs = await self._build_dynamic_catalogs(bundle, auth_key, user_settings, token) + if creds.get("auth_provider") == "trakt": + # Trakt-backed account: fetch library from Trakt, bypass Stremio + fetched_catalogs = await self._build_dynamic_catalogs_trakt(creds, user_settings, token) + else: + bundle = StremioBundle() + try: + # Resolve auth key + auth_key = await self._resolve_auth_key(bundle, creds, token) + + if auth_key: + fetched_catalogs = await self._build_dynamic_catalogs(bundle, auth_key, user_settings, token) + finally: + await bundle.close() except Exception as e: logger.exception(f"[{redact_token(token)}] Dynamic catalog build failed: {e}") fetched_catalogs = [] - finally: - await bundle.close() # Combine base catalogs with fetched catalogs all_catalogs = [c.copy() for c in base_manifest["catalogs"]] + [c.copy() for c in fetched_catalogs] diff --git a/app/services/recommendation/catalog_service.py b/app/services/recommendation/catalog_service.py index e277765..eb94390 100644 --- a/app/services/recommendation/catalog_service.py +++ b/app/services/recommendation/catalog_service.py @@ -133,6 +133,18 @@ async def get_catalog( # continue with the request even if the auto update fails pass + # Resolve stable slot ID to real dynamic catalog ID if needed + slot_prefixes = ("watchly.watched.slot", "watchly.loved.slot", "watchly.theme.slot") + if any(catalog_id.startswith(p) for p in slot_prefixes): + slot_map = await user_cache.get_catalog_slot_map(token) + if slot_map and catalog_id in slot_map: + real_id = slot_map[catalog_id] + logger.debug(f"[{redact_token(token)}...] Resolved slot {catalog_id} → {real_id}") + catalog_id = real_id + else: + logger.warning(f"[{redact_token(token)}...] Slot {catalog_id} not found in slot map, cannot resolve") + raise HTTPException(status_code=404, detail="Catalog slot not found. Please re-configure the addon.") + bundle = StremioBundle() user_settings = None stale_data = None @@ -296,7 +308,9 @@ def _validate_inputs(self, token: str, content_type: str, catalog_id: str) -> No "watchly.liked.all", ] supported_prefixes = ("watchly.theme.", "watchly.loved.", "watchly.watched.") - if catalog_id not in supported_base and not any(catalog_id.startswith(p) for p in supported_prefixes): + # Also accept stable slot IDs (e.g. watchly.watched.slot0, watchly.theme.slot1) + is_slot = any(catalog_id.startswith(p.rstrip(".") + ".slot") for p in supported_prefixes) + if catalog_id not in supported_base and not any(catalog_id.startswith(p) for p in supported_prefixes) and not is_slot: logger.warning(f"Invalid id: {catalog_id}") raise HTTPException( status_code=400, @@ -308,6 +322,14 @@ def _validate_inputs(self, token: str, content_type: str, catalog_id: str) -> No async def _resolve_auth(self, bundle: StremioBundle, credentials: dict, token: str) -> str: auth_key = credentials.get("authKey") + + # Trakt accounts use a Trakt access token stored as authKey. + # Skip Stremio session validation entirely for these accounts. + if credentials.get("auth_provider") == "trakt": + if not auth_key: + raise HTTPException(status_code=401, detail="Trakt session expired. Please reconfigure.") + return auth_key + email = credentials.get("email") password = credentials.get("password") diff --git a/app/services/token_store.py b/app/services/token_store.py index 2f0a8ae..f428b6f 100644 --- a/app/services/token_store.py +++ b/app/services/token_store.py @@ -56,6 +56,16 @@ def _format_key(self, token: str) -> str: return f"{self.KEY_PREFIX}{token}" def get_token_from_user_id(self, user_id: str) -> str: + """ + For Trakt users, generate a stable opaque token from the user_id + so the username is not exposed in the manifest URL. + Stremio users keep their existing behaviour (user_id == token). + """ + if user_id.startswith("trakt:"): + import hashlib + salt = settings.TOKEN_SALT or "watchly" + digest = hashlib.sha256(f"{salt}:{user_id}".encode()).hexdigest() + return digest[:40] return user_id.strip() def get_user_id_from_token(self, token: str) -> str: @@ -75,6 +85,14 @@ async def store_user_data(self, user_id: str, payload: dict[str, Any]) -> str: if storage_data.get("authKey"): storage_data["authKey"] = self.encrypt_token(storage_data["authKey"]) + # Encrypt Trakt refresh token if present + if storage_data.get("trakt_refresh_token"): + try: + if not storage_data["trakt_refresh_token"].startswith("gAAAAAB"): + storage_data["trakt_refresh_token"] = self.encrypt_token(storage_data["trakt_refresh_token"]) + except Exception as exc: + logger.warning(f"Failed to encrypt trakt_refresh_token: {exc}") + # Securely store password if provided (primary login mode) if storage_data.get("password"): try: @@ -250,6 +268,13 @@ async def _get_user_data_cached(self, token: str) -> dict[str, Any] | None: logger.warning(f"Decryption failed for authKey associated with {redact_token(token)}: {e}") # Leave as-is (legacy plaintext or previous failure) pass + + if data.get("trakt_refresh_token"): + try: + if data["trakt_refresh_token"].startswith("gAAAAA"): + data["trakt_refresh_token"] = self.decrypt_token(data["trakt_refresh_token"]) + except Exception as e: + logger.debug(f"Decryption failed for trakt_refresh_token associated with {redact_token(token)}: {e}") if data.get("password"): try: data["password"] = self.decrypt_token(data["password"]) diff --git a/app/services/trakt/__init__.py b/app/services/trakt/__init__.py new file mode 100644 index 0000000..4ddf4c4 --- /dev/null +++ b/app/services/trakt/__init__.py @@ -0,0 +1,3 @@ +from app.services.trakt.service import TraktBundle + +__all__ = ["TraktBundle"] diff --git a/app/services/trakt/auth.py b/app/services/trakt/auth.py new file mode 100644 index 0000000..1b8b17b --- /dev/null +++ b/app/services/trakt/auth.py @@ -0,0 +1,79 @@ +import secrets +from typing import Any + +import httpx + + +# Module-level shared client for connection pooling across token exchanges. +# auth.py only talks to one endpoint (api.trakt.tv/oauth/token) so a single +# persistent client is sufficient and avoids the overhead of creating a new +# TCP connection for every OAuth exchange. +_http_client: httpx.AsyncClient | None = None + + +def _get_http_client() -> httpx.AsyncClient: + global _http_client + if _http_client is None or _http_client.is_closed: + _http_client = httpx.AsyncClient(timeout=15.0) + return _http_client + + +class TraktAuthService: + """ + Handles Trakt OAuth2 authentication (Authorization Code flow). + """ + + TOKEN_URL = "https://api.trakt.tv/oauth/token" + AUTHORIZE_URL = "https://trakt.tv/oauth/authorize" + + def __init__(self, client_id: str, client_secret: str, redirect_uri: str): + self.client_id = client_id + self.client_secret = client_secret + self.redirect_uri = redirect_uri + + def get_authorize_url(self, state: str | None = None) -> tuple[str, str]: + """ + Build the OAuth2 authorization URL and return it along with the state value. + """ + if not state: + state = secrets.token_urlsafe(16) + + params = { + "response_type": "code", + "client_id": self.client_id, + "redirect_uri": self.redirect_uri, + "state": state, + } + query = "&".join(f"{k}={v}" for k, v in params.items()) + return f"{self.AUTHORIZE_URL}?{query}", state + + async def exchange_code(self, code: str) -> dict[str, Any]: + """ + Exchange an authorization code for tokens. + Returns dict with access_token, refresh_token, expires_in, etc. + """ + payload = { + "code": code, + "client_id": self.client_id, + "client_secret": self.client_secret, + "redirect_uri": self.redirect_uri, + "grant_type": "authorization_code", + } + client = _get_http_client() + response = await client.post(self.TOKEN_URL, json=payload) + response.raise_for_status() + return response.json() + + async def refresh_token(self, refresh_token_value: str) -> dict[str, Any]: + """Refresh an expired access token.""" + payload = { + "refresh_token": refresh_token_value, + "client_id": self.client_id, + "client_secret": self.client_secret, + "redirect_uri": self.redirect_uri, + "grant_type": "refresh_token", + } + client = _get_http_client() + response = await client.post(self.TOKEN_URL, json=payload) + response.raise_for_status() + return response.json() diff --git a/app/services/trakt/client.py b/app/services/trakt/client.py new file mode 100644 index 0000000..7c15e04 --- /dev/null +++ b/app/services/trakt/client.py @@ -0,0 +1,18 @@ +from app.core.base_client import BaseClient + + +class TraktClient(BaseClient): + """ + Client for interacting with the Trakt API. + """ + + def __init__(self, client_id: str, access_token: str | None = None, timeout: float = 10.0, max_retries: int = 3): + headers = { + "Content-Type": "application/json", + "trakt-api-version": "2", + "trakt-api-key": client_id, + } + if access_token: + headers["Authorization"] = f"Bearer {access_token}" + + super().__init__(base_url="https://api.trakt.tv", timeout=timeout, max_retries=max_retries, headers=headers) diff --git a/app/services/trakt/library.py b/app/services/trakt/library.py new file mode 100644 index 0000000..ac8d7a6 --- /dev/null +++ b/app/services/trakt/library.py @@ -0,0 +1,136 @@ +from typing import Any + +from loguru import logger + +from app.services.trakt.client import TraktClient + + +class TraktLibraryService: + """ + Fetches and normalises watch history from Trakt into the same shape + that the Stremio library service produces, so the rest of the app + needs no changes. + """ + + def __init__(self, client: TraktClient): + self.client = client + + # ------------------------------------------------------------------ + # Public helpers + # ------------------------------------------------------------------ + + async def get_library_items(self) -> dict[str, list[dict[str, Any]]]: + """ + Return library items in the same shape as StremioLibraryService: + { "watched": [...], "loved": [], "liked": [], "added": [], "removed": [] } + + Each item contains at minimum: + _id – tt... or tmdb:... string + type – "movie" | "series" + name – title + """ + try: + import asyncio + movies, shows = await asyncio.gather( + self._get_history("movies"), + self._get_history("shows"), + ) + + watched: list[dict[str, Any]] = [] + seen_ids: set[str] = set() + + for raw in movies: + item = self._normalise_movie(raw) + if item and item["_id"] not in seen_ids: + seen_ids.add(item["_id"]) + watched.append(item) + + for raw in shows: + item = self._normalise_show(raw) + if item and item["_id"] not in seen_ids: + seen_ids.add(item["_id"]) + watched.append(item) + + logger.info(f"[Trakt] library: {len(watched)} watched items ({len(movies)} movies, {len(shows)} shows)") + + return { + "watched": watched, + "loved": [], + "liked": [], + "added": [], + "removed": [], + } + except Exception as e: + logger.exception(f"[Trakt] Failed to get library items: {e}") + return {"watched": [], "loved": [], "liked": [], "added": [], "removed": []} + + # ------------------------------------------------------------------ + # Private helpers + # ------------------------------------------------------------------ + + async def _get_history(self, media_type: str) -> list[dict[str, Any]]: + """ + Pull watched history for *media_type* ("movies" | "shows"). + Uses the /users/me/watched/:type endpoint which returns a deduplicated + list of everything the user has ever played (no paging needed). + """ + try: + data = await self.client.get(f"/users/me/watched/{media_type}") + if isinstance(data, list): + return data + return [] + except Exception as e: + logger.warning(f"[Trakt] Failed to fetch {media_type} history: {e}") + return [] + + def _get_id(self, ids: dict[str, Any]) -> str | None: + """Return the best available canonical ID (prefer IMDb, fall back to TMDB).""" + imdb = ids.get("imdb") + if imdb: + return imdb # e.g. "tt1234567" + tmdb = ids.get("tmdb") + if tmdb: + return f"tmdb:{tmdb}" + return None + + def _normalise_movie(self, raw: dict[str, Any]) -> dict[str, Any] | None: + movie = raw.get("movie", {}) + ids = movie.get("ids", {}) + canonical_id = self._get_id(ids) + if not canonical_id: + return None + return { + "_id": canonical_id, + "type": "movie", + "name": movie.get("title", ""), + "year": movie.get("year"), + "state": { + "timesWatched": raw.get("plays", 1), + "flaggedWatched": 1, + "lastWatched": raw.get("last_watched_at", ""), + }, + "temp": False, + "removed": False, + "_source": "trakt", + } + + def _normalise_show(self, raw: dict[str, Any]) -> dict[str, Any] | None: + show = raw.get("show", {}) + ids = show.get("ids", {}) + canonical_id = self._get_id(ids) + if not canonical_id: + return None + return { + "_id": canonical_id, + "type": "series", + "name": show.get("title", ""), + "year": show.get("year"), + "state": { + "timesWatched": raw.get("plays", 1), + "flaggedWatched": 1, + "lastWatched": raw.get("last_watched_at", ""), + }, + "temp": False, + "removed": False, + "_source": "trakt", + } diff --git a/app/services/trakt/service.py b/app/services/trakt/service.py new file mode 100644 index 0000000..7f6001c --- /dev/null +++ b/app/services/trakt/service.py @@ -0,0 +1,23 @@ +from app.services.trakt.auth import TraktAuthService +from app.services.trakt.client import TraktClient +from app.services.trakt.library import TraktLibraryService +from app.services.trakt.user import TraktUserService + + +class TraktBundle: + """ + Unified bundle for all Trakt-related services. + """ + + def __init__(self, client_id: str, client_secret: str, redirect_uri: str, access_token: str | None = None): + self.auth = TraktAuthService( + client_id=client_id, + client_secret=client_secret, + redirect_uri=redirect_uri, + ) + self._client = TraktClient(client_id=client_id, access_token=access_token) + self.user = TraktUserService(self._client) + self.library = TraktLibraryService(self._client) + + async def close(self): + await self._client.close() diff --git a/app/services/trakt/user.py b/app/services/trakt/user.py new file mode 100644 index 0000000..7d6ccbf --- /dev/null +++ b/app/services/trakt/user.py @@ -0,0 +1,23 @@ +from typing import Any + +from loguru import logger + +from app.services.trakt.client import TraktClient + + +class TraktUserService: + """ + Fetches the authenticated Trakt user's profile. + """ + + def __init__(self, client: TraktClient): + self.client = client + + async def get_user_info(self) -> dict[str, Any]: + """Return the authenticated user's profile (username, name, etc.).""" + try: + data = await self.client.get("/users/me?extended=full") + return data + except Exception as e: + logger.exception(f"Failed to fetch Trakt user info: {e}") + raise diff --git a/app/services/user_cache.py b/app/services/user_cache.py index d1ace43..3e718e9 100644 --- a/app/services/user_cache.py +++ b/app/services/user_cache.py @@ -404,6 +404,31 @@ async def invalidate_catalog(self, token: str, type: str, id: str) -> None: await redis_service.delete(key) logger.debug(f"[{redact_token(token)}...] Invalidated catalog cache for {type}/{id}") + async def get_catalog_slot_map(self, token: str) -> dict[str, str] | None: + """ + Return the slot-to-real-id mapping for dynamic catalogs. + e.g. {"watchly.watched.slot0": "watchly.watched.tt0209144", ...} + """ + key = f"watchly:catalog_slot_map:{token}" + try: + data = await redis_service.get(key) + if data: + import json + return json.loads(data) + except Exception as e: + logger.warning(f"[{redact_token(token)}...] Failed to get catalog slot map: {e}") + return None + + async def set_catalog_slot_map(self, token: str, slot_map: dict[str, str]) -> None: + """Store the slot-to-real-id mapping for dynamic catalogs.""" + key = f"watchly:catalog_slot_map:{token}" + try: + import json + await redis_service.set(key, json.dumps(slot_map), 86400 * 7) + logger.debug(f"[{redact_token(token)}...] Stored catalog slot map ({len(slot_map)} entries)") + except Exception as e: + logger.warning(f"[{redact_token(token)}...] Failed to set catalog slot map: {e}") + async def invalidate_all_catalogs(self, token: str) -> None: """ Invalidate all cached catalogs for a user. diff --git a/app/static/js/main.js b/app/static/js/main.js index d79b92a..2c2f47c 100644 --- a/app/static/js/main.js +++ b/app/static/js/main.js @@ -4,6 +4,7 @@ import { defaultCatalogs } from './constants.js'; import { showToast, initializeFooter, initializeKofi } from './modules/ui.js'; import { initializeNavigation, switchSection, lockNavigationForLoggedOut, initializeMobileNav, updateMobileLayout, unlockNavigation } from './modules/navigation.js'; import { initializeAuth, setStremioLoggedOutState } from './modules/auth.js'; +import { initializeTrakt, setTraktLoggedOutState } from './modules/trakt.js'; import { initializeCatalogList, renderCatalogList, getCatalogs, setCatalogs } from './modules/catalog.js'; import { initializeForm, clearErrors } from './modules/form.js'; @@ -65,6 +66,9 @@ function resetApp() { // Reset Stremio State setStremioLoggedOutState(); + // Reset Trakt State + setTraktLoggedOutState(); + // Reset catalogs catalogsState = JSON.parse(JSON.stringify(defaultCatalogs)); setCatalogs(catalogsState); @@ -118,7 +122,7 @@ document.addEventListener('DOMContentLoaded', () => { } ); - // Initialize authentication + // Initialize authentication (Stremio) initializeAuth( { stremioLoginBtn, @@ -135,6 +139,16 @@ document.addEventListener('DOMContentLoaded', () => { } ); + // Initialize Trakt authentication + initializeTrakt( + { languageSelect }, + { + getCatalogs, + renderCatalogList, + resetApp + } + ); + // Initialize form handling initializeForm( { diff --git a/app/static/js/modules/form.js b/app/static/js/modules/form.js index 4c0c76d..b3f0bd2 100644 --- a/app/static/js/modules/form.js +++ b/app/static/js/modules/form.js @@ -1,6 +1,7 @@ // Form Submission and UI Helpers import { showToast, showConfirm, escapeHtml } from './ui.js'; +import { getTraktTokensFromStorage } from './trakt.js'; import { switchSection } from './navigation.js'; import { MOVIE_GENRES, SERIES_GENRES } from '../constants.js'; @@ -104,9 +105,13 @@ async function initializeFormSubmission() { }); }); + // Determine active provider + const traktTokens = getTraktTokensFromStorage(); + const isTraktLogin = !!(traktTokens && traktTokens.access_token && !sAuthKey && !email); + // Validation - if (!sAuthKey && !(email && password)) { - showError("generalError", "Please login with Stremio or enter email & password."); + if (!sAuthKey && !(email && password) && !isTraktLogin) { + showError("generalError", "Please login with Stremio or Trakt to continue."); switchSection('login'); return; } @@ -143,25 +148,51 @@ async function initializeFormSubmission() { }; } - const payload = { - authKey: sAuthKey || undefined, - email: email || undefined, - password: password || undefined, - catalogs: catalogsToSend, - language: language, - year_min: yearMin, - year_max: yearMax, - popularity: popularity, - sorting_order: sortingOrder, - poster_rating: posterRating, - tmdb_api_key: tmdbApiKey || undefined, - simkl_api_key: simklApiKey, - gemini_api_key: geminiApiKey, - excluded_movie_genres: excludedMovieGenres, - excluded_series_genres: excludedSeriesGenres - }; - - const response = await fetch("/tokens/", { + let endpoint, payload; + + if (isTraktLogin) { + // ---- Trakt submission ---- + endpoint = "/tokens/trakt/"; + payload = { + trakt_access_token: traktTokens.access_token, + trakt_refresh_token: traktTokens.refresh_token || undefined, + trakt_expires_at: traktTokens.expires_at || undefined, + catalogs: catalogsToSend, + language: language, + year_min: yearMin, + year_max: yearMax, + popularity: popularity, + sorting_order: sortingOrder, + poster_rating: posterRating, + tmdb_api_key: tmdbApiKey || undefined, + simkl_api_key: simklApiKey, + gemini_api_key: geminiApiKey, + excluded_movie_genres: excludedMovieGenres, + excluded_series_genres: excludedSeriesGenres + }; + } else { + // ---- Stremio submission ---- + endpoint = "/tokens/"; + payload = { + authKey: sAuthKey || undefined, + email: email || undefined, + password: password || undefined, + catalogs: catalogsToSend, + language: language, + year_min: yearMin, + year_max: yearMax, + popularity: popularity, + sorting_order: sortingOrder, + poster_rating: posterRating, + tmdb_api_key: tmdbApiKey || undefined, + simkl_api_key: simklApiKey, + gemini_api_key: geminiApiKey, + excluded_movie_genres: excludedMovieGenres, + excluded_series_genres: excludedSeriesGenres + }; + } + + const response = await fetch(endpoint, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) diff --git a/app/static/js/modules/trakt.js b/app/static/js/modules/trakt.js new file mode 100644 index 0000000..ec4b82d --- /dev/null +++ b/app/static/js/modules/trakt.js @@ -0,0 +1,381 @@ +// Trakt Authentication Module + +import { showToast } from './ui.js'; +import { switchSection, unlockNavigation } from './navigation.js'; + +// LocalStorage keys for Trakt +const TRAKT_STORAGE_KEY = 'watchly_trakt_auth'; +const EXPIRY_DAYS = 85; // Trakt tokens last 90 days; refresh a bit early + +let languageSelect = null; +let getCatalogs = null; +let renderCatalogList = null; +let resetApp = null; + +// -------------------------------------------------------------------------- +// Public API +// -------------------------------------------------------------------------- + +export function initializeTrakt(domElements, catalogState) { + languageSelect = domElements.languageSelect; + getCatalogs = catalogState.getCatalogs; + renderCatalogList = catalogState.renderCatalogList; + resetApp = catalogState.resetApp; + + initializeTraktConnectButton(); + initializeTraktLogoutButton(); + attemptTraktAutoLogin(); +} + +export function setTraktLoggedOutState() { + clearTraktFromStorage(); + hideTraktStatus(); + + const traktConnectBtn = document.getElementById('traktConnectBtn'); + if (traktConnectBtn) { + traktConnectBtn.classList.remove('hidden'); + } +} + +// -------------------------------------------------------------------------- +// Storage helpers +// -------------------------------------------------------------------------- + +function saveTraktToStorage(authData) { + try { + const expiryDate = new Date(); + expiryDate.setDate(expiryDate.getDate() + EXPIRY_DAYS); + localStorage.setItem(TRAKT_STORAGE_KEY, JSON.stringify({ ...authData, expiresAt: expiryDate.getTime() })); + } catch (e) { + console.warn('Failed to save Trakt auth:', e); + } +} + +function getTraktFromStorage() { + try { + const stored = localStorage.getItem(TRAKT_STORAGE_KEY); + if (!stored) return null; + const data = JSON.parse(stored); + if (data.expiresAt && data.expiresAt < Date.now()) { + clearTraktFromStorage(); + return null; + } + return data; + } catch (e) { + clearTraktFromStorage(); + return null; + } +} + +function clearTraktFromStorage() { + try { localStorage.removeItem(TRAKT_STORAGE_KEY); } catch (e) { /* noop */ } +} + +// -------------------------------------------------------------------------- +// OAuth popup flow +// -------------------------------------------------------------------------- + +function initializeTraktConnectButton() { + const btn = document.getElementById('traktConnectBtn'); + if (!btn) return; + + btn.addEventListener('click', async () => { + setTraktConnecting(true); + try { + // 1. Fetch the authorization URL from backend + const res = await fetch('/tokens/trakt/authorize'); + if (!res.ok) { + const err = await res.json().catch(() => ({})); + throw new Error(err.detail || 'Failed to start Trakt authorization'); + } + const { url } = await res.json(); + + // 2. Open OAuth popup + const tokens = await openTraktPopup(url); + + // 3. Call identity check to get user info + existing settings + await fetchTraktIdentity(tokens); + + // 4. Save to storage + saveTraktToStorage(tokens); + + unlockNavigation(); + switchSection('config'); + } catch (err) { + showToast(err.message || 'Trakt login failed', 'error'); + } finally { + setTraktConnecting(false); + } + }); +} + +function initializeTraktLogoutButton() { + const btn = document.getElementById('traktLogoutBtn'); + if (!btn) return; + btn.addEventListener('click', () => { + if (resetApp) resetApp(); + }); +} + +/** + * Open a popup window for Trakt OAuth and resolve when the callback page + * posts a message back to us. + */ +function openTraktPopup(url) { + return new Promise((resolve, reject) => { + const width = 600; + const height = 700; + const left = Math.round(window.screenX + (window.outerWidth - width) / 2); + const top = Math.round(window.screenY + (window.outerHeight - height) / 2); + + const popup = window.open( + url, + 'trakt_oauth', + `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes` + ); + + if (!popup) { + reject(new Error('Could not open the authorization popup. Please allow popups for this site.')); + return; + } + + let settled = false; + + function onMessage(event) { + // Only accept messages from our own origin + if (event.origin !== window.location.origin) return; + const data = event.data; + if (!data || typeof data !== 'object') return; + + if (data.type === 'trakt_auth_success') { + if (!settled) { + settled = true; + cleanup(); + resolve({ + access_token: data.access_token, + refresh_token: data.refresh_token, + expires_at: data.expires_at, + }); + } + } else if (data.type === 'trakt_auth_error') { + if (!settled) { + settled = true; + cleanup(); + reject(new Error(data.error || 'Trakt authorization failed')); + } + } + } + + // Also detect if the user closes the popup manually + const pollTimer = setInterval(() => { + if (popup.closed && !settled) { + settled = true; + cleanup(); + reject(new Error('Authorization window was closed')); + } + }, 500); + + function cleanup() { + window.removeEventListener('message', onMessage); + clearInterval(pollTimer); + } + + window.addEventListener('message', onMessage); + }); +} + +// -------------------------------------------------------------------------- +// Identity fetch + settings population +// -------------------------------------------------------------------------- + +async function fetchTraktIdentity(tokens) { + const payload = { + trakt_access_token: tokens.access_token, + trakt_refresh_token: tokens.refresh_token || null, + trakt_expires_at: tokens.expires_at || null, + }; + + const res = await fetch('/tokens/trakt/identity', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(payload), + }); + + if (!res.ok) { + const err = await res.json().catch(() => ({})); + throw new Error(err.detail || 'Failed to verify Trakt identity'); + } + + const data = await res.json(); + const display = data.display || data.username || 'Trakt User'; + + showTraktStatus(display); + + if (data.exists && data.settings) { + showToast(`Welcome back, ${display}! Loading your settings…`, 'info', 5000); + populateSettings(data.settings); + + const installHeader = document.querySelector('#sect-install h2'); + const installDesc = document.querySelector('#sect-install p'); + if (installHeader) installHeader.textContent = 'Update Settings'; + if (installDesc) installDesc.textContent = 'Update your preferences and re-install.'; + + const btnText = document.querySelector('#submitBtn .btn-text'); + if (btnText) btnText.textContent = 'Update & Re-Install'; + } else { + showToast(`Welcome, ${display}! Setting up your account…`, 'success', 5000); + } + + // Store display name so the form submit can use it + const traktDisplayInput = document.getElementById('traktDisplayName'); + if (traktDisplayInput) traktDisplayInput.value = display; +} + +function populateSettings(s) { + if (s.language && languageSelect) languageSelect.value = s.language; + + const popularitySelect = document.getElementById('popularitySelect'); + const yearMinInput = document.getElementById('yearMin'); + const yearMaxInput = document.getElementById('yearMax'); + const sortingOrderSelect = document.getElementById('sortingOrderSelect'); + + if (s.popularity && popularitySelect) popularitySelect.value = s.popularity; + if (s.year_min && yearMinInput) yearMinInput.value = s.year_min; + if (s.year_max && yearMaxInput) yearMaxInput.value = s.year_max; + if (window.updateYearSlider) window.updateYearSlider(); + if (s.sorting_order && sortingOrderSelect) sortingOrderSelect.value = s.sorting_order; + + const posterRatingProvider = document.getElementById('posterRatingProvider'); + const posterRatingApiKey = document.getElementById('posterRatingApiKey'); + if (posterRatingProvider && posterRatingApiKey && s.poster_rating?.provider && s.poster_rating?.api_key) { + posterRatingProvider.value = s.poster_rating.provider; + posterRatingApiKey.value = s.poster_rating.api_key; + posterRatingProvider.dispatchEvent(new Event('change')); + } + + const tmdbApiKeyInput = document.getElementById('tmdbApiKey'); + if (s.tmdb_api_key && tmdbApiKeyInput) tmdbApiKeyInput.value = s.tmdb_api_key; + + const simklApiKeyInput = document.getElementById('simklApiKey'); + if (s.simkl_api_key && simklApiKeyInput) simklApiKeyInput.value = s.simkl_api_key; + + const geminiApiKeyInput = document.getElementById('geminiApiKey'); + if (s.gemini_api_key && geminiApiKeyInput) geminiApiKeyInput.value = s.gemini_api_key; + + // Genres + document.querySelectorAll('input[name="movie-genre"]').forEach(cb => cb.checked = false); + document.querySelectorAll('input[name="series-genre"]').forEach(cb => cb.checked = false); + if (s.excluded_movie_genres) s.excluded_movie_genres.forEach(id => { + const cb = document.querySelector(`input[name="movie-genre"][value="${id}"]`); + if (cb) cb.checked = true; + }); + if (s.excluded_series_genres) s.excluded_series_genres.forEach(id => { + const cb = document.querySelector(`input[name="series-genre"][value="${id}"]`); + if (cb) cb.checked = true; + }); + + // Catalogs + if (s.catalogs && Array.isArray(s.catalogs)) { + const catalogs = getCatalogs ? getCatalogs() : []; + s.catalogs.forEach(remote => { + const local = catalogs.find(c => c.id === remote.id); + if (local) { + local.enabled = remote.enabled; + if (remote.name) local.name = remote.name; + if (typeof remote.enabled_movie === 'boolean') local.enabledMovie = remote.enabled_movie; + if (typeof remote.enabled_series === 'boolean') local.enabledSeries = remote.enabled_series; + if (typeof remote.display_at_home === 'boolean') local.display_at_home = remote.display_at_home; + if (typeof remote.shuffle === 'boolean') local.shuffle = remote.shuffle; + } + }); + if (renderCatalogList) renderCatalogList(); + } +} + +// -------------------------------------------------------------------------- +// Auto-login +// -------------------------------------------------------------------------- + +async function attemptTraktAutoLogin() { + const stored = getTraktFromStorage(); + if (!stored?.access_token) return; + + try { + await fetchTraktIdentity(stored); + unlockNavigation(); + switchSection('config'); + } catch (err) { + console.warn('Trakt auto-login failed:', err); + clearTraktFromStorage(); + } +} + +// -------------------------------------------------------------------------- +// UI helpers +// -------------------------------------------------------------------------- + +function setTraktConnecting(loading) { + const btn = document.getElementById('traktConnectBtn'); + if (!btn) return; + const text = btn.querySelector('.btn-text'); + const loader = btn.querySelector('.loader'); + btn.disabled = loading; + if (text) text.classList.toggle('hidden', loading); + if (loader) loader.classList.toggle('hidden', !loading); +} + +export function showTraktStatus(displayName) { + const statusSection = document.getElementById('traktStatusSection'); + const displayEl = document.getElementById('traktStatusDisplay'); + const avatarEl = document.getElementById('traktStatusAvatar'); + const connectBtn = document.getElementById('traktConnectBtn'); + + if (displayEl) displayEl.textContent = displayName; + if (avatarEl) avatarEl.textContent = getInitials(displayName); + if (statusSection) statusSection.classList.remove('hidden'); + if (connectBtn) connectBtn.classList.add('hidden'); + + // Sidebar profile + const userProfileWrapper = document.getElementById('user-profile-dropdown-wrapper'); + const userEmail = document.getElementById('user-email'); + const userAvatar = document.getElementById('user-avatar'); + const loginFormCard = document.getElementById('loginFormCard'); + + if (userEmail) userEmail.textContent = displayName; + if (userAvatar) userAvatar.textContent = getInitials(displayName); + if (userProfileWrapper) userProfileWrapper.classList.remove('hidden'); + // Keep loginFormCard visible so users can navigate back and see the Trakt tab + // Instead, switch to Trakt tab so it's clear which provider is active + try { + const saved = localStorage.getItem('watchly_login_tab'); + if (!saved || saved === 'trakt') { + const traktTab = document.getElementById('tabTrakt'); + if (traktTab) traktTab.click(); + } + } catch(e) {} +} + +function hideTraktStatus() { + const statusSection = document.getElementById('traktStatusSection'); + const connectBtn = document.getElementById('traktConnectBtn'); + if (statusSection) statusSection.classList.add('hidden'); + if (connectBtn) connectBtn.classList.remove('hidden'); + + const userProfileWrapper = document.getElementById('user-profile-dropdown-wrapper'); + if (userProfileWrapper) userProfileWrapper.classList.add('hidden'); +} + +function getInitials(name) { + if (!name) return '?'; + const parts = name.trim().split(/[\s._-]+/); + if (parts.length >= 2) return (parts[0][0] + parts[1][0]).toUpperCase(); + return name.substring(0, 2).toUpperCase(); +} + +// -------------------------------------------------------------------------- +// Exported helpers for form.js +// -------------------------------------------------------------------------- + +export function getTraktTokensFromStorage() { + return getTraktFromStorage(); +} diff --git a/app/templates/components/section_login.html b/app/templates/components/section_login.html index 1443106..79acb4c 100644 --- a/app/templates/components/section_login.html +++ b/app/templates/components/section_login.html @@ -1,23 +1,20 @@ + + + + + diff --git a/app/templates/components/sidebar.html b/app/templates/components/sidebar.html index 865c3fe..cb66d35 100644 --- a/app/templates/components/sidebar.html +++ b/app/templates/components/sidebar.html @@ -88,7 +88,7 @@

"$REPO/app/services/trakt/__init__.py" +echo " wrote app/services/trakt/__init__.py" + +mkdir -p "$REPO/app/services/trakt" +echo "ZnJvbSBhcHAuY29yZS5iYXNlX2NsaWVudCBpbXBvcnQgQmFzZUNsaWVudAoKCmNsYXNzIFRyYWt0Q2xpZW50KEJhc2VDbGllbnQpOgogICAgIiIiCiAgICBDbGllbnQgZm9yIGludGVyYWN0aW5nIHdpdGggdGhlIFRyYWt0IEFQSS4KICAgICIiIgoKICAgIGRlZiBfX2luaXRfXyhzZWxmLCBjbGllbnRfaWQ6IHN0ciwgYWNjZXNzX3Rva2VuOiBzdHIgfCBOb25lID0gTm9uZSwgdGltZW91dDogZmxvYXQgPSAxMC4wLCBtYXhfcmV0cmllczogaW50ID0gMyk6CiAgICAgICAgaGVhZGVycyA9IHsKICAgICAgICAgICAgIkNvbnRlbnQtVHlwZSI6ICJhcHBsaWNhdGlvbi9qc29uIiwKICAgICAgICAgICAgInRyYWt0LWFwaS12ZXJzaW9uIjogIjIiLAogICAgICAgICAgICAidHJha3QtYXBpLWtleSI6IGNsaWVudF9pZCwKICAgICAgICB9CiAgICAgICAgaWYgYWNjZXNzX3Rva2VuOgogICAgICAgICAgICBoZWFkZXJzWyJBdXRob3JpemF0aW9uIl0gPSBmIkJlYXJlciB7YWNjZXNzX3Rva2VufSIKCiAgICAgICAgc3VwZXIoKS5fX2luaXRfXyhiYXNlX3VybD0iaHR0cHM6Ly9hcGkudHJha3QudHYiLCB0aW1lb3V0PXRpbWVvdXQsIG1heF9yZXRyaWVzPW1heF9yZXRyaWVzLCBoZWFkZXJzPWhlYWRlcnMpCg==" | base64 --decode > "$REPO/app/services/trakt/client.py" +echo " wrote app/services/trakt/client.py" + +mkdir -p "$REPO/app/services/trakt" +echo "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" | base64 --decode > "$REPO/app/services/trakt/auth.py" +echo " wrote app/services/trakt/auth.py" + +mkdir -p "$REPO/app/services/trakt" +echo "ZnJvbSB0eXBpbmcgaW1wb3J0IEFueQoKZnJvbSBsb2d1cnUgaW1wb3J0IGxvZ2dlcgoKZnJvbSBhcHAuc2VydmljZXMudHJha3QuY2xpZW50IGltcG9ydCBUcmFrdENsaWVudAoKCmNsYXNzIFRyYWt0VXNlclNlcnZpY2U6CiAgICAiIiIKICAgIEZldGNoZXMgdGhlIGF1dGhlbnRpY2F0ZWQgVHJha3QgdXNlcidzIHByb2ZpbGUuCiAgICAiIiIKCiAgICBkZWYgX19pbml0X18oc2VsZiwgY2xpZW50OiBUcmFrdENsaWVudCk6CiAgICAgICAgc2VsZi5jbGllbnQgPSBjbGllbnQKCiAgICBhc3luYyBkZWYgZ2V0X3VzZXJfaW5mbyhzZWxmKSAtPiBkaWN0W3N0ciwgQW55XToKICAgICAgICAiIiJSZXR1cm4gdGhlIGF1dGhlbnRpY2F0ZWQgdXNlcidzIHByb2ZpbGUgKHVzZXJuYW1lLCBuYW1lLCBldGMuKS4iIiIKICAgICAgICB0cnk6CiAgICAgICAgICAgIGRhdGEgPSBhd2FpdCBzZWxmLmNsaWVudC5nZXQoIi91c2Vycy9tZT9leHRlbmRlZD1mdWxsIikKICAgICAgICAgICAgcmV0dXJuIGRhdGEKICAgICAgICBleGNlcHQgRXhjZXB0aW9uIGFzIGU6CiAgICAgICAgICAgIGxvZ2dlci5leGNlcHRpb24oZiJGYWlsZWQgdG8gZmV0Y2ggVHJha3QgdXNlciBpbmZvOiB7ZX0iKQogICAgICAgICAgICByYWlzZQo=" | base64 --decode > "$REPO/app/services/trakt/user.py" +echo " wrote app/services/trakt/user.py" + +mkdir -p "$REPO/app/services/trakt" +echo "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" | base64 --decode > "$REPO/app/services/trakt/library.py" +echo " wrote app/services/trakt/library.py" + +mkdir -p "$REPO/app/services/trakt" +echo "ZnJvbSBhcHAuc2VydmljZXMudHJha3QuYXV0aCBpbXBvcnQgVHJha3RBdXRoU2VydmljZQpmcm9tIGFwcC5zZXJ2aWNlcy50cmFrdC5jbGllbnQgaW1wb3J0IFRyYWt0Q2xpZW50CmZyb20gYXBwLnNlcnZpY2VzLnRyYWt0LmxpYnJhcnkgaW1wb3J0IFRyYWt0TGlicmFyeVNlcnZpY2UKZnJvbSBhcHAuc2VydmljZXMudHJha3QudXNlciBpbXBvcnQgVHJha3RVc2VyU2VydmljZQoKCmNsYXNzIFRyYWt0QnVuZGxlOgogICAgIiIiCiAgICBVbmlmaWVkIGJ1bmRsZSBmb3IgYWxsIFRyYWt0LXJlbGF0ZWQgc2VydmljZXMuCiAgICAiIiIKCiAgICBkZWYgX19pbml0X18oc2VsZiwgY2xpZW50X2lkOiBzdHIsIGNsaWVudF9zZWNyZXQ6IHN0ciwgcmVkaXJlY3RfdXJpOiBzdHIsIGFjY2Vzc190b2tlbjogc3RyIHwgTm9uZSA9IE5vbmUpOgogICAgICAgIHNlbGYuYXV0aCA9IFRyYWt0QXV0aFNlcnZpY2UoCiAgICAgICAgICAgIGNsaWVudF9pZD1jbGllbnRfaWQsCiAgICAgICAgICAgIGNsaWVudF9zZWNyZXQ9Y2xpZW50X3NlY3JldCwKICAgICAgICAgICAgcmVkaXJlY3RfdXJpPXJlZGlyZWN0X3VyaSwKICAgICAgICApCiAgICAgICAgc2VsZi5fY2xpZW50ID0gVHJha3RDbGllbnQoY2xpZW50X2lkPWNsaWVudF9pZCwgYWNjZXNzX3Rva2VuPWFjY2Vzc190b2tlbikKICAgICAgICBzZWxmLnVzZXIgPSBUcmFrdFVzZXJTZXJ2aWNlKHNlbGYuX2NsaWVudCkKICAgICAgICBzZWxmLmxpYnJhcnkgPSBUcmFrdExpYnJhcnlTZXJ2aWNlKHNlbGYuX2NsaWVudCkKCiAgICBhc3luYyBkZWYgY2xvc2Uoc2VsZik6CiAgICAgICAgYXdhaXQgc2VsZi5fY2xpZW50LmNsb3NlKCkK" | base64 --decode > "$REPO/app/services/trakt/service.py" +echo " wrote app/services/trakt/service.py" + +mkdir -p "$REPO/app/api/endpoints" +echo """"
Trakt OAuth and token-creation endpoints.

Flow:
1. GET  /tokens/trakt/config        → returns client_id + whether Trakt is configured
2. GET  /tokens/trakt/authorize     → returns the Trakt OAuth2 URL for the popup
3. GET  /tokens/trakt/callback      → Trakt redirects here after user approves;
                                       exchanges code for tokens, then posts a
                                       message to the opener window and closes.
4. POST /tokens/trakt               → Creates/updates a Watchly account using a
                                       Trakt access_token (same body shape as
                                       the main /tokens/ endpoint plus trakt_access_token).
5. POST /tokens/trakt/identity      → Lightweight identity-check (returns user info
                                       + existing settings if account exists).
"""

import secrets
from datetime import datetime, timezone
from typing import Any

from fastapi import APIRouter, HTTPException, Request
from fastapi.responses import HTMLResponse
from loguru import logger
from pydantic import BaseModel, Field

from app.core.config import settings
from app.core.security import redact_token
from app.core.settings import CatalogConfig, PosterRatingConfig, UserSettings, get_default_settings
from app.services.manifest import manifest_service
from app.services.token_store import token_store
from app.services.trakt.service import TraktBundle

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

# In-memory store for short-lived OAuth state values.
# This is per-process only; for multi-worker deployments Redis would be better,
# but CSRF protection is still improved versus nothing.
_oauth_states: dict[str, str] = {}


def _get_bundle(access_token: str | None = None) -> TraktBundle:
    client_id = settings.TRAKT_CLIENT_ID
    client_secret = settings.TRAKT_CLIENT_SECRET
    if not client_id or not client_secret:
        raise HTTPException(
            status_code=503,
            detail="Trakt integration is not configured on this server. Set TRAKT_CLIENT_ID and TRAKT_CLIENT_SECRET.",
        )
    redirect_uri = f"{settings.HOST_NAME}/tokens/trakt/callback"
    return TraktBundle(
        client_id=client_id,
        client_secret=client_secret,
        redirect_uri=redirect_uri,
        access_token=access_token,
    )


# ---------------------------------------------------------------------------
# Request / Response models
# ---------------------------------------------------------------------------


class TraktTokenRequest(BaseModel):
    trakt_access_token: str = Field(..., description="Trakt OAuth2 access token")
    trakt_refresh_token: str | None = Field(default=None, description="Trakt OAuth2 refresh token")
    trakt_expires_at: int | None = Field(default=None, description="Unix timestamp when access token expires")
    catalogs: list[CatalogConfig] | None = Field(default=None)
    language: str = Field(default="en-US")
    poster_rating: PosterRatingConfig | None = Field(default=None)
    excluded_movie_genres: list[str] = Field(default_factory=list)
    excluded_series_genres: list[str] = Field(default_factory=list)
    popularity: str = Field(default="balanced")
    year_min: int = Field(default=2010)
    year_max: int = Field(default=2025)
    sorting_order: str = Field(default="default")
    simkl_api_key: str | None = Field(default=None)
    gemini_api_key: str | None = Field(default=None)
    tmdb_api_key: str | None = Field(default=None)


class TraktTokenResponse(BaseModel):
    token: str
    manifestUrl: str
    expiresInSeconds: int | None = None


# ---------------------------------------------------------------------------
# Endpoints
# ---------------------------------------------------------------------------


@router.get("/config")
async def trakt_config():
    """Return whether Trakt is configured and the client_id (needed for the popup)."""
    configured = bool(settings.TRAKT_CLIENT_ID and settings.TRAKT_CLIENT_SECRET)
    return {
        "configured": configured,
        "client_id": settings.TRAKT_CLIENT_ID if configured else None,
    }


@router.get("/authorize")
async def trakt_authorize():
    """Return the Trakt OAuth2 authorization URL for the frontend popup."""
    bundle = _get_bundle()
    state = secrets.token_urlsafe(16)
    _oauth_states[state] = state  # minimal anti-CSRF
    url, _ = bundle.auth.get_authorize_url(state=state)
    await bundle.close()
    return {"url": url, "state": state}


@router.get("/callback", response_class=HTMLResponse)
async def trakt_callback(request: Request, code: str | None = None, state: str | None = None, error: str | None = None):
    """
    Trakt redirects here after the user approves (or denies) the app.
    We exchange the code for tokens and post a message back to the opener
    window, then close the popup.
    """
    # --- error from Trakt ---
    if error or not code:
        return HTMLResponse(_popup_close_html(success=False, error=error or "Authorization cancelled"))

    # --- exchange code for tokens ---
    try:
        bundle = _get_bundle()
        token_data = await bundle.auth.exchange_code(code)
        await bundle.close()
    except Exception as exc:
        logger.error(f"Trakt callback: token exchange failed: {exc}")
        return HTMLResponse(_popup_close_html(success=False, error="Token exchange failed"))

    access_token = token_data.get("access_token")
    refresh_token = token_data.get("refresh_token")
    expires_in = token_data.get("expires_in", 7776000)  # default 90 days

    if not access_token:
        return HTMLResponse(_popup_close_html(success=False, error="No access token received"))

    # Calculate expiry unix timestamp
    import time
    expires_at = int(time.time()) + expires_in

    return HTMLResponse(
        _popup_close_html(
            success=True,
            access_token=access_token,
            refresh_token=refresh_token,
            expires_at=expires_at,
        )
    )


@router.post("/identity", status_code=200)
async def trakt_identity(payload: TraktTokenRequest):
    """
    Validate the Trakt access token, return user info and existing settings.
    """
    bundle = _get_bundle(access_token=payload.trakt_access_token)
    try:
        user_info = await bundle.user.get_user_info()
    except Exception as exc:
        raise HTTPException(status_code=400, detail=f"Invalid Trakt access token: {exc}") from exc
    finally:
        await bundle.close()

    username = user_info.get("username") or user_info.get("name") or "trakt_user"
    # Use a Trakt-namespaced user_id so it can't clash with Stremio IDs
    user_id = f"trakt:{username}"

    token = token_store.get_token_from_user_id(user_id)
    user_data = await token_store.get_user_data(token)
    exists = bool(user_data)

    response: dict[str, Any] = {
        "user_id": user_id,
        "username": username,
        "display": user_info.get("name") or username,
        "exists": exists,
    }
    if exists and user_data:
        raw_settings = user_data.get("settings", {})
        try:
            user_settings = UserSettings(**raw_settings)
            response["settings"] = user_settings.model_dump()
        except Exception as e:
            logger.warning(f"Failed to normalise settings for {user_id}: {e}")
            response["settings"] = raw_settings

    return response


@router.post("/", response_model=TraktTokenResponse)
async def create_trakt_token(payload: TraktTokenRequest, request: Request):
    """
    Create or update a Watchly account backed by a Trakt access token.
    The library is fetched from Trakt; everything else behaves like the
    Stremio-based token endpoint.
    """
    bundle = _get_bundle(access_token=payload.trakt_access_token)

    try:
        user_info = await bundle.user.get_user_info()
    except Exception as exc:
        await bundle.close()
        raise HTTPException(status_code=400, detail=f"Invalid Trakt access token: {exc}") from exc

    username = user_info.get("username") or user_info.get("name") or "trakt_user"
    user_id = f"trakt:{username}"

    token = token_store.get_token_from_user_id(user_id)
    existing_data = await token_store.get_user_data(token)

    default_settings = get_default_settings()
    user_settings = UserSettings(
        language=payload.language or default_settings.language,
        catalogs=payload.catalogs if payload.catalogs else default_settings.catalogs,
        poster_rating=payload.poster_rating,
        excluded_movie_genres=payload.excluded_movie_genres,
        excluded_series_genres=payload.excluded_series_genres,
        year_min=payload.year_min,
        year_max=payload.year_max,
        popularity=payload.popularity,
        sorting_order=payload.sorting_order,
        simkl_api_key=payload.simkl_api_key,
        gemini_api_key=payload.gemini_api_key,
        tmdb_api_key=payload.tmdb_api_key,
    )

    payload_to_store: dict[str, Any] = {
        "auth_provider": "trakt",
        "trakt_access_token": payload.trakt_access_token,
        "trakt_refresh_token": payload.trakt_refresh_token,
        "trakt_expires_at": payload.trakt_expires_at,
        "trakt_username": username,
        "email": user_info.get("name") or username,
        "settings": user_settings.model_dump(),
    }
    if existing_data:
        payload_to_store["last_updated"] = existing_data.get("last_updated")
    else:
        payload_to_store["last_updated"] = datetime.now(timezone.utc).isoformat()

    # Encrypt Trakt tokens via token_store's encryption
    # We store them in a field token_store understands; use a small workaround:
    # store as authKey temporarily so token_store encrypts it, then rename.
    # Actually, token_store encrypts `authKey` natively — store access token there.
    payload_to_store["authKey"] = payload.trakt_access_token

    token = await token_store.store_user_data(user_id, payload_to_store)
    account_status = "updated" if existing_data else "created"
    logger.info(f"[{redact_token(token)}] Trakt account {account_status} for user {user_id}")

    # Pre-cache library using Trakt data
    try:
        library_items = await bundle.library.get_library_items()
        # Use the shared manifest caching pathway, passing library_items directly
        await manifest_service.cache_library_and_profiles_from_items(library_items, user_settings, token)
        logger.info(f"[{redact_token(token)}] Trakt library cached ({len(library_items.get('watched', []))} items)")
    except Exception as exc:
        logger.warning(f"[{redact_token(token)}] Failed to pre-cache Trakt library: {exc}. Will cache on demand.")
    finally:
        await bundle.close()

    base_url = settings.HOST_NAME
    manifest_url = f"{base_url}/{token}/manifest.json"
    expires_in = settings.TOKEN_TTL_SECONDS if settings.TOKEN_TTL_SECONDS > 0 else None

    return TraktTokenResponse(token=token, manifestUrl=manifest_url, expiresInSeconds=expires_in)


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _popup_close_html(
    success: bool,
    error: str | None = None,
    access_token: str | None = None,
    refresh_token: str | None = None,
    expires_at: int | None = None,
) -> str:
    """
    Minimal HTML page that posts a message to the opener and closes itself.
    The frontend listens for this message via window.addEventListener('message', ...).
    """
    if success:
        payload_js = (
            f"{{ type: 'trakt_auth_success', "
            f"access_token: {_js_str(access_token)}, "
            f"refresh_token: {_js_str(refresh_token)}, "
            f"expires_at: {expires_at or 'null'} }}"
        )
    else:
        payload_js = f"{{ type: 'trakt_auth_error', error: {_js_str(error or 'Unknown error')} }}"

    return f"""<!DOCTYPE html>
<html>
<head><title>Trakt Authorization</title></head>
<body>
<p style="font-family:sans-serif;text-align:center;margin-top:3rem">
  {'Authorization successful! You can close this window.' if success else f'Authorization failed: {error}'}
</p>
<script>
  try {{
    if (window.opener) {{
      window.opener.postMessage({payload_js}, window.location.origin);
    }}
  }} catch(e) {{}}
  setTimeout(function() {{ window.close(); }}, 1000);
</script>
</body>
</html>"""


def _js_str(value: str | None) -> str:
    if value is None:
        return "null"
    escaped = value.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
    return f'"{escaped}"'
" | base64 --decode > "$REPO/app/api/endpoints/trakt.py" +echo " wrote app/api/endpoints/trakt.py" + +mkdir -p "$REPO/app/static/js/modules" +echo "// Trakt Authentication Module

import { showToast } from './ui.js';
import { switchSection, unlockNavigation } from './navigation.js';

// LocalStorage keys for Trakt
const TRAKT_STORAGE_KEY = 'watchly_trakt_auth';
const EXPIRY_DAYS = 85; // Trakt tokens last 90 days; refresh a bit early

let languageSelect = null;
let getCatalogs = null;
let renderCatalogList = null;
let resetApp = null;

// --------------------------------------------------------------------------
// Public API
// --------------------------------------------------------------------------

export function initializeTrakt(domElements, catalogState) {
    languageSelect = domElements.languageSelect;
    getCatalogs = catalogState.getCatalogs;
    renderCatalogList = catalogState.renderCatalogList;
    resetApp = catalogState.resetApp;

    initializeTraktConnectButton();
    initializeTraktLogoutButton();
    attemptTraktAutoLogin();
}

export function setTraktLoggedOutState() {
    clearTraktFromStorage();
    hideTraktStatus();

    const traktConnectBtn = document.getElementById('traktConnectBtn');
    if (traktConnectBtn) {
        traktConnectBtn.classList.remove('hidden');
    }
}

// --------------------------------------------------------------------------
// Storage helpers
// --------------------------------------------------------------------------

function saveTraktToStorage(authData) {
    try {
        const expiryDate = new Date();
        expiryDate.setDate(expiryDate.getDate() + EXPIRY_DAYS);
        localStorage.setItem(TRAKT_STORAGE_KEY, JSON.stringify({ ...authData, expiresAt: expiryDate.getTime() }));
    } catch (e) {
        console.warn('Failed to save Trakt auth:', e);
    }
}

function getTraktFromStorage() {
    try {
        const stored = localStorage.getItem(TRAKT_STORAGE_KEY);
        if (!stored) return null;
        const data = JSON.parse(stored);
        if (data.expiresAt && data.expiresAt < Date.now()) {
            clearTraktFromStorage();
            return null;
        }
        return data;
    } catch (e) {
        clearTraktFromStorage();
        return null;
    }
}

function clearTraktFromStorage() {
    try { localStorage.removeItem(TRAKT_STORAGE_KEY); } catch (e) { /* noop */ }
}

// --------------------------------------------------------------------------
// OAuth popup flow
// --------------------------------------------------------------------------

function initializeTraktConnectButton() {
    const btn = document.getElementById('traktConnectBtn');
    if (!btn) return;

    btn.addEventListener('click', async () => {
        setTraktConnecting(true);
        try {
            // 1. Fetch the authorization URL from backend
            const res = await fetch('/tokens/trakt/authorize');
            if (!res.ok) {
                const err = await res.json().catch(() => ({}));
                throw new Error(err.detail || 'Failed to start Trakt authorization');
            }
            const { url } = await res.json();

            // 2. Open OAuth popup
            const tokens = await openTraktPopup(url);

            // 3. Call identity check to get user info + existing settings
            await fetchTraktIdentity(tokens);

            // 4. Save to storage
            saveTraktToStorage(tokens);

            unlockNavigation();
            switchSection('config');
        } catch (err) {
            showToast(err.message || 'Trakt login failed', 'error');
        } finally {
            setTraktConnecting(false);
        }
    });
}

function initializeTraktLogoutButton() {
    const btn = document.getElementById('traktLogoutBtn');
    if (!btn) return;
    btn.addEventListener('click', () => {
        if (resetApp) resetApp();
    });
}

/**
 * Open a popup window for Trakt OAuth and resolve when the callback page
 * posts a message back to us.
 */
function openTraktPopup(url) {
    return new Promise((resolve, reject) => {
        const width = 600;
        const height = 700;
        const left = Math.round(window.screenX + (window.outerWidth - width) / 2);
        const top = Math.round(window.screenY + (window.outerHeight - height) / 2);

        const popup = window.open(
            url,
            'trakt_oauth',
            `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`
        );

        if (!popup) {
            reject(new Error('Could not open the authorization popup. Please allow popups for this site.'));
            return;
        }

        let settled = false;

        function onMessage(event) {
            // Only accept messages from our own origin
            if (event.origin !== window.location.origin) return;
            const data = event.data;
            if (!data || typeof data !== 'object') return;

            if (data.type === 'trakt_auth_success') {
                if (!settled) {
                    settled = true;
                    cleanup();
                    resolve({
                        access_token: data.access_token,
                        refresh_token: data.refresh_token,
                        expires_at: data.expires_at,
                    });
                }
            } else if (data.type === 'trakt_auth_error') {
                if (!settled) {
                    settled = true;
                    cleanup();
                    reject(new Error(data.error || 'Trakt authorization failed'));
                }
            }
        }

        // Also detect if the user closes the popup manually
        const pollTimer = setInterval(() => {
            if (popup.closed && !settled) {
                settled = true;
                cleanup();
                reject(new Error('Authorization window was closed'));
            }
        }, 500);

        function cleanup() {
            window.removeEventListener('message', onMessage);
            clearInterval(pollTimer);
        }

        window.addEventListener('message', onMessage);
    });
}

// --------------------------------------------------------------------------
// Identity fetch + settings population
// --------------------------------------------------------------------------

async function fetchTraktIdentity(tokens) {
    const payload = {
        trakt_access_token: tokens.access_token,
        trakt_refresh_token: tokens.refresh_token || null,
        trakt_expires_at: tokens.expires_at || null,
    };

    const res = await fetch('/tokens/trakt/identity', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload),
    });

    if (!res.ok) {
        const err = await res.json().catch(() => ({}));
        throw new Error(err.detail || 'Failed to verify Trakt identity');
    }

    const data = await res.json();
    const display = data.display || data.username || 'Trakt User';

    showTraktStatus(display);

    if (data.exists && data.settings) {
        showToast(`Welcome back, ${display}! Loading your settings…`, 'info', 5000);
        populateSettings(data.settings);

        const installHeader = document.querySelector('#sect-install h2');
        const installDesc = document.querySelector('#sect-install p');
        if (installHeader) installHeader.textContent = 'Update Settings';
        if (installDesc) installDesc.textContent = 'Update your preferences and re-install.';

        const btnText = document.querySelector('#submitBtn .btn-text');
        if (btnText) btnText.textContent = 'Update & Re-Install';
    } else {
        showToast(`Welcome, ${display}! Setting up your account…`, 'success', 5000);
    }

    // Store display name so the form submit can use it
    const traktDisplayInput = document.getElementById('traktDisplayName');
    if (traktDisplayInput) traktDisplayInput.value = display;
}

function populateSettings(s) {
    if (s.language && languageSelect) languageSelect.value = s.language;

    const popularitySelect = document.getElementById('popularitySelect');
    const yearMinInput = document.getElementById('yearMin');
    const yearMaxInput = document.getElementById('yearMax');
    const sortingOrderSelect = document.getElementById('sortingOrderSelect');

    if (s.popularity && popularitySelect) popularitySelect.value = s.popularity;
    if (s.year_min && yearMinInput) yearMinInput.value = s.year_min;
    if (s.year_max && yearMaxInput) yearMaxInput.value = s.year_max;
    if (window.updateYearSlider) window.updateYearSlider();
    if (s.sorting_order && sortingOrderSelect) sortingOrderSelect.value = s.sorting_order;

    const posterRatingProvider = document.getElementById('posterRatingProvider');
    const posterRatingApiKey = document.getElementById('posterRatingApiKey');
    if (posterRatingProvider && posterRatingApiKey && s.poster_rating?.provider && s.poster_rating?.api_key) {
        posterRatingProvider.value = s.poster_rating.provider;
        posterRatingApiKey.value = s.poster_rating.api_key;
        posterRatingProvider.dispatchEvent(new Event('change'));
    }

    const tmdbApiKeyInput = document.getElementById('tmdbApiKey');
    if (s.tmdb_api_key && tmdbApiKeyInput) tmdbApiKeyInput.value = s.tmdb_api_key;

    const simklApiKeyInput = document.getElementById('simklApiKey');
    if (s.simkl_api_key && simklApiKeyInput) simklApiKeyInput.value = s.simkl_api_key;

    const geminiApiKeyInput = document.getElementById('geminiApiKey');
    if (s.gemini_api_key && geminiApiKeyInput) geminiApiKeyInput.value = s.gemini_api_key;

    // Genres
    document.querySelectorAll('input[name="movie-genre"]').forEach(cb => cb.checked = false);
    document.querySelectorAll('input[name="series-genre"]').forEach(cb => cb.checked = false);
    if (s.excluded_movie_genres) s.excluded_movie_genres.forEach(id => {
        const cb = document.querySelector(`input[name="movie-genre"][value="${id}"]`);
        if (cb) cb.checked = true;
    });
    if (s.excluded_series_genres) s.excluded_series_genres.forEach(id => {
        const cb = document.querySelector(`input[name="series-genre"][value="${id}"]`);
        if (cb) cb.checked = true;
    });

    // Catalogs
    if (s.catalogs && Array.isArray(s.catalogs)) {
        const catalogs = getCatalogs ? getCatalogs() : [];
        s.catalogs.forEach(remote => {
            const local = catalogs.find(c => c.id === remote.id);
            if (local) {
                local.enabled = remote.enabled;
                if (remote.name) local.name = remote.name;
                if (typeof remote.enabled_movie === 'boolean') local.enabledMovie = remote.enabled_movie;
                if (typeof remote.enabled_series === 'boolean') local.enabledSeries = remote.enabled_series;
                if (typeof remote.display_at_home === 'boolean') local.display_at_home = remote.display_at_home;
                if (typeof remote.shuffle === 'boolean') local.shuffle = remote.shuffle;
            }
        });
        if (renderCatalogList) renderCatalogList();
    }
}

// --------------------------------------------------------------------------
// Auto-login
// --------------------------------------------------------------------------

async function attemptTraktAutoLogin() {
    const stored = getTraktFromStorage();
    if (!stored?.access_token) return;

    try {
        await fetchTraktIdentity(stored);
        unlockNavigation();
        switchSection('config');
    } catch (err) {
        console.warn('Trakt auto-login failed:', err);
        clearTraktFromStorage();
    }
}

// --------------------------------------------------------------------------
// UI helpers
// --------------------------------------------------------------------------

function setTraktConnecting(loading) {
    const btn = document.getElementById('traktConnectBtn');
    if (!btn) return;
    const text = btn.querySelector('.btn-text');
    const loader = btn.querySelector('.loader');
    btn.disabled = loading;
    if (text) text.classList.toggle('hidden', loading);
    if (loader) loader.classList.toggle('hidden', !loading);
}

export function showTraktStatus(displayName) {
    const statusSection = document.getElementById('traktStatusSection');
    const displayEl = document.getElementById('traktStatusDisplay');
    const avatarEl = document.getElementById('traktStatusAvatar');
    const connectBtn = document.getElementById('traktConnectBtn');

    if (displayEl) displayEl.textContent = displayName;
    if (avatarEl) avatarEl.textContent = getInitials(displayName);
    if (statusSection) statusSection.classList.remove('hidden');
    if (connectBtn) connectBtn.classList.add('hidden');

    // Sidebar profile
    const userProfileWrapper = document.getElementById('user-profile-dropdown-wrapper');
    const userEmail = document.getElementById('user-email');
    const userAvatar = document.getElementById('user-avatar');
    const loginFormCard = document.getElementById('loginFormCard');

    if (userEmail) userEmail.textContent = displayName;
    if (userAvatar) userAvatar.textContent = getInitials(displayName);
    if (userProfileWrapper) userProfileWrapper.classList.remove('hidden');
    if (loginFormCard) loginFormCard.classList.add('hidden');
}

function hideTraktStatus() {
    const statusSection = document.getElementById('traktStatusSection');
    const connectBtn = document.getElementById('traktConnectBtn');
    if (statusSection) statusSection.classList.add('hidden');
    if (connectBtn) connectBtn.classList.remove('hidden');

    const userProfileWrapper = document.getElementById('user-profile-dropdown-wrapper');
    const loginFormCard = document.getElementById('loginFormCard');
    if (userProfileWrapper) userProfileWrapper.classList.add('hidden');
    if (loginFormCard) loginFormCard.classList.remove('hidden');
}

function getInitials(name) {
    if (!name) return '?';
    const parts = name.trim().split(/[\s._-]+/);
    if (parts.length >= 2) return (parts[0][0] + parts[1][0]).toUpperCase();
    return name.substring(0, 2).toUpperCase();
}

// --------------------------------------------------------------------------
// Exported helpers for form.js
// --------------------------------------------------------------------------

export function getTraktTokensFromStorage() {
    return getTraktFromStorage();
}
" | base64 --decode > "$REPO/app/static/js/modules/trakt.js" +echo " wrote app/static/js/modules/trakt.js" + +mkdir -p "$REPO/app/templates/components" +echo "<!-- SECTION 1: LOGIN -->
<section id="sect-login" class="space-y-6 hidden animate-fade-in">
    <div class="mb-8">
        <h2 class="text-3xl font-bold text-white mb-2">Connect Your Library</h2>
        <p class="text-slate-400">Log in with Stremio or Trakt so Watchly can read your watch history.</p>
    </div>

    <!-- Logged In Status (shown after login - shared across both providers) -->
    <div id="loginStatusSection" class="hidden bg-neutral-900/60 border border-white/10 rounded-2xl p-6 md:p-8 backdrop-blur-sm shadow-xl shadow-black/20">
        <div class="flex items-center justify-between gap-4">
            <div class="flex items-center gap-3 flex-grow min-w-0">
                <div class="w-10 h-10 rounded-full bg-white text-black ring-1 ring-white/10 flex items-center justify-center font-bold text-sm flex-shrink-0"
                    id="loginStatusAvatar">
                </div>
                <div class="flex-grow min-w-0">
                    <div class="text-xs text-slate-500 mb-0.5">Logged in as</div>
                    <div class="text-sm text-white font-medium truncate" id="loginStatusEmail"></div>
                </div>
            </div>
            <button type="button" id="loginStatusLogoutBtn"
                class="flex-shrink-0 bg-red-600 hover:bg-red-700 text-white font-medium py-2.5 px-4 rounded-xl transition border border-red-700 shadow-lg shadow-red-900/20 flex items-center justify-center gap-2">
                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                        d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1">
                    </path>
                </svg>
                <span>Logout</span>
            </button>
        </div>
    </div>

    <div id="loginFormCard" class="bg-neutral-900/60 border border-white/10 rounded-2xl p-6 md:p-8 backdrop-blur-sm shadow-xl shadow-black/20">

        <!-- Provider Tabs -->
        <div class="flex gap-1 mb-6 bg-neutral-800/60 p-1 rounded-xl">
            <button type="button" id="tabStremio"
                class="login-tab flex-1 py-2.5 px-4 rounded-lg text-sm font-medium transition-all bg-white text-black shadow"
                data-tab="stremio">
                <span class="flex items-center justify-center gap-2">
                    <img src="https://stremio.com/website/stremio-logo-small.png" class="w-4 h-4" alt="">
                    Stremio
                </span>
            </button>
            <button type="button" id="tabTrakt"
                class="login-tab flex-1 py-2.5 px-4 rounded-lg text-sm font-medium transition-all text-slate-400 hover:text-white"
                data-tab="trakt">
                <span class="flex items-center justify-center gap-2">
                    <!-- Trakt icon (simple "t" badge) -->
                    <svg class="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
                        <path d="M12 2C6.477 2 2 6.477 2 12s4.477 10 10 10 10-4.477 10-10S17.523 2 12 2zm-.5 5h1.5v6h3v1.5h-4.5V7z"/>
                    </svg>
                    Trakt
                </span>
            </button>
        </div>

        <!-- ===== STREMIO PANEL ===== -->
        <div id="panelStremio">
            <button type="button" id="stremioLoginBtn"
                class="w-full bg-stremio text-white font-medium py-4 rounded-xl transition flex items-center justify-center gap-3 border border-stremio-border shadow-lg shadow-stremio/20 group hover:bg-white hover:text-black hover:border-white/10">
                <img src="https://stremio.com/website/stremio-logo-small.png"
                    class="w-6 h-6 group-hover:scale-110 transition-transform" alt="Stremio">
                <span id="stremioLoginText" class="text-lg">Login with Stremio</span>
            </button>

            <input type="hidden" id="authKey">

            <!-- Divider -->
            <div id="emailPwdDivider" class="flex items-center gap-3 my-6">
                <div class="h-px bg-white/10 w-full"></div>
                <div class="text-xs text-slate-500">or</div>
                <div class="h-px bg-white/10 w-full"></div>
            </div>

            <!-- Email/Password Login -->
            <div id="emailPwdSection" class="grid gap-3">
                <label class="text-xs text-slate-400">Email</label>
                <input id="emailInput" type="email" autocomplete="email" inputmode="email"
                    spellcheck="false" required placeholder="you@example.com"
                    class="w-full bg-neutral-900 border border-slate-700 rounded-xl px-4 py-3.5 text-white placeholder-slate-500 focus:ring-2 focus:ring-white/20 focus:border-white/30 outline-none transition-all">
                <label class="text-xs text-slate-400">Password</label>
                <div class="relative">
                    <input id="passwordInput" type="password" autocomplete="current-password"
                        placeholder="Your Stremio password"
                        class="w-full bg-neutral-900 border border-slate-700 rounded-xl pl-4 pr-12 py-3.5 text-white placeholder-slate-500 focus:ring-2 focus:ring-white/20 focus:border-white/30 outline-none transition-all">
                    <button type="button"
                        class="toggle-btn absolute right-2 top-1/2 -translate-y-1/2 bg-white/10 hover:bg-white/20 text-white p-2 rounded-lg"
                        aria-label="Show password" title="Show" data-target="passwordInput">
                        <svg class="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor"
                            stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
                            <path d="M1 12s4-7 11-7 11 7 11 7-4 7-11 7-11-7-11-7z" />
                            <circle cx="12" cy="12" r="3" />
                        </svg>
                    </button>
                </div>
                <button type="button" id="emailPwdContinueBtn"
                    class="mt-2 w-full bg-white text-black hover:bg-white/90 font-medium py-3 rounded-xl transition border border-white/10 flex items-center justify-center gap-2">
                    <span class="btn-text">Continue with Email</span>
                    <div class="loader hidden w-5 h-5 border-2 border-black/30 border-t-black rounded-full animate-spin">
                    </div>
                </button>
            </div>

            <!-- Inline error for email/password login -->
            <div id="emailPwdError" class="hidden mt-3 p-3 bg-red-500/10 border border-red-500/20 rounded-xl text-red-200 text-sm">
            </div>

            <!-- Disclaimer -->
            <div id="emailPwdDisclaimer"
                class="mt-4 text-xs leading-relaxed bg-yellow-500/10 border border-yellow-500/30 text-yellow-200 rounded-xl p-3">
                <strong class="text-yellow-300">Why email &amp; password?</strong>
                <span class="block mt-1">We store your credentials securely to generate a fresh Stremio auth
                    key automatically when needed. This avoids expired keys and keeps your addon working
                    without manual re-login.</span>
                <span class="block mt-2">Prefer not to share your password? Use the Stremio login above to
                    supply an auth key. Note: auth keys can expire and may require periodic
                    re-authentication.</span>
            </div>
        </div>
        <!-- end #panelStremio -->

        <!-- ===== TRAKT PANEL ===== -->
        <div id="panelTrakt" class="hidden">

            <!-- Logged-in state -->
            <div id="traktStatusSection" class="hidden mb-4">
                <div class="flex items-center justify-between gap-4 p-4 bg-neutral-800/60 rounded-xl border border-white/10">
                    <div class="flex items-center gap-3 flex-grow min-w-0">
                        <div class="w-10 h-10 rounded-full bg-[#ed1c24] text-white ring-1 ring-white/10 flex items-center justify-center font-bold text-sm flex-shrink-0"
                            id="traktStatusAvatar">T</div>
                        <div class="flex-grow min-w-0">
                            <div class="text-xs text-slate-500 mb-0.5">Connected as</div>
                            <div class="text-sm text-white font-medium truncate" id="traktStatusDisplay"></div>
                        </div>
                    </div>
                    <button type="button" id="traktLogoutBtn"
                        class="flex-shrink-0 bg-red-600 hover:bg-red-700 text-white font-medium py-2 px-3 rounded-xl transition border border-red-700 text-sm">
                        Disconnect
                    </button>
                </div>
            </div>

            <!-- Connect button -->
            <button type="button" id="traktConnectBtn"
                class="w-full bg-[#ed1c24] hover:bg-[#c41019] text-white font-medium py-4 rounded-xl transition flex items-center justify-center gap-3 border border-[#b00e15] shadow-lg shadow-red-900/20">
                <!-- Trakt "T" logo as simple SVG -->
                <svg class="w-6 h-6 flex-shrink-0" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
                    <circle cx="16" cy="16" r="16" fill="white"/>
                    <text x="16" y="22" text-anchor="middle" font-size="18" font-weight="bold" fill="#ed1c24" font-family="sans-serif">t</text>
                </svg>
                <span class="btn-text text-lg">Connect with Trakt</span>
                <div class="loader hidden w-5 h-5 border-2 border-white/30 border-t-white rounded-full animate-spin"></div>
            </button>

            <!-- Hidden field to carry Trakt display name through to form submission -->
            <input type="hidden" id="traktDisplayName">

            <div class="mt-4 text-xs leading-relaxed bg-blue-500/10 border border-blue-500/30 text-blue-200 rounded-xl p-3">
                <strong class="text-blue-300">How it works</strong>
                <span class="block mt-1">Clicking "Connect with Trakt" opens a secure Trakt authorization
                    window. After you approve access, Watchly uses your Trakt watch history to generate
                    recommendations — no Stremio account needed.</span>
                <span class="block mt-2">Your Trakt access token is stored encrypted on the server and
                    is never shared or exposed in URLs.</span>
            </div>
        </div>
        <!-- end #panelTrakt -->

    </div>
    <!-- end #loginFormCard -->
</section>

<script>
// Tab switching logic (inline to avoid module-loading order issues)
(function () {
    function switchLoginTab(tab) {
        const tabs = document.querySelectorAll('.login-tab');
        const panelStremio = document.getElementById('panelStremio');
        const panelTrakt = document.getElementById('panelTrakt');

        tabs.forEach(t => {
            const active = t.dataset.tab === tab;
            t.classList.toggle('bg-white', active);
            t.classList.toggle('text-black', active);
            t.classList.toggle('shadow', active);
            t.classList.toggle('text-slate-400', !active);
            t.classList.toggle('hover:text-white', !active);
        });

        if (panelStremio) panelStremio.classList.toggle('hidden', tab !== 'stremio');
        if (panelTrakt) panelTrakt.classList.toggle('hidden', tab !== 'trakt');

        // Persist choice
        try { localStorage.setItem('watchly_login_tab', tab); } catch (e) { }
    }

    document.addEventListener('DOMContentLoaded', function () {
        document.querySelectorAll('.login-tab').forEach(btn => {
            btn.addEventListener('click', () => switchLoginTab(btn.dataset.tab));
        });

        // Restore last tab
        try {
            const saved = localStorage.getItem('watchly_login_tab');
            if (saved === 'trakt') switchLoginTab('trakt');
        } catch (e) { }
    });
})();
</script>

<script>
// Hide the Trakt tab if Trakt is not configured on this server
(function () {
    fetch('/tokens/trakt/config')
        .then(r => r.json())
        .then(data => {
            if (!data.configured) {
                const traktTab = document.getElementById('tabTrakt');
                if (traktTab) traktTab.style.display = 'none';
            }
        })
        .catch(() => {
            // If the endpoint fails (unlikely), leave tabs as-is
        });
})();
</script>

" | base64 --decode > "$REPO/app/templates/components/section_login.html" +echo " wrote app/templates/components/section_login.html" + +mkdir -p "$REPO/app/api" +echo "ZnJvbSBmYXN0YXBpIGltcG9ydCBBUElSb3V0ZXIKCmZyb20gLmVuZHBvaW50cy5hbm5vdW5jZW1lbnQgaW1wb3J0IHJvdXRlciBhcyBhbm5vdW5jZW1lbnRfcm91dGVyCmZyb20gLmVuZHBvaW50cy5jYXRhbG9ncyBpbXBvcnQgcm91dGVyIGFzIGNhdGFsb2dzX3JvdXRlcgpmcm9tIC5lbmRwb2ludHMuaGVhbHRoIGltcG9ydCByb3V0ZXIgYXMgaGVhbHRoX3JvdXRlcgpmcm9tIC5lbmRwb2ludHMubWFuaWZlc3QgaW1wb3J0IHJvdXRlciBhcyBtYW5pZmVzdF9yb3V0ZXIKZnJvbSAuZW5kcG9pbnRzLm1ldGEgaW1wb3J0IHJvdXRlciBhcyBtZXRhX3JvdXRlcgpmcm9tIC5lbmRwb2ludHMuc3RhdHMgaW1wb3J0IHJvdXRlciBhcyBzdGF0c19yb3V0ZXIKZnJvbSAuZW5kcG9pbnRzLnRva2VucyBpbXBvcnQgcm91dGVyIGFzIHRva2Vuc19yb3V0ZXIKZnJvbSAuZW5kcG9pbnRzLnRyYWt0IGltcG9ydCByb3V0ZXIgYXMgdHJha3Rfcm91dGVyCmZyb20gLmVuZHBvaW50cy52YWxpZGF0aW9uIGltcG9ydCByb3V0ZXIgYXMgdmFsaWRhdGlvbl9yb3V0ZXIKCmFwaV9yb3V0ZXIgPSBBUElSb3V0ZXIoKQoKCkBhcGlfcm91dGVyLmdldCgiLyIpCmFzeW5jIGRlZiByb290KCk6CiAgICByZXR1cm4geyJtZXNzYWdlIjogIldhdGNobHkgQVBJIGlzIHJ1bm5pbmcifQoKCmFwaV9yb3V0ZXIuaW5jbHVkZV9yb3V0ZXIobWFuaWZlc3Rfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKGNhdGFsb2dzX3JvdXRlcikKYXBpX3JvdXRlci5pbmNsdWRlX3JvdXRlcih0b2tlbnNfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKHRyYWt0X3JvdXRlcikKYXBpX3JvdXRlci5pbmNsdWRlX3JvdXRlcihoZWFsdGhfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKG1ldGFfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKGFubm91bmNlbWVudF9yb3V0ZXIpCmFwaV9yb3V0ZXIuaW5jbHVkZV9yb3V0ZXIoc3RhdHNfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKHZhbGlkYXRpb25fcm91dGVyKQo=" | base64 --decode > "$REPO/app/api/router.py" +echo " wrote app/api/router.py" + +mkdir -p "$REPO/app/core" +echo "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" | base64 --decode > "$REPO/app/core/config.py" +echo " wrote app/core/config.py" + +mkdir -p "$REPO/app/static/js" +echo "// Main entry point - initializes all modules

import { defaultCatalogs } from './constants.js';
import { showToast, initializeFooter, initializeKofi } from './modules/ui.js';
import { initializeNavigation, switchSection, lockNavigationForLoggedOut, initializeMobileNav, updateMobileLayout, unlockNavigation } from './modules/navigation.js';
import { initializeAuth, setStremioLoggedOutState } from './modules/auth.js';
import { initializeTrakt, setTraktLoggedOutState } from './modules/trakt.js';
import { initializeCatalogList, renderCatalogList, getCatalogs, setCatalogs } from './modules/catalog.js';
import { initializeForm, clearErrors } from './modules/form.js';

// Initialize catalogs state
let catalogsState = JSON.parse(JSON.stringify(defaultCatalogs));

// DOM Elements
const configForm = document.getElementById('configForm');
const catalogList = document.getElementById('catalogList');
const movieGenreList = document.getElementById('movieGenreList');
const seriesGenreList = document.getElementById('seriesGenreList');
const submitBtn = document.getElementById('submitBtn');
const stremioLoginBtn = document.getElementById('stremioLoginBtn');
const stremioLoginText = document.getElementById('stremioLoginText');
const emailInput = document.getElementById('emailInput');
const passwordInput = document.getElementById('passwordInput');
const emailPwdContinueBtn = document.getElementById('emailPwdContinueBtn');
const languageSelect = document.getElementById('languageSelect');
const configNextBtn = document.getElementById('configNextBtn');
const catalogsNextBtn = document.getElementById('catalogsNextBtn');
const successResetBtn = document.getElementById('successResetBtn');
const btnGetStarted = document.getElementById('btn-get-started');

const navItems = {
    welcome: document.getElementById('nav-welcome'),
    login: document.getElementById('nav-login'),
    config: document.getElementById('nav-config'),
    catalogs: document.getElementById('nav-catalogs'),
    install: document.getElementById('nav-install')
};

const sections = {
    welcome: document.getElementById('sect-welcome'),
    login: document.getElementById('sect-login'),
    config: document.getElementById('sect-config'),
    catalogs: document.getElementById('sect-catalogs'),
    install: document.getElementById('sect-install'),
    success: document.getElementById('sect-success')
};

// Main scroll container
const mainEl = document.querySelector('main');

// Reset App Function
function resetApp() {
    if (configForm) configForm.reset();
    clearErrors();

    // Reset Navigation is now Back to Welcome
    switchSection('welcome');

    // Lock Navs
    Object.keys(navItems).forEach(key => {
        if (key !== 'login' && key !== 'welcome') {
            if (navItems[key]) navItems[key].classList.add('disabled');
        }
    });

    // Reset Stremio State
    setStremioLoggedOutState();

    // Reset Trakt State
    setTraktLoggedOutState();

    // Reset catalogs
    catalogsState = JSON.parse(JSON.stringify(defaultCatalogs));
    setCatalogs(catalogsState);
    renderCatalogList();

    // Show Form
    if (configForm) configForm.classList.remove('hidden');
    if (sections.success) sections.success.classList.add('hidden');
}

// Welcome Flow Logic
function initializeWelcomeFlow() {
    if (!btnGetStarted) return;

    // Support mobile taps reliably while avoiding double-fire (touch -> click)
    let touched = false;
    const handleGetStarted = (e) => {
        if (e.type === 'click' && touched) return;
        if (e.type === 'touchstart') touched = true;
        if (navItems.login) navItems.login.classList.remove('disabled');
        switchSection('login');
    };

    btnGetStarted.addEventListener('click', handleGetStarted);
    btnGetStarted.addEventListener('touchstart', handleGetStarted, { passive: true });
}

// Initialize everything
document.addEventListener('DOMContentLoaded', () => {
    // Start at Welcome
    switchSection('welcome');
    initializeWelcomeFlow();

    // Initialize all modules
    initializeNavigation({
        navItems,
        sections,
        mainEl
    });

    // By default, ensure logged-out users see only Welcome/Login
    lockNavigationForLoggedOut();

    // Initialize catalog management - set catalogs first
    setCatalogs(catalogsState);
    initializeCatalogList(
        { catalogList },
        {
            catalogs: catalogsState,
            renderCatalogList
        }
    );

    // Initialize authentication (Stremio)
    initializeAuth(
        {
            stremioLoginBtn,
            stremioLoginText,
            emailInput,
            passwordInput,
            emailPwdContinueBtn,
            languageSelect
        },
        {
            getCatalogs,
            renderCatalogList,
            resetApp
        }
    );

    // Initialize Trakt authentication
    initializeTrakt(
        { languageSelect },
        {
            getCatalogs,
            renderCatalogList,
            resetApp
        }
    );

    // Initialize form handling
    initializeForm(
        {
            configForm,
            submitBtn,
            emailInput,
            passwordInput,
            languageSelect,
            movieGenreList,
            seriesGenreList
        },
        {
            getCatalogs,
            resetApp
        }
    );

    // Initialize mobile navigation
    initializeMobileNav();

    // Initialize UI components
    initializeFooter();
    initializeKofi();

    // Layout adjustments for fixed mobile header
    updateMobileLayout();
    window.addEventListener('resize', updateMobileLayout);
    window.addEventListener('orientationchange', updateMobileLayout);

    // Next Buttons
    if (configNextBtn) configNextBtn.addEventListener('click', () => switchSection('catalogs'));
    if (catalogsNextBtn) catalogsNextBtn.addEventListener('click', () => switchSection('install'));

    // Reset Buttons
    const resetBtn = document.getElementById('resetBtn');
    if (resetBtn) resetBtn.addEventListener('click', resetApp);
    if (successResetBtn) successResetBtn.addEventListener('click', resetApp);
});

// Make resetApp available globally for auth module
window.resetApp = resetApp;
window.switchSection = switchSection;
window.unlockNavigation = unlockNavigation;
" | base64 --decode > "$REPO/app/static/js/main.js" +echo " wrote app/static/js/main.js" + +mkdir -p "$REPO/app/static/js/modules" +echo "// Form Submission and UI Helpers

import { showToast, showConfirm, escapeHtml } from './ui.js';
import { getTraktTokensFromStorage } from './trakt.js';
import { switchSection } from './navigation.js';
import { MOVIE_GENRES, SERIES_GENRES } from '../constants.js';

// DOM Elements - will be initialized
let configForm = null;
let submitBtn = null;
let emailInput = null;
let passwordInput = null;
let languageSelect = null;
let movieGenreList = null;
let seriesGenreList = null;
let getCatalogs = null;
let resetApp = null;

export function initializeForm(domElements, catalogState) {
    configForm = domElements.configForm;
    submitBtn = domElements.submitBtn;
    emailInput = domElements.emailInput;
    passwordInput = domElements.passwordInput;
    languageSelect = domElements.languageSelect;
    movieGenreList = domElements.movieGenreList;
    seriesGenreList = domElements.seriesGenreList;
    getCatalogs = catalogState.getCatalogs;
    resetApp = catalogState.resetApp;

    initializeFormSubmission();
    initializeGenreLists();
    initializeLanguageSelect();
    initializePasswordToggles();
    initializeSuccessActions();
    initializePosterRatingProvider();
    initializeTmdb();
    initializeSimkl();
    initializeGemini();
    initializeYearSlider();
}

// Form Submission
async function initializeFormSubmission() {
    if (!submitBtn) return;

    submitBtn.addEventListener("click", async (e) => {
        e.preventDefault();
        clearErrors();

        const sAuthKey = (document.getElementById("authKey").value || '').trim();
        const email = emailInput?.value.trim();
        const password = passwordInput?.value;
        const language = languageSelect.value;
        const popularity = document.getElementById("popularitySelect")?.value || "balanced";
        const yearMin = parseInt(document.getElementById("yearMin")?.value || "1980");
        const yearMax = parseInt(document.getElementById("yearMax")?.value || "2026");
        const sortingOrder = document.getElementById("sortingOrderSelect")?.value || "default";
        const posterRatingProvider = document.getElementById("posterRatingProvider")?.value || "";
        const posterRatingApiKey = document.getElementById("posterRatingApiKey")?.value.trim() || "";
        const excludedMovieGenres = Array.from(document.querySelectorAll('input[name="movie-genre"]:checked')).map(cb => cb.value);
        const excludedSeriesGenres = Array.from(document.querySelectorAll('input[name="series-genre"]:checked')).map(cb => cb.value);
        const tmdbApiKey = document.getElementById("tmdbApiKey")?.value.trim() || "";
        const simklApiKey = document.getElementById("simklApiKey")?.value.trim() || "";
        const geminiApiKey = document.getElementById("geminiApiKey")?.value.trim() || "";

        const catalogsToSend = [];
        const catalogs = getCatalogs ? getCatalogs() : [];
        // Get enabled state from catalog objects (updated by visibility button)
        catalogs.forEach(originalCatalog => {
            const catalogId = originalCatalog.id;
            const enabled = originalCatalog.enabled !== false;

            // Get enabled_movie and enabled_series from toggle buttons
            const activeBtn = document.querySelector(`.catalog-type-btn[data-catalog-id="${catalogId}"].bg-white`);
            let enabledMovie = true;
            let enabledSeries = true;

            if (activeBtn) {
                const mode = activeBtn.dataset.mode;
                if (mode === 'movie') {
                    enabledMovie = true;
                    enabledSeries = false;
                } else if (mode === 'series') {
                    enabledMovie = false;
                    enabledSeries = true;
                } else {
                    // 'both' or default
                    enabledMovie = true;
                    enabledSeries = true;
                }
            } else {
                // Fallback to catalog state
                enabledMovie = originalCatalog.enabledMovie !== false;
                enabledSeries = originalCatalog.enabledSeries !== false;
            }

            catalogsToSend.push({
                id: catalogId,
                name: originalCatalog.name,
                enabled: enabled,
                enabled_movie: enabledMovie,
                enabled_series: enabledSeries,
                display_at_home: originalCatalog.display_at_home !== false, // Default to true if not set
                shuffle: originalCatalog.shuffle === true, // Default to false if not set
            });
        });

        // Determine active provider
        const traktTokens = getTraktTokensFromStorage();
        const isTraktLogin = !!(traktTokens && traktTokens.access_token && !sAuthKey && !email);

        // Validation
        if (!sAuthKey && !(email && password) && !isTraktLogin) {
            showError("generalError", "Please login with Stremio or Trakt to continue.");
            switchSection('login');
            return;
        }

        if (!tmdbApiKey) {
            showError("generalError", "TMDB API key is required.");
            const tmdbInput = document.getElementById("tmdbApiKey");
            if (tmdbInput) {
                tmdbInput.focus();
                tmdbInput.scrollIntoView({ behavior: "smooth", block: "center" });
            }
            return;
        }

        // Validate poster rating API key if provided
        if (posterRatingProvider && posterRatingApiKey) {
            if (window.validatePosterRatingApiKey) {
                const isValid = await window.validatePosterRatingApiKey();
                if (!isValid) {
                    return;
                }
            }
        }

        setLoading(true);

        try {
            // Build poster_rating payload
            let posterRating = null;
            if (posterRatingProvider && posterRatingApiKey) {
                posterRating = {
                    provider: posterRatingProvider,
                    api_key: posterRatingApiKey
                };
            }

            let endpoint, payload;

            if (isTraktLogin) {
                // ---- Trakt submission ----
                endpoint = "/tokens/trakt/";
                payload = {
                    trakt_access_token: traktTokens.access_token,
                    trakt_refresh_token: traktTokens.refresh_token || undefined,
                    trakt_expires_at: traktTokens.expires_at || undefined,
                    catalogs: catalogsToSend,
                    language: language,
                    year_min: yearMin,
                    year_max: yearMax,
                    popularity: popularity,
                    sorting_order: sortingOrder,
                    poster_rating: posterRating,
                    tmdb_api_key: tmdbApiKey || undefined,
                    simkl_api_key: simklApiKey,
                    gemini_api_key: geminiApiKey,
                    excluded_movie_genres: excludedMovieGenres,
                    excluded_series_genres: excludedSeriesGenres
                };
            } else {
                // ---- Stremio submission ----
                endpoint = "/tokens/";
                payload = {
                    authKey: sAuthKey || undefined,
                    email: email || undefined,
                    password: password || undefined,
                    catalogs: catalogsToSend,
                    language: language,
                    year_min: yearMin,
                    year_max: yearMax,
                    popularity: popularity,
                    sorting_order: sortingOrder,
                    poster_rating: posterRating,
                    tmdb_api_key: tmdbApiKey || undefined,
                    simkl_api_key: simklApiKey,
                    gemini_api_key: geminiApiKey,
                    excluded_movie_genres: excludedMovieGenres,
                    excluded_series_genres: excludedSeriesGenres
                };
            }

            const response = await fetch(endpoint, {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify(payload)
            });

            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.detail || "Failed to generate manifest URL");
            }
            const data = await response.json();
            showSuccess(data.manifestUrl);
        } catch (error) {
            console.error("Error:", error);
            showError("generalError", error.message);
        } finally {
            setLoading(false);
        }
    });
}

// UI Helpers & Genre Lists
function initializeGenreLists() {
    renderGenreList(movieGenreList, MOVIE_GENRES, 'movie-genre');
    renderGenreList(seriesGenreList, SERIES_GENRES, 'series-genre');
}

function renderGenreList(container, genres, namePrefix) {
    if (!container) return;
    container.innerHTML = genres.map(genre => `
        <label class="flex items-center gap-3 p-2 rounded-lg hover:bg-white/5 cursor-pointer transition group">
            <div class="relative flex items-center">
                <input type="checkbox" name="${namePrefix}" value="${genre.id}"
                    class="peer appearance-none w-5 h-5 border-2 border-slate-600 rounded bg-neutral-900 checked:bg-white checked:border-white transition-colors">
                <svg class="absolute w-3.5 h-3.5 text-black left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 opacity-0 peer-checked:opacity-100 pointer-events-none transition-opacity"
                    fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="3" d="M5 13l4 4L19 7"></path>
                </svg>
            </div>
            <span class="text-sm text-slate-300 group-hover:text-white transition-colors select-none">${genre.name}</span>
        </label>
    `).join('');
}

function initializeLanguageSelect() {
    if (!languageSelect) return;
}

// Poster Rating Provider
function initializePosterRatingProvider() {
    const providerSelect = document.getElementById("posterRatingProvider");
    const apiKeyContainer = document.getElementById("posterRatingApiKeyContainer");
    const apiKeyInput = document.getElementById("posterRatingApiKey");
    const helpContainer = document.getElementById("posterRatingHelp");
    const helpText = document.getElementById("posterRatingHelpText");
    const validateBtn = document.getElementById("posterRatingApiKeyValidate");
    const toggleBtn = document.getElementById("posterRatingApiKeyToggle");
    const eyeIcon = document.getElementById("posterRatingApiKeyEye");
    const eyeOffIcon = document.getElementById("posterRatingApiKeyEyeOff");
    const validationMessage = document.getElementById("posterRatingValidationMessage");

    if (!providerSelect || !apiKeyContainer || !apiKeyInput || !helpContainer || !helpText) return;

    const providerInfo = {
        "rpdb": {
            name: "RPDB (RatingPosterDB)",
            url: "https://ratingposterdb.com",
            description: "Enable ratings on posters via RatingPosterDB"
        },
        "top_posters": {
            name: "Top Posters",
            url: "https://api.top-streaming.stream/",
            description: "Enable ratings on posters via Top Posters"
        }
    };

    let isValidated = false;

    // Eye toggle functionality
    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    // Validation function
    async function validateApiKey() {
        const selectedProvider = providerSelect.value;
        const apiKey = apiKeyInput.value.trim();

        if (!selectedProvider || !apiKey) {
            showValidationMessage("Please select a provider and enter an API key", "error");
            return false;
        }

        if (!validateBtn) return false;

        // Show loading state
        validateBtn.disabled = true;
        validateBtn.classList.add("opacity-50", "cursor-not-allowed");
        const originalHTML = validateBtn.innerHTML;
        validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';

        try {
            const response = await fetch("/poster-rating/validate", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ provider: selectedProvider, api_key: apiKey })
            });

            const data = await response.json();

            if (data.valid) {
                showValidationMessage("API key is valid ✓", "success");
                isValidated = true;
                return true;
            } else {
                showValidationMessage(data.message || "Invalid API key", "error");
                apiKeyInput.value = ""; // Clear invalid key
                isValidated = false;
                return false;
            }
        } catch (error) {
            showValidationMessage("Validation failed. Please try again.", "error");
            isValidated = false;
            return false;
        } finally {
            validateBtn.disabled = false;
            validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
            validateBtn.innerHTML = originalHTML;
        }
    }

    // Show validation message
    function showValidationMessage(message, type) {
        if (!validationMessage) return;
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    // Clear validation message
    function clearValidationMessage() {
        if (validationMessage) {
            validationMessage.classList.add("hidden");
        }
    }

    // Validate button click
    if (validateBtn) {
        validateBtn.addEventListener("click", validateApiKey);
    }

    // Clear validation when API key changes
    apiKeyInput.addEventListener("input", () => {
        isValidated = false;
        clearValidationMessage();
    });

    function updateUI() {
        const selectedProvider = providerSelect.value;

        if (selectedProvider && providerInfo[selectedProvider]) {
            const info = providerInfo[selectedProvider];
            apiKeyContainer.style.display = "block";
            helpContainer.style.display = "block";
            helpText.innerHTML = `${info.description}. Get your API key from <a href="${info.url}" target="_blank" class="text-slate-300 hover:text-white underline">${info.name}</a>.`;
            // Don't clear the API key when switching providers - just reset validation
            isValidated = false;
            clearValidationMessage();
        } else {
            // Only clear when provider is set to "None"
            apiKeyContainer.style.display = "none";
            helpContainer.style.display = "none";
            apiKeyInput.value = "";
            isValidated = false;
            clearValidationMessage();
        }
    }

    // Handle provider change - preserve API key value, just reset validation
    providerSelect.addEventListener("change", () => {
        isValidated = false;
        clearValidationMessage();
        updateUI();
    });

    updateUI(); // Initialize on load

    // Export validate function for form submission
    window.validatePosterRatingApiKey = validateApiKey;
}

// TMDB API Key (Required)
function initializeTmdb() {
    const apiKeyInput = document.getElementById("tmdbApiKey");
    const validateBtn = document.getElementById("tmdbApiKeyValidate");
    const toggleBtn = document.getElementById("tmdbApiKeyToggle");
    const eyeIcon = document.getElementById("tmdbApiKeyEye");
    const eyeOffIcon = document.getElementById("tmdbApiKeyEyeOff");
    const validationMessage = document.getElementById("tmdbValidationMessage");

    if (!apiKeyInput || !validationMessage) return;

    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    function showTmdbValidationMessage(message, type) {
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    if (validateBtn) {
        validateBtn.addEventListener("click", async () => {
            const apiKey = apiKeyInput.value.trim();
            if (!apiKey) {
                showTmdbValidationMessage("Please enter a TMDB API key", "error");
                return;
            }
            validateBtn.disabled = true;
            validateBtn.classList.add("opacity-50", "cursor-not-allowed");
            const originalHTML = validateBtn.innerHTML;
            validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';
            try {
                const response = await fetch("/tmdb/validation", {
                    method: "POST",
                    headers: { "Content-Type": "application/json" },
                    body: JSON.stringify({ api_key: apiKey })
                });
                const data = await response.json();
                if (data.valid) {
                    showTmdbValidationMessage("TMDB API key is valid ✓", "success");
                } else {
                    showTmdbValidationMessage(data.message || "Invalid TMDB API key", "error");
                }
            } catch (error) {
                showTmdbValidationMessage("Validation failed. Please try again.", "error");
            } finally {
                validateBtn.disabled = false;
                validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
                validateBtn.innerHTML = originalHTML;
            }
        });
    }

    apiKeyInput.addEventListener("input", () => validationMessage.classList.add("hidden"));
}

// Simkl Integration
function initializeSimkl() {
    const apiKeyInput = document.getElementById("simklApiKey");
    const validateBtn = document.getElementById("simklApiKeyValidate");
    const toggleBtn = document.getElementById("simklApiKeyToggle");
    const eyeIcon = document.getElementById("simklApiKeyEye");
    const eyeOffIcon = document.getElementById("simklApiKeyEyeOff");
    const validationMessage = document.getElementById("simklValidationMessage");

    if (!apiKeyInput || !validateBtn || !validationMessage) return;

    // Eye toggle functionality
    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    // Validation function
    async function validateSimklKey() {
        const apiKey = apiKeyInput.value.trim();

        if (!apiKey) {
            showSimklValidationMessage("Please enter a Simkl API key", "error");
            return false;
        }

        // Show loading state
        validateBtn.disabled = true;
        validateBtn.classList.add("opacity-50", "cursor-not-allowed");
        const originalHTML = validateBtn.innerHTML;
        validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';

        try {
            const response = await fetch("/simkl/validation", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ api_key: apiKey })
            });

            const data = await response.json();

            if (data.valid) {
                showSimklValidationMessage("Simkl API key is valid ✓", "success");
                return true;
            } else {
                showSimklValidationMessage(data.message || "Invalid Simkl API key", "error");
                return false;
            }
        } catch (error) {
            showSimklValidationMessage("Validation failed. Please try again.", "error");
            return false;
        } finally {
            validateBtn.disabled = false;
            validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
            validateBtn.innerHTML = originalHTML;
        }
    }

    function showSimklValidationMessage(message, type) {
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    validateBtn.addEventListener("click", validateSimklKey);

    apiKeyInput.addEventListener("input", () => {
        validationMessage.classList.add("hidden");
    });
}

// Gemini AI Integration
function initializeGemini() {
    const apiKeyInput = document.getElementById("geminiApiKey");
    const validateBtn = document.getElementById("geminiApiKeyValidate");
    const toggleBtn = document.getElementById("geminiApiKeyToggle");
    const eyeIcon = document.getElementById("geminiApiKeyEye");
    const eyeOffIcon = document.getElementById("geminiApiKeyEyeOff");
    const validationMessage = document.getElementById("geminiValidationMessage");

    if (!apiKeyInput || !validateBtn || !validationMessage) return;

    // Eye toggle functionality
    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    // Validation function
    async function validateGeminiKey() {
        const apiKey = apiKeyInput.value.trim();

        if (!apiKey) {
            showGeminiValidationMessage("Please enter a Gemini API key", "error");
            return false;
        }

        // Show loading state
        validateBtn.disabled = true;
        validateBtn.classList.add("opacity-50", "cursor-not-allowed");
        const originalHTML = validateBtn.innerHTML;
        validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';

        try {
            const response = await fetch("/gemini/validation", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ api_key: apiKey })
            });

            const data = await response.json();

            if (data.valid) {
                showGeminiValidationMessage("Gemini API key is valid ✓", "success");
                return true;
            } else {
                showGeminiValidationMessage(data.message || "Invalid Gemini API key", "error");
                return false;
            }
        } catch (error) {
            showGeminiValidationMessage("Validation failed. Please try again.", "error");
            return false;
        } finally {
            validateBtn.disabled = false;
            validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
            validateBtn.innerHTML = originalHTML;
        }
    }

    function showGeminiValidationMessage(message, type) {
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    validateBtn.addEventListener("click", validateGeminiKey);

    apiKeyInput.addEventListener("input", () => {
        validationMessage.classList.add("hidden");
    });
}

// Password Toggles
function initializePasswordToggles() {
    document.querySelectorAll('.toggle-btn').forEach(btn => {
        btn.addEventListener('click', () => {
            const targetId = btn.getAttribute('data-target');
            const input = document.getElementById(targetId);
            if (!input) return;
            const isHidden = input.type === 'password';
            input.type = isHidden ? 'text' : 'password';
            // Swap icon and labels
            if (isHidden) {
                // Now visible: show eye-off icon
                btn.setAttribute('title', 'Hide');
                btn.setAttribute('aria-label', 'Hide password');
                btn.innerHTML = '<svg class="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.94 17.94A10.94 10.94 0 0 1 12 20c-7 0-11-8-11-8a21.77 21.77 0 0 1 5.06-6.17M9.9 4.24A10.94 10.94 0 0 1 12 4c7 0 11 8 11 8a21.8 21.8 0 0 1-3.22 4.31"/><path d="M1 1l22 22"/><path d="M14.12 14.12A3 3 0 0 1 9.88 9.88"/></svg>';
            } else {
                // Now hidden: show eye icon
                btn.setAttribute('title', 'Show');
                btn.setAttribute('aria-label', 'Show password');
                btn.innerHTML = '<svg class="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 12s4-7 11-7 11 7 11 7-4 7-11 7-11-7-11-7z"/><circle cx="12" cy="12" r="3"/></svg>';
            }
        });
    });
}

// Delete & Success Helpers
function initializeSuccessActions() {
    const copyBtn = document.getElementById('copyBtn');
    if (copyBtn) {
        copyBtn.addEventListener('click', async (e) => {
            e.preventDefault();
            e.stopPropagation();
            const urlText = document.getElementById('addonUrl').textContent;
            try {
                await navigator.clipboard.writeText(urlText);
                const originalText = copyBtn.innerHTML;
                copyBtn.innerHTML = 'Copied!';
                setTimeout(() => { copyBtn.innerHTML = originalText; }, 2000);
            } catch (err) { }
        });
    }

    const installDesktopBtn = document.getElementById('installDesktopBtn');
    if (installDesktopBtn) {
        installDesktopBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            const url = document.getElementById('addonUrl').textContent;
            window.location.href = `stremio://${url.replace(/^https?:\/\//, '')}`;
        });
    }
    const installWebBtn = document.getElementById('installWebBtn');
    if (installWebBtn) {
        installWebBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            const url = document.getElementById('addonUrl').textContent;
            window.open(`https://web.stremio.com/#/addons?addon=${encodeURIComponent(url)}`, '_blank');
        });
    }

    const deleteAccountBtn = document.getElementById('deleteAccountBtn');
    if (deleteAccountBtn) {
        deleteAccountBtn.addEventListener('click', async () => {
            const confirmed = await showConfirm(
                'Delete Account?',
                'Are you sure you want to delete your settings? This action is irreversible and all your data will be permanently removed.'
            );

            if (!confirmed) return;

            const sAuthKey = (document.getElementById("authKey").value || '').trim();
            const email = emailInput?.value.trim();
            const password = passwordInput?.value;

            if (!sAuthKey && !(email && password)) {
                showError('generalError', "Provide Stremio auth key or email & password to delete your account.");
                switchSection('login');
                return;
            }

            setLoading(true);
            try {
                const payload = { authKey: sAuthKey || undefined, email: email || undefined, password: password || undefined };
                const res = await fetch('/tokens/', { method: 'DELETE', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
                if (!res.ok) throw new Error((await res.json()).detail || 'Failed to delete');
                showToast('Account deleted successfully.', 'success');
                if (resetApp) resetApp();
            } catch (e) {
                showError('generalError', e.message);
            } finally {
                setLoading(false);
            }
        });
    }
}

function setLoading(loading) {
    if (!submitBtn) return;
    const btnText = submitBtn.querySelector('.btn-text');
    const loader = submitBtn.querySelector('.loader');
    submitBtn.disabled = loading;
    if (loading) {
        if (btnText) btnText.classList.add('hidden');
        if (loader) loader.classList.remove('hidden');
    } else {
        if (btnText) btnText.classList.remove('hidden');
        if (loader) loader.classList.add('hidden');
    }
}

function showError(target, message) {
    if (target === 'generalError') {
        const errEl = document.getElementById('errorMessage');
        if (errEl) {
            errEl.querySelector('.message-content').textContent = message;
            errEl.classList.remove('hidden');
        } else { showToast(message, 'error'); }
    } else if (target === 'stremioAuthSection') {
        showToast(message, 'error');
    } else {
        const el = document.getElementById(target);
        if (el) {
            el.classList.add('border-red-500');
            el.focus();
        }
    }
}

export function clearErrors() {
    const errEl = document.getElementById('errorMessage');
    if (errEl) errEl.classList.add('hidden');
    document.querySelectorAll('.border-red-500').forEach(e => e.classList.remove('border-red-500'));
}

function showSuccess(url) {
    // Hide form entirely by hiding the active section
    const sections = {
        welcome: document.getElementById('sect-welcome'),
        login: document.getElementById('sect-login'),
        config: document.getElementById('sect-config'),
        catalogs: document.getElementById('sect-catalogs'),
        install: document.getElementById('sect-install'),
        success: document.getElementById('sect-success')
    };
    Object.values(sections).forEach(s => { if (s) s.classList.add('hidden') });

    // Show Success Section
    if (sections.success) {
        sections.success.classList.remove('hidden');
        document.getElementById('addonUrl').textContent = url;
    }
}

// Year Slider Logic
function initializeYearSlider() {
    const yearMin = document.getElementById('yearMin');
    const yearMax = document.getElementById('yearMax');
    const yearMinLabel = document.getElementById('yearMinLabel');
    const yearMaxLabel = document.getElementById('yearMaxLabel');
    const track = document.getElementById('yearSliderTrack');

    if (!yearMin || !yearMax || !yearMinLabel || !yearMaxLabel || !track) return;

    function updateSlider() {
        const minVal = parseInt(yearMin.value);
        const maxVal = parseInt(yearMax.value);

        if (minVal > maxVal) {
            // Prevent crossing: if min > max, snap them
            // This is handled by input listeners to avoid jerky movement
        }

        yearMinLabel.textContent = minVal;
        yearMaxLabel.textContent = maxVal;

        const range = yearMin.max - yearMin.min;
        const left = ((minVal - yearMin.min) / range) * 100;
        const right = ((yearMin.max - maxVal) / range) * 100;

        track.style.left = left + '%';
        track.style.right = right + '%';
    }

    yearMin.addEventListener('input', () => {
        if (parseInt(yearMin.value) > parseInt(yearMax.value)) {
            yearMin.value = yearMax.value;
        }
        yearMin.classList.add('year-slider-active');
        yearMax.classList.remove('year-slider-active');
        updateSlider();
    });

    yearMax.addEventListener('input', () => {
        if (parseInt(yearMax.value) < parseInt(yearMin.value)) {
            yearMax.value = yearMin.value;
        }
        yearMax.classList.add('year-slider-active');
        yearMin.classList.remove('year-slider-active');
        updateSlider();
    });

    // Initial update
    updateSlider();

    // Export update function for external population
    window.updateYearSlider = updateSlider;
}
" | base64 --decode > "$REPO/app/static/js/modules/form.js" +echo " wrote app/static/js/modules/form.js" + +mkdir -p "$REPO/app/services" +echo "from typing import Any

from fastapi import HTTPException
from loguru import logger

from app.core.config import settings
from app.core.security import redact_token
from app.core.settings import UserSettings, resolve_tmdb_api_key
from app.core.version import __version__
from app.services.catalog import DynamicCatalogService
from app.services.profile.integration import ProfileIntegration
from app.services.stremio.service import StremioBundle
from app.services.token_store import token_store
from app.services.translation import apply_catalog_translation
from app.services.user_cache import user_cache
from app.utils.catalog import cache_profile_and_watched_sets, sort_catalogs


class ManifestService:
    """Service for generating Stremio manifest files."""

    @staticmethod
    def get_base_manifest() -> dict[str, Any]:
        """Get the base manifest structure."""
        return {
            "id": settings.ADDON_ID,
            "version": __version__,
            "name": settings.ADDON_NAME,
            "description": "Movie and series recommendations based on your Stremio library.",
            "logo": ("https://raw.githubusercontent.com/TimilsinaBimal/Watchly/refs/heads/main/app/static/logo.png"),
            "background": (
                "https://raw.githubusercontent.com/TimilsinaBimal/Watchly/refs/heads/main/app/static/cover.png"
            ),
            "resources": ["catalog"],
            "types": ["movie", "series"],
            "idPrefixes": ["tt"],
            "catalogs": [],
            "behaviorHints": {"configurable": True, "configurationRequired": False},
            "stremioAddonsConfig": {
                "issuer": "https://stremio-addons.net",
                "signature": (
                    "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0..WSrhzzlj1TuDycD6QoVLuA.Dzmxzr4y83uqQF15r4tC1bB9-vtZRh1Rvy4BqgDYxu91c2esiJuov9KnnI_cboQCgZS7hjwnIqRSlQ-jEyGwXHHRerh9QklyfdxpXqNUyBgTWFzDOVdVvDYJeM_tGMmR.sezAChlWGV7lNS-t9HWB6A"  # noqa
                ),
            },
        }

    async def _resolve_auth_key(self, bundle: StremioBundle, credentials: dict[str, Any], token: str) -> str | None:
        """Resolve and validate auth key, refreshing if needed."""
        auth_key = credentials.get("authKey")
        email = credentials.get("email")
        password = credentials.get("password")

        is_valid = False
        if auth_key:
            try:
                await bundle.auth.get_user_info(auth_key)
                is_valid = True
            except Exception as e:
                logger.debug(f"Auth key check failed for {email or 'unknown'}: {e}")

        if not is_valid and email and password:
            try:
                auth_key = await bundle.auth.login(email, password)
                # Update store
                credentials["authKey"] = auth_key
                await token_store.update_user_data(token, credentials)
            except Exception as e:
                logger.error(f"Failed to refresh auth key during manifest fetch: {e}")
                return None

        return auth_key

    async def cache_library_and_profiles(
        self, bundle: StremioBundle, auth_key: str, user_settings: UserSettings, token: str
    ) -> dict[str, Any]:
        """
        Fetch and cache library items and profiles for a user.

        This should be called during token creation to pre-cache data
        so manifest generation is fast.

        Args:
            bundle: StremioBundle instance
            auth_key: Stremio auth key
            user_settings: User settings
            token: User token

        Returns:
            Library items dictionary
        """
        # Fetch library items
        logger.info(f"[{redact_token(token)}] Fetching library items for caching")
        library_items = await bundle.library.get_library_items(auth_key)

        # Cache library items using centralized cache service
        await user_cache.set_library_items(token, library_items)
        logger.debug(f"[{redact_token(token)}] Cached library items")

        # Build and cache profiles for both movie and series
        language = user_settings.language
        tmdb_key = resolve_tmdb_api_key(user_settings)
        integration_service = ProfileIntegration(language=language, tmdb_api_key=tmdb_key)

        for content_type in ["movie", "series"]:
            try:
                logger.info(f"[{redact_token(token)}] Building and caching profile for {content_type}")
                _, _, _ = await cache_profile_and_watched_sets(
                    token, content_type, integration_service, library_items, bundle, auth_key
                )
                logger.debug(f"[{redact_token(token)}] Cached profile and watched sets for {content_type}")
            except Exception as e:
                logger.warning(f"[{redact_token(token)}] Failed to build/cache profile for {content_type}: {e}")

        return library_items

    async def cache_library_and_profiles_from_items(
        self, library_items: dict, user_settings: UserSettings, token: str
    ) -> None:
        """
        Cache library items and build profiles from an already-fetched library dict.
        Used by Trakt (and any future non-Stremio provider) where library data is
        obtained outside of the Stremio bundle.
        """
        await user_cache.set_library_items(token, library_items)
        logger.debug(f"[{redact_token(token)}] Cached library items (provider-agnostic)")

        language = user_settings.language
        tmdb_key = resolve_tmdb_api_key(user_settings)
        integration_service = ProfileIntegration(language=language, tmdb_api_key=tmdb_key)

        for content_type in ["movie", "series"]:
            try:
                profile, watched_tmdb, watched_imdb = await integration_service.build_profile_from_library(
                    library_items, content_type
                )
                await user_cache.set_profile_and_watched_sets(token, content_type, profile, watched_tmdb, watched_imdb)
                logger.debug(f"[{redact_token(token)}] Cached profile for {content_type}")
            except Exception as e:
                logger.warning(f"[{redact_token(token)}] Failed to cache profile for {content_type}: {e}")


    async def _ensure_library_and_profiles_cached(
        self, bundle: StremioBundle, auth_key: str, user_settings: UserSettings, token: str
    ) -> dict[str, Any]:
        """Ensure library items and profiles are cached, fetching and building if needed."""
        # Try to get cached library items first
        library_items = await user_cache.get_library_items(token)

        if library_items:
            logger.debug(f"[{redact_token(token)}] Using cached library items for manifest")
            return library_items

        # If not cached, fetch and cache
        logger.info(f"[{redact_token(token)}] Library items not cached, fetching from Stremio for manifest")
        return await self.cache_library_and_profiles(bundle, auth_key, user_settings, token)

    async def _build_dynamic_catalogs(
        self, bundle: StremioBundle, auth_key: str, user_settings: UserSettings | None, token: str
    ) -> list[dict[str, Any]]:
        """Build dynamic catalogs for the manifest."""
        # check if cached, if not, fetch and cache
        library_items = await user_cache.get_library_items(token)
        if not library_items:
            library_items = await self._ensure_library_and_profiles_cached(bundle, auth_key, user_settings, token)
            await user_cache.set_library_items(token, library_items)

        tmdb_key = resolve_tmdb_api_key(user_settings)
        dynamic_catalog_service = DynamicCatalogService(language=user_settings.language, tmdb_api_key=tmdb_key)
        return await dynamic_catalog_service.get_dynamic_catalogs(library_items, user_settings, token=token)

    async def _translate_catalogs(self, catalogs: list[dict[str, Any]], language: str | None) -> list[dict[str, Any]]:
        """Translate catalog names to target language."""
        if not language:
            return catalogs

        translated_catalogs = []
        for cat in catalogs:
            await apply_catalog_translation(cat, language)
            translated_catalogs.append(cat)

        return translated_catalogs

    def _sort_catalogs(
        self, catalogs: list[dict[str, Any]], user_settings: UserSettings | None
    ) -> list[dict[str, Any]]:
        """Sort catalogs according to user settings order."""
        if not user_settings:
            return catalogs

        return sort_catalogs(catalogs, user_settings)

    async def _build_dynamic_catalogs_trakt(
        self, creds: dict, user_settings: UserSettings | None, token: str
    ) -> list[dict[str, Any]]:
        """Build dynamic catalogs for a Trakt-backed account."""
        from app.core.config import settings as app_settings
        from app.services.trakt.service import TraktBundle

        # Use cached library if available
        library_items = await user_cache.get_library_items(token)
        if not library_items:
            access_token = creds.get("authKey")  # stored as authKey after encryption/decryption
            if not access_token or not app_settings.TRAKT_CLIENT_ID or not app_settings.TRAKT_CLIENT_SECRET:
                logger.warning(f"[{redact_token(token)}] Trakt credentials missing, cannot fetch library")
                return []
            redirect_uri = f"{app_settings.HOST_NAME}/tokens/trakt/callback"
            trakt_bundle = TraktBundle(
                client_id=app_settings.TRAKT_CLIENT_ID,
                client_secret=app_settings.TRAKT_CLIENT_SECRET,
                redirect_uri=redirect_uri,
                access_token=access_token,
            )
            try:
                library_items = await trakt_bundle.library.get_library_items()
                await user_cache.set_library_items(token, library_items)
            finally:
                await trakt_bundle.close()

        if not library_items:
            return []

        tmdb_key = resolve_tmdb_api_key(user_settings)
        dynamic_catalog_service = DynamicCatalogService(
            language=user_settings.language if user_settings else "en-US",
            tmdb_api_key=tmdb_key,
        )
        return await dynamic_catalog_service.get_dynamic_catalogs(library_items, user_settings, token=token)

    async def get_manifest_for_token(self, token: str) -> dict[str, Any]:
        """
        Generate manifest for a given token.

        Args:
            token: User token

        Returns:
            Complete manifest dictionary

        Raises:
            HTTPException: If token is invalid or credentials are missing
        """
        if not token:
            raise HTTPException(status_code=401, detail="Missing token. Please reconfigure the addon.")

        # Load user credentials and settings
        creds = await token_store.get_user_data(token)
        if not creds:
            raise HTTPException(status_code=401, detail="Token not found. Please reconfigure the addon.")

        user_settings = None
        try:
            if creds.get("settings"):
                user_settings = UserSettings(**creds["settings"])
        except Exception as e:
            logger.error(f"[{redact_token(token)}] Error loading user data from token store: {e}")
            raise HTTPException(status_code=401, detail="Invalid token session. Please reconfigure.")

        base_manifest = self.get_base_manifest()

        fetched_catalogs = []
        try:
            if creds.get("auth_provider") == "trakt":
                # Trakt-backed account: fetch library from Trakt, bypass Stremio
                fetched_catalogs = await self._build_dynamic_catalogs_trakt(creds, user_settings, token)
            else:
                bundle = StremioBundle()
                try:
                    # Resolve auth key
                    auth_key = await self._resolve_auth_key(bundle, creds, token)

                    if auth_key:
                        fetched_catalogs = await self._build_dynamic_catalogs(bundle, auth_key, user_settings, token)
                finally:
                    await bundle.close()
        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Dynamic catalog build failed: {e}")
            fetched_catalogs = []

        # Combine base catalogs with fetched catalogs
        all_catalogs = [c.copy() for c in base_manifest["catalogs"]] + [c.copy() for c in fetched_catalogs]

        # Translate catalogs
        language = user_settings.language if user_settings else None
        translated_catalogs = await self._translate_catalogs(all_catalogs, language)

        # Sort catalogs
        sorted_catalogs = self._sort_catalogs(translated_catalogs, user_settings)

        if sorted_catalogs:
            base_manifest["catalogs"] = sorted_catalogs

        return base_manifest


manifest_service = ManifestService()
" | base64 --decode > "$REPO/app/services/manifest.py" +echo " wrote app/services/manifest.py" + +mkdir -p "$REPO/app/services" +echo "import asyncio
from datetime import datetime, timezone
from typing import Any

from fastapi import HTTPException
from loguru import logger

from app.core.config import settings
from app.core.security import redact_token
from app.core.settings import UserSettings
from app.services.catalog import DynamicCatalogService
from app.services.manifest import manifest_service
from app.services.stremio.service import StremioBundle
from app.services.token_store import token_store
from app.services.translation import apply_catalog_translation
from app.utils.catalog import sort_catalogs


class CatalogUpdater:
    """
    Catalog updater that triggers updates on-demand when users request catalogs.
    Uses in-memory locking to prevent duplicate concurrent updates.
    """

    def __init__(self):
        # In-memory lock to prevent duplicate updates for the same token
        self._updating_tokens: set[str] = set()

    def _needs_update(self, credentials: dict[str, Any]) -> bool:
        """Check if catalog update is needed based on last_updated timestamp."""
        if not credentials:
            return False

        last_updated = credentials.get("last_updated")
        if not last_updated:
            # No timestamp means never updated, needs update
            return True

        try:
            # Parse ISO format timestamp
            if isinstance(last_updated, str):
                last_update_time = datetime.fromisoformat(last_updated.replace("Z", "+00:00"))
            else:
                last_update_time = last_updated

            # Check if more than 11 hours have passed (update if less than 1 hour remaining)
            now = datetime.now(timezone.utc)
            if last_update_time.tzinfo is None:
                last_update_time = last_update_time.replace(tzinfo=timezone.utc)

            time_since_update = (now - last_update_time).total_seconds()
            # Update if less than 1 hour remaining until next update
            return time_since_update >= (settings.CATALOG_REFRESH_INTERVAL_SECONDS - 3600)
        except (ValueError, TypeError, AttributeError) as e:
            logger.warning(f"Failed to parse last_updated timestamp: {e}. Treating as needs update.")
            return True

    async def refresh_catalogs_for_credentials(
        self, token: str, credentials: dict[str, Any], update_timestamp: bool = True
    ) -> bool:
        """
        Refresh catalogs for a user's credentials.

        Args:
            token: User token
            credentials: User credentials dict
            update_timestamp: Whether to update last_updated timestamp on success

        Returns:
            True if update was successful, False otherwise
        """
        if not credentials:
            logger.warning(f"[{redact_token(token)}] Attempted to refresh catalogs with no credentials.")
            raise HTTPException(status_code=401, detail="Invalid or expired token. Please reconfigure the addon.")

        # Trakt-backed accounts use a different refresh path
        if credentials.get("auth_provider") == "trakt":
            return await self._refresh_trakt_catalogs(token, credentials, update_timestamp)

        auth_key = credentials.get("authKey")
        # check if auth key is valid
        bundle = StremioBundle()
        try:
            try:
                await bundle.auth.get_user_info(auth_key)
            except Exception as e:
                logger.exception(f"[{redact_token(token)}] Invalid auth key. Falling back to login: {e}")
                email = credentials.get("email")
                password = credentials.get("password")
                if email and password:
                    auth_key = await bundle.auth.login(email, password)
                    credentials["authKey"] = auth_key
                    await token_store.update_user_data(token, credentials)
                else:
                    return True  # true since we won't be able to update it again. so no need to try again.

            # 1. Check if addon is still installed
            try:
                addon_installed = await bundle.addons.is_addon_installed(auth_key)
                if not addon_installed:
                    logger.info(f"[{redact_token(token)}] User has not installed addon. Removing token from redis")
                    return True
            except Exception as e:
                logger.exception(f"[{redact_token(token)}] Failed to check if addon is installed: {e}")
                return False

            # 2. Extract settings and refresh
            user_settings = None
            if credentials.get("settings"):
                try:
                    user_settings = UserSettings(**credentials["settings"])
                except Exception as e:
                    logger.exception(f"[{redact_token(token)}] Failed to parse user settings: {e}")
                    # if user doesn't have setting, we can't update the catalogs.
                    # so no need to try again.
                    return True

            library_items = await manifest_service.cache_library_and_profiles(bundle, auth_key, user_settings, token)
            language = user_settings.language if user_settings else "en-US"

            from app.core.settings import resolve_tmdb_api_key

            tmdb_key = resolve_tmdb_api_key(user_settings)
            dynamic_catalog_service = DynamicCatalogService(
                language=language,
                tmdb_api_key=tmdb_key,
            )

            catalogs = await dynamic_catalog_service.get_dynamic_catalogs(
                library_items=library_items, user_settings=user_settings, token=token
            )

            lang = user_settings.language if user_settings else None
            for cat in catalogs:
                await apply_catalog_translation(cat, lang)

            # sort catalogs by order in user settings
            if user_settings:
                catalogs = sort_catalogs(catalogs, user_settings)

            success = await bundle.addons.update_catalogs(auth_key, catalogs)

            # Update timestamp and invalidate cache only on success
            if success and update_timestamp:
                try:
                    # Update last_updated timestamp to current time
                    # This represents when the update completed successfully
                    now = datetime.now(timezone.utc)
                    last_updated_str = now.replace(microsecond=0).isoformat()
                    credentials["last_updated"] = last_updated_str
                    await token_store.update_user_data(token, credentials)
                    logger.debug(f"[{redact_token(token)}] Updated last_updated timestamp to {last_updated_str}")
                except Exception as e:
                    logger.warning(f"[{redact_token(token)}] Failed to update last_updated timestamp: {e}")

            return success

        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Failed to update catalogs in background: {e}")
            try:
                error_msg = f"Failed to update catalogs: {str(e)}"
                description = (
                    f"Movie and series recommendations based on your Stremio library.\n\n⚠️ Status: Error\n{error_msg}"
                )
                await bundle.addons.update_description(auth_key, description)
            except Exception as update_err:
                logger.warning(f"[{redact_token(token)}] Failed to update addon description with error: {update_err}")
            return False
        finally:
            await bundle.close()

    async def _refresh_trakt_catalogs(
        self, token: str, credentials: dict[str, Any], update_timestamp: bool = True
    ) -> bool:
        """Refresh catalogs for a Trakt-backed account."""
        from app.core.settings import resolve_tmdb_api_key
        from app.services.trakt.service import TraktBundle

        user_settings = None
        if credentials.get("settings"):
            try:
                user_settings = UserSettings(**credentials["settings"])
            except Exception as e:
                logger.warning(f"[{redact_token(token)}] Failed to parse Trakt user settings: {e}")
                return True

        access_token = credentials.get("authKey")  # stored as authKey after decrypt
        if not access_token or not settings.TRAKT_CLIENT_ID or not settings.TRAKT_CLIENT_SECRET:
            logger.warning(f"[{redact_token(token)}] Trakt credentials missing, skipping refresh")
            return True

        redirect_uri = f"{settings.HOST_NAME}/tokens/trakt/callback"
        trakt_bundle = TraktBundle(
            client_id=settings.TRAKT_CLIENT_ID,
            client_secret=settings.TRAKT_CLIENT_SECRET,
            redirect_uri=redirect_uri,
            access_token=access_token,
        )
        try:
            library_items = await trakt_bundle.library.get_library_items()
            await manifest_service.cache_library_and_profiles_from_items(library_items, user_settings, token)

            if update_timestamp:
                now = datetime.now(timezone.utc)
                credentials["last_updated"] = now.replace(microsecond=0).isoformat()
                await token_store.update_user_data(token, credentials)

            logger.info(f"[{redact_token(token)}] Trakt catalog refresh complete")
            return True
        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Trakt catalog refresh failed: {e}")
            return False
        finally:
            await trakt_bundle.close()

    async def trigger_update(self, token: str, credentials: dict[str, Any]) -> None:
        """
        Trigger a catalog update if needed.
        This function checks if update is needed and fires a background task.
        Uses in-memory lock to prevent duplicate updates.
        """
        # Check if already updating
        if token in self._updating_tokens:
            logger.debug(f"[{redact_token(token)}] Update already in progress, skipping")
            return

        # Check if update is needed
        if not self._needs_update(credentials):
            logger.debug(f"[{redact_token(token)}] Catalog update not needed yet")
            return

        # Add to lock and fire background update
        self._updating_tokens.add(token)
        logger.info(f"[{redact_token(token)}] Triggering catalog update")

        # Fire and forget background task
        asyncio.create_task(self._update_task(token, credentials))

    async def _update_task(self, token: str, credentials: dict[str, Any]) -> None:
        """Background task that performs the actual catalog update."""
        try:
            success = await self.refresh_catalogs_for_credentials(token, credentials, update_timestamp=True)
            if success:
                logger.info(f"[{redact_token(token)}] Catalog update completed successfully")
            else:
                logger.warning(f"[{redact_token(token)}] Catalog update completed with failure")
        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Catalog update task failed: {e}")
        finally:
            # Always remove from lock
            self._updating_tokens.discard(token)


logger.info(f"Catalog updater initialized with refresh interval of {settings.CATALOG_REFRESH_INTERVAL_SECONDS} seconds")
catalog_updater = CatalogUpdater()
" | base64 --decode > "$REPO/app/services/catalog_updater.py" +echo " wrote app/services/catalog_updater.py" + +mkdir -p "$REPO/app/services" +echo "import base64
import json
from typing import Any

import redis.asyncio as redis
from async_lru import alru_cache
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from loguru import logger

from app.core.config import settings
from app.core.security import redact_token
from app.services.redis_service import redis_service
from app.services.user_cache import user_cache


class TokenStore:
    """Redis-backed store for user credentials and auth tokens."""

    KEY_PREFIX = settings.REDIS_TOKEN_KEY

    def __init__(self) -> None:
        if not settings.TOKEN_SALT or settings.TOKEN_SALT == "change-me":
            logger.warning(
                "TOKEN_SALT is missing or using the default placeholder. Set a strong value to secure tokens."
            )

    def _ensure_secure_salt(self) -> None:
        if not settings.TOKEN_SALT or settings.TOKEN_SALT == "change-me":
            logger.error("TOKEN_SALT is unset or using the insecure default.")
            raise RuntimeError("TOKEN_SALT must be set to a non-default value before storing credentials.")

    def _get_cipher(self) -> Fernet:
        salt = b"x7FDf9kypzQ1LmR32b8hWv49sKq2Pd8T"
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=salt,
            iterations=200_000,
        )

        key = base64.urlsafe_b64encode(kdf.derive(settings.TOKEN_SALT.encode("utf-8")))
        return Fernet(key)

    def encrypt_token(self, token: str) -> str:
        cipher = self._get_cipher()
        return cipher.encrypt(token.encode("utf-8")).decode("utf-8")

    def decrypt_token(self, enc: str) -> str:
        cipher = self._get_cipher()
        return cipher.decrypt(enc.encode("utf-8")).decode("utf-8")

    def _format_key(self, token: str) -> str:
        """Format Redis key from token."""
        return f"{self.KEY_PREFIX}{token}"

    def get_token_from_user_id(self, user_id: str) -> str:
        return user_id.strip()

    def get_user_id_from_token(self, token: str) -> str:
        return token.strip() if token else ""

    async def store_user_data(self, user_id: str, payload: dict[str, Any]) -> str:
        self._ensure_secure_salt()
        token = self.get_token_from_user_id(user_id)
        key = self._format_key(token)

        # Prepare data for storage (Plain JSON, no encryption needed)
        storage_data = payload.copy()

        # Store user_id in payload for convenience
        storage_data["user_id"] = user_id

        if storage_data.get("authKey"):
            storage_data["authKey"] = self.encrypt_token(storage_data["authKey"])

        # Encrypt Trakt refresh token if present
        if storage_data.get("trakt_refresh_token"):
            try:
                if not storage_data["trakt_refresh_token"].startswith("gAAAAAB"):
                    storage_data["trakt_refresh_token"] = self.encrypt_token(storage_data["trakt_refresh_token"])
            except Exception as exc:
                logger.warning(f"Failed to encrypt trakt_refresh_token: {exc}")

        # Securely store password if provided (primary login mode)
        if storage_data.get("password"):
            try:
                storage_data["password"] = self.encrypt_token(storage_data["password"])
            except Exception as exc:
                logger.error(f"Password encryption failed for {redact_token(user_id)}: {exc}")
                # Do not store plaintext passwords
                raise RuntimeError("PASSWORD_ENCRYPT_FAILED")

        # Encrypt poster_rating API key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            poster_rating = storage_data["settings"].get("poster_rating")
            if poster_rating and isinstance(poster_rating, dict) and poster_rating.get("api_key"):
                try:
                    # Only encrypt if it's not already encrypted (check if it's a valid encrypted string)
                    api_key = poster_rating["api_key"]
                    # Simple check: encrypted tokens are base64-like and longer
                    # If it looks like plaintext, encrypt it
                    # Fernet encrypted tokens start with "gAAAAAB"
                    if not api_key.startswith("gAAAAAB"):
                        poster_rating["api_key"] = self.encrypt_token(api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt poster_rating api_key for {redact_token(user_id)}: {exc}")

        # Encrypt simkl_api_key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            simkl_api_key = storage_data["settings"].get("simkl_api_key")
            if simkl_api_key:
                try:
                    if not simkl_api_key.startswith("gAAAAAB"):
                        storage_data["settings"]["simkl_api_key"] = self.encrypt_token(simkl_api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt simkl_api_key for {redact_token(user_id)}: {exc}")

        # Encrypt gemini_api_key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            gemini_api_key = storage_data["settings"].get("gemini_api_key")
            if gemini_api_key:
                try:
                    if not gemini_api_key.startswith("gAAAAAB"):
                        storage_data["settings"]["gemini_api_key"] = self.encrypt_token(gemini_api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt gemini_api_key for {redact_token(user_id)}: {exc}")

        # Encrypt tmdb_api_key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            tmdb_api_key = storage_data["settings"].get("tmdb_api_key")
            if tmdb_api_key:
                try:
                    if not tmdb_api_key.startswith("gAAAAAB"):
                        storage_data["settings"]["tmdb_api_key"] = self.encrypt_token(tmdb_api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt tmdb_api_key for {redact_token(user_id)}: {exc}")
        json_str = json.dumps(storage_data)

        if settings.TOKEN_TTL_SECONDS and settings.TOKEN_TTL_SECONDS > 0:
            await redis_service.set(key, json_str, settings.TOKEN_TTL_SECONDS)
        else:
            await redis_service.set(key, json_str)

        # Invalidate async LRU cache for fresh reads on subsequent requests
        try:
            self._get_user_data_cached.cache_invalidate(token)
        except KeyError:
            pass
        except Exception as e:
            logger.warning(f"Targeted cache invalidation failed: {e}. Falling back to clearing cache.")
            try:
                self._get_user_data_cached.cache_clear()
            except Exception as e_clear:
                logger.error(f"Error while clearing cache: {e_clear}")

        return token

    async def update_user_data(self, token: str, payload: dict[str, Any]) -> str:
        """Update user data by token. This is a convenience wrapper around store_user_data."""
        user_id = self.get_user_id_from_token(token)
        return await self.store_user_data(user_id, payload)

    async def _migrate_poster_rating_format_raw(self, token: str, redis_key: str, data: dict) -> dict | None:
        """Migrate old rpdb_key format to new poster_rating format in raw Redis data if needed."""
        if not data:
            return None

        settings_dict = data.get("settings")
        if not settings_dict or not isinstance(settings_dict, dict):
            return None

        rpdb_key = settings_dict.get("rpdb_key")
        poster_rating = settings_dict.get("poster_rating")
        needs_save = False

        # Case 1: Migrate rpdb_key to poster_rating if rpdb_key exists and poster_rating doesn't
        if rpdb_key and not poster_rating:
            logger.info(f"[MIGRATION] Migrating rpdb_key to poster_rating format for {redact_token(token)}")
            settings_dict["poster_rating"] = {
                "provider": "rpdb",
                "api_key": self.encrypt_token(rpdb_key),  # Encrypt the API key
            }
            needs_save = True

        # Case 2: Clean up deprecated rpdb_key field if it exists (even if empty/null)
        # Remove it since we've migrated to poster_rating or it's no longer needed
        if "rpdb_key" in settings_dict:
            settings_dict.pop("rpdb_key")
            # keep empty poster_rating field for now
            settings_dict["poster_rating"] = {
                "provider": "rpdb",
                "api_key": None,
            }
            if not needs_save:  # Only log if we didn't already log migration
                logger.info(f"[MIGRATION] Removing deprecated rpdb_key field for {redact_token(token)}")
            needs_save = True

        # Save back to redis if any changes were made
        if needs_save:
            try:
                if settings.TOKEN_TTL_SECONDS and settings.TOKEN_TTL_SECONDS > 0:
                    await redis_service.set(redis_key, json.dumps(data), settings.TOKEN_TTL_SECONDS)
                else:
                    await redis_service.set(redis_key, json.dumps(data))

                # Invalidate cache so next read gets the migrated data
                try:
                    self.get_user_data.cache_invalidate(token)
                except Exception:
                    pass

                logger.info(
                    "[MIGRATION] Successfully migrated and encrypted poster_rating " f"format for {redact_token(token)}"
                )
                return data
            except Exception as e:
                logger.warning(f"[MIGRATION] Failed to save migrated data for {redact_token(token)}: {e}")
                return None

        return None

    async def get_user_data(self, token: str) -> dict[str, Any] | None:
        data = await self._get_user_data_cached(token)
        if data is None:
            # Don't let a missing-token result get pinned in the per-process cache;
            # otherwise a token created on another worker would 401 here for hours.
            try:
                self._get_user_data_cached.cache_invalidate(token)
            except Exception:
                pass
        return data

    @alru_cache(maxsize=2000, ttl=43200)
    async def _get_user_data_cached(self, token: str) -> dict[str, Any] | None:
        logger.debug(f"[REDIS] Cache miss. Fetching data from redis for {token}")
        key = self._format_key(token)
        data_raw = await redis_service.get(key)

        if not data_raw:
            return None

        try:
            data = json.loads(data_raw)
        except json.JSONDecodeError:
            return None

        updated_data = await self._migrate_poster_rating_format_raw(token, key, data)
        if updated_data:
            data = updated_data

        # Decrypt fields individually; do not fail entire record on decryption errors
        if data.get("authKey"):
            try:
                data["authKey"] = self.decrypt_token(data["authKey"])
            except Exception as e:
                logger.warning(f"Decryption failed for authKey associated with {redact_token(token)}: {e}")
                # Leave as-is (legacy plaintext or previous failure)
                pass

        if data.get("trakt_refresh_token"):
            try:
                if data["trakt_refresh_token"].startswith("gAAAAA"):
                    data["trakt_refresh_token"] = self.decrypt_token(data["trakt_refresh_token"])
            except Exception as e:
                logger.debug(f"Decryption failed for trakt_refresh_token associated with {redact_token(token)}: {e}")
        if data.get("password"):
            try:
                data["password"] = self.decrypt_token(data["password"])
            except Exception as e:
                logger.warning(f"Decryption failed for password associated with {redact_token(token)}: {e}")
                # require re-login path when needed
                data["password"] = None

        # Decrypt poster_rating API key if present
        if data.get("settings") and isinstance(data["settings"], dict):
            poster_rating = data["settings"].get("poster_rating")
            if poster_rating and isinstance(poster_rating, dict) and poster_rating.get("api_key"):
                try:
                    if poster_rating["api_key"].startswith("gAAAAA"):
                        poster_rating["api_key"] = self.decrypt_token(poster_rating["api_key"])
                except Exception as e:
                    logger.debug(
                        f"Decryption failed for poster_rating api_key associated with {redact_token(token)}: {e}"
                    )

            simkl_api_key = data["settings"].get("simkl_api_key")
            if simkl_api_key:
                try:
                    if simkl_api_key.startswith("gAAAAA"):
                        data["settings"]["simkl_api_key"] = self.decrypt_token(simkl_api_key)
                except Exception as e:
                    logger.debug(f"Decryption failed for simkl_api_key associated with {redact_token(token)}: {e}")

            gemini_api_key = data["settings"].get("gemini_api_key")
            if gemini_api_key:
                try:
                    if gemini_api_key.startswith("gAAAAA"):
                        data["settings"]["gemini_api_key"] = self.decrypt_token(gemini_api_key)
                except Exception as e:
                    logger.debug(f"Decryption failed for gemini_api_key associated with {redact_token(token)}: {e}")

            tmdb_api_key = data["settings"].get("tmdb_api_key")
            if tmdb_api_key:
                try:
                    if tmdb_api_key.startswith("gAAAAA"):
                        data["settings"]["tmdb_api_key"] = self.decrypt_token(tmdb_api_key)
                except Exception as e:
                    logger.debug(f"Decryption failed for tmdb_api_key associated with {redact_token(token)}: {e}")

        return data

    async def delete_token(self, token: str = None, key: str = None) -> None:
        if not token and not key:
            raise ValueError("Either token or key must be provided")
        if token:
            key = self._format_key(token)

        await redis_service.delete(key)
        # we also need to delete the cached library items, profiles and watched sets
        if token:
            try:
                await user_cache.invalidate_all_user_data(token)
            except Exception as e:
                logger.warning(f"Failed to invalidate all user data for {redact_token(token)}: {e}")

        # Invalidate async LRU cache so future reads reflect deletion
        try:
            if token:
                self._get_user_data_cached.cache_invalidate(token)
            else:
                # If only key is provided, clear cache entirely to be safe
                self._get_user_data_cached.cache_clear()
        except KeyError:
            pass
        except Exception as e:
            logger.warning(f"Failed to invalidate user data cache during token deletion: {e}")

    async def count_users(self) -> int:
        """Count total users by scanning Redis keys with the configured prefix.

        Cached for 12 hours to avoid frequent Redis scans.
        """
        try:
            client = await redis_service.get_client()
        except (redis.RedisError, OSError) as exc:
            logger.warning(f"Cannot count users; Redis unavailable: {exc}")
            return 0

        pattern = f"{self.KEY_PREFIX}*"
        total = 0
        try:
            async for _ in client.scan_iter(match=pattern, count=500):
                total += 1
        except (redis.RedisError, OSError) as exc:
            logger.warning(f"Failed to scan for user count: {exc}")
            return 0
        return total


token_store = TokenStore()
" | base64 --decode > "$REPO/app/services/token_store.py" +echo " wrote app/services/token_store.py" + +cat >> "$REPO/.env.example" << 'ENVEOF' + +# Trakt OAuth (optional - enables Trakt login on the configure page) +# Register your app at https://trakt.tv/oauth/applications/new +# Set the redirect URI to: http://localhost:8000/tokens/trakt/callback +TRAKT_CLIENT_ID= +TRAKT_CLIENT_SECRET= +ENVEOF + +echo "" +echo "Patch applied successfully! All files written." \ No newline at end of file diff --git a/apply_trakt_patch_final.sh b/apply_trakt_patch_final.sh new file mode 100644 index 0000000..961180e --- /dev/null +++ b/apply_trakt_patch_final.sh @@ -0,0 +1,95 @@ +#!/usr/bin/env bash +set -e + +REPO="$(pwd)" +if [ ! -f "$REPO/main.py" ] || [ ! -d "$REPO/app" ]; then + echo "ERROR: Run this script from inside your watchly-trakt directory." + exit 1 +fi +echo "Applying Trakt integration patch (final)..." +mkdir -p "$REPO/app/services/trakt" + +mkdir -p "$REPO/app/services/trakt" +echo "ZnJvbSBhcHAuc2VydmljZXMudHJha3Quc2VydmljZSBpbXBvcnQgVHJha3RCdW5kbGUKCl9fYWxsX18gPSBbIlRyYWt0QnVuZGxlIl0K" | base64 --decode > "$REPO/app/services/trakt/__init__.py" +echo " wrote app/services/trakt/__init__.py" + +mkdir -p "$REPO/app/services/trakt" +echo "ZnJvbSBhcHAuY29yZS5iYXNlX2NsaWVudCBpbXBvcnQgQmFzZUNsaWVudAoKCmNsYXNzIFRyYWt0Q2xpZW50KEJhc2VDbGllbnQpOgogICAgIiIiCiAgICBDbGllbnQgZm9yIGludGVyYWN0aW5nIHdpdGggdGhlIFRyYWt0IEFQSS4KICAgICIiIgoKICAgIGRlZiBfX2luaXRfXyhzZWxmLCBjbGllbnRfaWQ6IHN0ciwgYWNjZXNzX3Rva2VuOiBzdHIgfCBOb25lID0gTm9uZSwgdGltZW91dDogZmxvYXQgPSAxMC4wLCBtYXhfcmV0cmllczogaW50ID0gMyk6CiAgICAgICAgaGVhZGVycyA9IHsKICAgICAgICAgICAgIkNvbnRlbnQtVHlwZSI6ICJhcHBsaWNhdGlvbi9qc29uIiwKICAgICAgICAgICAgInRyYWt0LWFwaS12ZXJzaW9uIjogIjIiLAogICAgICAgICAgICAidHJha3QtYXBpLWtleSI6IGNsaWVudF9pZCwKICAgICAgICB9CiAgICAgICAgaWYgYWNjZXNzX3Rva2VuOgogICAgICAgICAgICBoZWFkZXJzWyJBdXRob3JpemF0aW9uIl0gPSBmIkJlYXJlciB7YWNjZXNzX3Rva2VufSIKCiAgICAgICAgc3VwZXIoKS5fX2luaXRfXyhiYXNlX3VybD0iaHR0cHM6Ly9hcGkudHJha3QudHYiLCB0aW1lb3V0PXRpbWVvdXQsIG1heF9yZXRyaWVzPW1heF9yZXRyaWVzLCBoZWFkZXJzPWhlYWRlcnMpCg==" | base64 --decode > "$REPO/app/services/trakt/client.py" +echo " wrote app/services/trakt/client.py" + +mkdir -p "$REPO/app/services/trakt" +echo "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" | base64 --decode > "$REPO/app/services/trakt/auth.py" +echo " wrote app/services/trakt/auth.py" + +mkdir -p "$REPO/app/services/trakt" +echo "ZnJvbSB0eXBpbmcgaW1wb3J0IEFueQoKZnJvbSBsb2d1cnUgaW1wb3J0IGxvZ2dlcgoKZnJvbSBhcHAuc2VydmljZXMudHJha3QuY2xpZW50IGltcG9ydCBUcmFrdENsaWVudAoKCmNsYXNzIFRyYWt0VXNlclNlcnZpY2U6CiAgICAiIiIKICAgIEZldGNoZXMgdGhlIGF1dGhlbnRpY2F0ZWQgVHJha3QgdXNlcidzIHByb2ZpbGUuCiAgICAiIiIKCiAgICBkZWYgX19pbml0X18oc2VsZiwgY2xpZW50OiBUcmFrdENsaWVudCk6CiAgICAgICAgc2VsZi5jbGllbnQgPSBjbGllbnQKCiAgICBhc3luYyBkZWYgZ2V0X3VzZXJfaW5mbyhzZWxmKSAtPiBkaWN0W3N0ciwgQW55XToKICAgICAgICAiIiJSZXR1cm4gdGhlIGF1dGhlbnRpY2F0ZWQgdXNlcidzIHByb2ZpbGUgKHVzZXJuYW1lLCBuYW1lLCBldGMuKS4iIiIKICAgICAgICB0cnk6CiAgICAgICAgICAgIGRhdGEgPSBhd2FpdCBzZWxmLmNsaWVudC5nZXQoIi91c2Vycy9tZT9leHRlbmRlZD1mdWxsIikKICAgICAgICAgICAgcmV0dXJuIGRhdGEKICAgICAgICBleGNlcHQgRXhjZXB0aW9uIGFzIGU6CiAgICAgICAgICAgIGxvZ2dlci5leGNlcHRpb24oZiJGYWlsZWQgdG8gZmV0Y2ggVHJha3QgdXNlciBpbmZvOiB7ZX0iKQogICAgICAgICAgICByYWlzZQo=" | base64 --decode > "$REPO/app/services/trakt/user.py" +echo " wrote app/services/trakt/user.py" + +mkdir -p "$REPO/app/services/trakt" +echo "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" | base64 --decode > "$REPO/app/services/trakt/library.py" +echo " wrote app/services/trakt/library.py" + +mkdir -p "$REPO/app/services/trakt" +echo "ZnJvbSBhcHAuc2VydmljZXMudHJha3QuYXV0aCBpbXBvcnQgVHJha3RBdXRoU2VydmljZQpmcm9tIGFwcC5zZXJ2aWNlcy50cmFrdC5jbGllbnQgaW1wb3J0IFRyYWt0Q2xpZW50CmZyb20gYXBwLnNlcnZpY2VzLnRyYWt0LmxpYnJhcnkgaW1wb3J0IFRyYWt0TGlicmFyeVNlcnZpY2UKZnJvbSBhcHAuc2VydmljZXMudHJha3QudXNlciBpbXBvcnQgVHJha3RVc2VyU2VydmljZQoKCmNsYXNzIFRyYWt0QnVuZGxlOgogICAgIiIiCiAgICBVbmlmaWVkIGJ1bmRsZSBmb3IgYWxsIFRyYWt0LXJlbGF0ZWQgc2VydmljZXMuCiAgICAiIiIKCiAgICBkZWYgX19pbml0X18oc2VsZiwgY2xpZW50X2lkOiBzdHIsIGNsaWVudF9zZWNyZXQ6IHN0ciwgcmVkaXJlY3RfdXJpOiBzdHIsIGFjY2Vzc190b2tlbjogc3RyIHwgTm9uZSA9IE5vbmUpOgogICAgICAgIHNlbGYuYXV0aCA9IFRyYWt0QXV0aFNlcnZpY2UoCiAgICAgICAgICAgIGNsaWVudF9pZD1jbGllbnRfaWQsCiAgICAgICAgICAgIGNsaWVudF9zZWNyZXQ9Y2xpZW50X3NlY3JldCwKICAgICAgICAgICAgcmVkaXJlY3RfdXJpPXJlZGlyZWN0X3VyaSwKICAgICAgICApCiAgICAgICAgc2VsZi5fY2xpZW50ID0gVHJha3RDbGllbnQoY2xpZW50X2lkPWNsaWVudF9pZCwgYWNjZXNzX3Rva2VuPWFjY2Vzc190b2tlbikKICAgICAgICBzZWxmLnVzZXIgPSBUcmFrdFVzZXJTZXJ2aWNlKHNlbGYuX2NsaWVudCkKICAgICAgICBzZWxmLmxpYnJhcnkgPSBUcmFrdExpYnJhcnlTZXJ2aWNlKHNlbGYuX2NsaWVudCkKCiAgICBhc3luYyBkZWYgY2xvc2Uoc2VsZik6CiAgICAgICAgYXdhaXQgc2VsZi5fY2xpZW50LmNsb3NlKCkK" | base64 --decode > "$REPO/app/services/trakt/service.py" +echo " wrote app/services/trakt/service.py" + +mkdir -p "$REPO/app/api/endpoints" +echo """"
Trakt OAuth and token-creation endpoints.

Flow:
1. GET  /tokens/trakt/config        → returns client_id + whether Trakt is configured
2. GET  /tokens/trakt/authorize     → returns the Trakt OAuth2 URL for the popup
3. GET  /tokens/trakt/callback      → Trakt redirects here after user approves;
                                       exchanges code for tokens, then posts a
                                       message to the opener window and closes.
4. POST /tokens/trakt               → Creates/updates a Watchly account using a
                                       Trakt access_token (same body shape as
                                       the main /tokens/ endpoint plus trakt_access_token).
5. POST /tokens/trakt/identity      → Lightweight identity-check (returns user info
                                       + existing settings if account exists).
"""

import secrets
from datetime import datetime, timezone
from typing import Any

from fastapi import APIRouter, HTTPException, Request
from fastapi.responses import HTMLResponse
from loguru import logger
from pydantic import BaseModel, Field

from app.core.config import settings
from app.core.security import redact_token
from app.core.settings import CatalogConfig, PosterRatingConfig, UserSettings, get_default_settings
from app.services.manifest import manifest_service
from app.services.token_store import token_store
from app.services.trakt.service import TraktBundle

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

# In-memory store for short-lived OAuth state values.
# This is per-process only; for multi-worker deployments Redis would be better,
# but CSRF protection is still improved versus nothing.
_oauth_states: dict[str, str] = {}


def _get_bundle(access_token: str | None = None) -> TraktBundle:
    client_id = settings.TRAKT_CLIENT_ID
    client_secret = settings.TRAKT_CLIENT_SECRET
    if not client_id or not client_secret:
        raise HTTPException(
            status_code=503,
            detail="Trakt integration is not configured on this server. Set TRAKT_CLIENT_ID and TRAKT_CLIENT_SECRET.",
        )
    redirect_uri = f"{settings.HOST_NAME}/tokens/trakt/callback"
    return TraktBundle(
        client_id=client_id,
        client_secret=client_secret,
        redirect_uri=redirect_uri,
        access_token=access_token,
    )


# ---------------------------------------------------------------------------
# Request / Response models
# ---------------------------------------------------------------------------


class TraktTokenRequest(BaseModel):
    trakt_access_token: str = Field(..., description="Trakt OAuth2 access token")
    trakt_refresh_token: str | None = Field(default=None, description="Trakt OAuth2 refresh token")
    trakt_expires_at: int | None = Field(default=None, description="Unix timestamp when access token expires")
    catalogs: list[CatalogConfig] | None = Field(default=None)
    language: str = Field(default="en-US")
    poster_rating: PosterRatingConfig | None = Field(default=None)
    excluded_movie_genres: list[str] = Field(default_factory=list)
    excluded_series_genres: list[str] = Field(default_factory=list)
    popularity: str = Field(default="balanced")
    year_min: int = Field(default=2010)
    year_max: int = Field(default=2025)
    sorting_order: str = Field(default="default")
    simkl_api_key: str | None = Field(default=None)
    gemini_api_key: str | None = Field(default=None)
    tmdb_api_key: str | None = Field(default=None)


class TraktTokenResponse(BaseModel):
    token: str
    manifestUrl: str
    expiresInSeconds: int | None = None


# ---------------------------------------------------------------------------
# Endpoints
# ---------------------------------------------------------------------------


@router.get("/config")
async def trakt_config():
    """Return whether Trakt is configured and the client_id (needed for the popup)."""
    configured = bool(settings.TRAKT_CLIENT_ID and settings.TRAKT_CLIENT_SECRET)
    return {
        "configured": configured,
        "client_id": settings.TRAKT_CLIENT_ID if configured else None,
    }


@router.get("/authorize")
async def trakt_authorize():
    """Return the Trakt OAuth2 authorization URL for the frontend popup."""
    bundle = _get_bundle()
    state = secrets.token_urlsafe(16)
    _oauth_states[state] = state  # minimal anti-CSRF
    url, _ = bundle.auth.get_authorize_url(state=state)
    await bundle.close()
    return {"url": url, "state": state}


@router.get("/callback", response_class=HTMLResponse)
async def trakt_callback(request: Request, code: str | None = None, state: str | None = None, error: str | None = None):
    """
    Trakt redirects here after the user approves (or denies) the app.
    We exchange the code for tokens and post a message back to the opener
    window, then close the popup.
    """
    # --- error from Trakt ---
    if error or not code:
        return HTMLResponse(_popup_close_html(success=False, error=error or "Authorization cancelled"))

    # --- verify state to prevent CSRF ---
    if not state or state not in _oauth_states:
        return HTMLResponse(_popup_close_html(success=False, error="Invalid OAuth state. Please try again."))
    del _oauth_states[state]

    # --- exchange code for tokens ---
    try:
        bundle = _get_bundle()
        token_data = await bundle.auth.exchange_code(code)
        await bundle.close()
    except Exception as exc:
        logger.error(f"Trakt callback: token exchange failed: {exc}")
        return HTMLResponse(_popup_close_html(success=False, error="Token exchange failed"))

    access_token = token_data.get("access_token")
    refresh_token = token_data.get("refresh_token")
    expires_in = token_data.get("expires_in", 7776000)  # default 90 days

    if not access_token:
        return HTMLResponse(_popup_close_html(success=False, error="No access token received"))

    # Calculate expiry unix timestamp
    import time
    expires_at = int(time.time()) + expires_in

    return HTMLResponse(
        _popup_close_html(
            success=True,
            access_token=access_token,
            refresh_token=refresh_token,
            expires_at=expires_at,
        )
    )


@router.post("/identity", status_code=200)
async def trakt_identity(payload: TraktTokenRequest):
    """
    Validate the Trakt access token, return user info and existing settings.
    """
    bundle = _get_bundle(access_token=payload.trakt_access_token)
    try:
        user_info = await bundle.user.get_user_info()
    except Exception as exc:
        raise HTTPException(status_code=400, detail=f"Invalid Trakt access token: {exc}") from exc
    finally:
        await bundle.close()

    username = user_info.get("username") or user_info.get("name") or "trakt_user"
    # Use a Trakt-namespaced user_id so it can't clash with Stremio IDs
    user_id = f"trakt:{username}"

    token = token_store.get_token_from_user_id(user_id)
    user_data = await token_store.get_user_data(token)
    exists = bool(user_data)

    response: dict[str, Any] = {
        "user_id": user_id,
        "username": username,
        "display": user_info.get("name") or username,
        "exists": exists,
    }
    if exists and user_data:
        raw_settings = user_data.get("settings", {})
        try:
            user_settings = UserSettings(**raw_settings)
            response["settings"] = user_settings.model_dump()
        except Exception as e:
            logger.warning(f"Failed to normalise settings for {user_id}: {e}")
            response["settings"] = raw_settings

    return response


@router.post("/", response_model=TraktTokenResponse)
async def create_trakt_token(payload: TraktTokenRequest, request: Request):
    """
    Create or update a Watchly account backed by a Trakt access token.
    The library is fetched from Trakt; everything else behaves like the
    Stremio-based token endpoint.
    """
    bundle = _get_bundle(access_token=payload.trakt_access_token)

    try:
        user_info = await bundle.user.get_user_info()
    except Exception as exc:
        await bundle.close()
        raise HTTPException(status_code=400, detail=f"Invalid Trakt access token: {exc}") from exc

    username = user_info.get("username") or user_info.get("name") or "trakt_user"
    user_id = f"trakt:{username}"

    token = token_store.get_token_from_user_id(user_id)
    existing_data = await token_store.get_user_data(token)

    default_settings = get_default_settings()
    user_settings = UserSettings(
        language=payload.language or default_settings.language,
        catalogs=payload.catalogs if payload.catalogs else default_settings.catalogs,
        poster_rating=payload.poster_rating,
        excluded_movie_genres=payload.excluded_movie_genres,
        excluded_series_genres=payload.excluded_series_genres,
        year_min=payload.year_min,
        year_max=payload.year_max,
        popularity=payload.popularity,
        sorting_order=payload.sorting_order,
        simkl_api_key=payload.simkl_api_key,
        gemini_api_key=payload.gemini_api_key,
        tmdb_api_key=payload.tmdb_api_key,
    )

    payload_to_store: dict[str, Any] = {
        "auth_provider": "trakt",
        # authKey stores the Trakt access token (encrypted by token_store)
        "authKey": payload.trakt_access_token,
        "trakt_refresh_token": payload.trakt_refresh_token,
        "trakt_expires_at": payload.trakt_expires_at,
        "trakt_username": username,
        "email": user_info.get("name") or username,
        "settings": user_settings.model_dump(),
        "last_updated": existing_data.get("last_updated") if existing_data else datetime.now(timezone.utc).isoformat(),
    }

    token = await token_store.store_user_data(user_id, payload_to_store)
    account_status = "updated" if existing_data else "created"
    logger.info(f"[{redact_token(token)}] Trakt account {account_status} for user {user_id}")

    # Pre-cache library using Trakt data
    try:
        library_items = await bundle.library.get_library_items()
        # Use the shared manifest caching pathway, passing library_items directly
        await manifest_service.cache_library_and_profiles_from_items(library_items, user_settings, token)
        logger.info(f"[{redact_token(token)}] Trakt library cached ({len(library_items.get('watched', []))} items)")
    except Exception as exc:
        logger.warning(f"[{redact_token(token)}] Failed to pre-cache Trakt library: {exc}. Will cache on demand.")
    finally:
        await bundle.close()

    base_url = settings.HOST_NAME
    manifest_url = f"{base_url}/{token}/manifest.json"
    expires_in = settings.TOKEN_TTL_SECONDS if settings.TOKEN_TTL_SECONDS > 0 else None

    return TraktTokenResponse(token=token, manifestUrl=manifest_url, expiresInSeconds=expires_in)


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _popup_close_html(
    success: bool,
    error: str | None = None,
    access_token: str | None = None,
    refresh_token: str | None = None,
    expires_at: int | None = None,
) -> str:
    """
    Minimal HTML page that posts a message to the opener and closes itself.
    The frontend listens for this message via window.addEventListener('message', ...).
    """
    if success:
        payload_js = (
            f"{{ type: 'trakt_auth_success', "
            f"access_token: {_js_str(access_token)}, "
            f"refresh_token: {_js_str(refresh_token)}, "
            f"expires_at: {expires_at or 'null'} }}"
        )
    else:
        payload_js = f"{{ type: 'trakt_auth_error', error: {_js_str(error or 'Unknown error')} }}"

    return f"""<!DOCTYPE html>
<html>
<head><title>Trakt Authorization</title></head>
<body>
<p style="font-family:sans-serif;text-align:center;margin-top:3rem">
  {'Authorization successful! You can close this window.' if success else f'Authorization failed: {error}'}
</p>
<script>
  try {{
    if (window.opener) {{
      window.opener.postMessage({payload_js}, window.location.origin);
    }}
  }} catch(e) {{}}
  setTimeout(function() {{ window.close(); }}, 1000);
</script>
</body>
</html>"""


def _js_str(value: str | None) -> str:
    if value is None:
        return "null"
    escaped = value.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
    return f'"{escaped}"'
" | base64 --decode > "$REPO/app/api/endpoints/trakt.py" +echo " wrote app/api/endpoints/trakt.py" + +mkdir -p "$REPO/app/api/endpoints" +echo "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" | base64 --decode > "$REPO/app/api/endpoints/catalogs.py" +echo " wrote app/api/endpoints/catalogs.py" + +mkdir -p "$REPO/app/static/js/modules" +echo "// Trakt Authentication Module

import { showToast } from './ui.js';
import { switchSection, unlockNavigation } from './navigation.js';

// LocalStorage keys for Trakt
const TRAKT_STORAGE_KEY = 'watchly_trakt_auth';
const EXPIRY_DAYS = 85; // Trakt tokens last 90 days; refresh a bit early

let languageSelect = null;
let getCatalogs = null;
let renderCatalogList = null;
let resetApp = null;

// --------------------------------------------------------------------------
// Public API
// --------------------------------------------------------------------------

export function initializeTrakt(domElements, catalogState) {
    languageSelect = domElements.languageSelect;
    getCatalogs = catalogState.getCatalogs;
    renderCatalogList = catalogState.renderCatalogList;
    resetApp = catalogState.resetApp;

    initializeTraktConnectButton();
    initializeTraktLogoutButton();
    attemptTraktAutoLogin();
}

export function setTraktLoggedOutState() {
    clearTraktFromStorage();
    hideTraktStatus();

    const traktConnectBtn = document.getElementById('traktConnectBtn');
    if (traktConnectBtn) {
        traktConnectBtn.classList.remove('hidden');
    }
}

// --------------------------------------------------------------------------
// Storage helpers
// --------------------------------------------------------------------------

function saveTraktToStorage(authData) {
    try {
        const expiryDate = new Date();
        expiryDate.setDate(expiryDate.getDate() + EXPIRY_DAYS);
        localStorage.setItem(TRAKT_STORAGE_KEY, JSON.stringify({ ...authData, expiresAt: expiryDate.getTime() }));
    } catch (e) {
        console.warn('Failed to save Trakt auth:', e);
    }
}

function getTraktFromStorage() {
    try {
        const stored = localStorage.getItem(TRAKT_STORAGE_KEY);
        if (!stored) return null;
        const data = JSON.parse(stored);
        if (data.expiresAt && data.expiresAt < Date.now()) {
            clearTraktFromStorage();
            return null;
        }
        return data;
    } catch (e) {
        clearTraktFromStorage();
        return null;
    }
}

function clearTraktFromStorage() {
    try { localStorage.removeItem(TRAKT_STORAGE_KEY); } catch (e) { /* noop */ }
}

// --------------------------------------------------------------------------
// OAuth popup flow
// --------------------------------------------------------------------------

function initializeTraktConnectButton() {
    const btn = document.getElementById('traktConnectBtn');
    if (!btn) return;

    btn.addEventListener('click', async () => {
        setTraktConnecting(true);
        try {
            // 1. Fetch the authorization URL from backend
            const res = await fetch('/tokens/trakt/authorize');
            if (!res.ok) {
                const err = await res.json().catch(() => ({}));
                throw new Error(err.detail || 'Failed to start Trakt authorization');
            }
            const { url } = await res.json();

            // 2. Open OAuth popup
            const tokens = await openTraktPopup(url);

            // 3. Call identity check to get user info + existing settings
            await fetchTraktIdentity(tokens);

            // 4. Save to storage
            saveTraktToStorage(tokens);

            unlockNavigation();
            switchSection('config');
        } catch (err) {
            showToast(err.message || 'Trakt login failed', 'error');
        } finally {
            setTraktConnecting(false);
        }
    });
}

function initializeTraktLogoutButton() {
    const btn = document.getElementById('traktLogoutBtn');
    if (!btn) return;
    btn.addEventListener('click', () => {
        if (resetApp) resetApp();
    });
}

/**
 * Open a popup window for Trakt OAuth and resolve when the callback page
 * posts a message back to us.
 */
function openTraktPopup(url) {
    return new Promise((resolve, reject) => {
        const width = 600;
        const height = 700;
        const left = Math.round(window.screenX + (window.outerWidth - width) / 2);
        const top = Math.round(window.screenY + (window.outerHeight - height) / 2);

        const popup = window.open(
            url,
            'trakt_oauth',
            `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes`
        );

        if (!popup) {
            reject(new Error('Could not open the authorization popup. Please allow popups for this site.'));
            return;
        }

        let settled = false;

        function onMessage(event) {
            // Only accept messages from our own origin
            if (event.origin !== window.location.origin) return;
            const data = event.data;
            if (!data || typeof data !== 'object') return;

            if (data.type === 'trakt_auth_success') {
                if (!settled) {
                    settled = true;
                    cleanup();
                    resolve({
                        access_token: data.access_token,
                        refresh_token: data.refresh_token,
                        expires_at: data.expires_at,
                    });
                }
            } else if (data.type === 'trakt_auth_error') {
                if (!settled) {
                    settled = true;
                    cleanup();
                    reject(new Error(data.error || 'Trakt authorization failed'));
                }
            }
        }

        // Also detect if the user closes the popup manually
        const pollTimer = setInterval(() => {
            if (popup.closed && !settled) {
                settled = true;
                cleanup();
                reject(new Error('Authorization window was closed'));
            }
        }, 500);

        function cleanup() {
            window.removeEventListener('message', onMessage);
            clearInterval(pollTimer);
        }

        window.addEventListener('message', onMessage);
    });
}

// --------------------------------------------------------------------------
// Identity fetch + settings population
// --------------------------------------------------------------------------

async function fetchTraktIdentity(tokens) {
    const payload = {
        trakt_access_token: tokens.access_token,
        trakt_refresh_token: tokens.refresh_token || null,
        trakt_expires_at: tokens.expires_at || null,
    };

    const res = await fetch('/tokens/trakt/identity', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(payload),
    });

    if (!res.ok) {
        const err = await res.json().catch(() => ({}));
        throw new Error(err.detail || 'Failed to verify Trakt identity');
    }

    const data = await res.json();
    const display = data.display || data.username || 'Trakt User';

    showTraktStatus(display);

    if (data.exists && data.settings) {
        showToast(`Welcome back, ${display}! Loading your settings…`, 'info', 5000);
        populateSettings(data.settings);

        const installHeader = document.querySelector('#sect-install h2');
        const installDesc = document.querySelector('#sect-install p');
        if (installHeader) installHeader.textContent = 'Update Settings';
        if (installDesc) installDesc.textContent = 'Update your preferences and re-install.';

        const btnText = document.querySelector('#submitBtn .btn-text');
        if (btnText) btnText.textContent = 'Update & Re-Install';
    } else {
        showToast(`Welcome, ${display}! Setting up your account…`, 'success', 5000);
    }

    // Store display name so the form submit can use it
    const traktDisplayInput = document.getElementById('traktDisplayName');
    if (traktDisplayInput) traktDisplayInput.value = display;
}

function populateSettings(s) {
    if (s.language && languageSelect) languageSelect.value = s.language;

    const popularitySelect = document.getElementById('popularitySelect');
    const yearMinInput = document.getElementById('yearMin');
    const yearMaxInput = document.getElementById('yearMax');
    const sortingOrderSelect = document.getElementById('sortingOrderSelect');

    if (s.popularity && popularitySelect) popularitySelect.value = s.popularity;
    if (s.year_min && yearMinInput) yearMinInput.value = s.year_min;
    if (s.year_max && yearMaxInput) yearMaxInput.value = s.year_max;
    if (window.updateYearSlider) window.updateYearSlider();
    if (s.sorting_order && sortingOrderSelect) sortingOrderSelect.value = s.sorting_order;

    const posterRatingProvider = document.getElementById('posterRatingProvider');
    const posterRatingApiKey = document.getElementById('posterRatingApiKey');
    if (posterRatingProvider && posterRatingApiKey && s.poster_rating?.provider && s.poster_rating?.api_key) {
        posterRatingProvider.value = s.poster_rating.provider;
        posterRatingApiKey.value = s.poster_rating.api_key;
        posterRatingProvider.dispatchEvent(new Event('change'));
    }

    const tmdbApiKeyInput = document.getElementById('tmdbApiKey');
    if (s.tmdb_api_key && tmdbApiKeyInput) tmdbApiKeyInput.value = s.tmdb_api_key;

    const simklApiKeyInput = document.getElementById('simklApiKey');
    if (s.simkl_api_key && simklApiKeyInput) simklApiKeyInput.value = s.simkl_api_key;

    const geminiApiKeyInput = document.getElementById('geminiApiKey');
    if (s.gemini_api_key && geminiApiKeyInput) geminiApiKeyInput.value = s.gemini_api_key;

    // Genres
    document.querySelectorAll('input[name="movie-genre"]').forEach(cb => cb.checked = false);
    document.querySelectorAll('input[name="series-genre"]').forEach(cb => cb.checked = false);
    if (s.excluded_movie_genres) s.excluded_movie_genres.forEach(id => {
        const cb = document.querySelector(`input[name="movie-genre"][value="${id}"]`);
        if (cb) cb.checked = true;
    });
    if (s.excluded_series_genres) s.excluded_series_genres.forEach(id => {
        const cb = document.querySelector(`input[name="series-genre"][value="${id}"]`);
        if (cb) cb.checked = true;
    });

    // Catalogs
    if (s.catalogs && Array.isArray(s.catalogs)) {
        const catalogs = getCatalogs ? getCatalogs() : [];
        s.catalogs.forEach(remote => {
            const local = catalogs.find(c => c.id === remote.id);
            if (local) {
                local.enabled = remote.enabled;
                if (remote.name) local.name = remote.name;
                if (typeof remote.enabled_movie === 'boolean') local.enabledMovie = remote.enabled_movie;
                if (typeof remote.enabled_series === 'boolean') local.enabledSeries = remote.enabled_series;
                if (typeof remote.display_at_home === 'boolean') local.display_at_home = remote.display_at_home;
                if (typeof remote.shuffle === 'boolean') local.shuffle = remote.shuffle;
            }
        });
        if (renderCatalogList) renderCatalogList();
    }
}

// --------------------------------------------------------------------------
// Auto-login
// --------------------------------------------------------------------------

async function attemptTraktAutoLogin() {
    const stored = getTraktFromStorage();
    if (!stored?.access_token) return;

    try {
        await fetchTraktIdentity(stored);
        unlockNavigation();
        switchSection('config');
    } catch (err) {
        console.warn('Trakt auto-login failed:', err);
        clearTraktFromStorage();
    }
}

// --------------------------------------------------------------------------
// UI helpers
// --------------------------------------------------------------------------

function setTraktConnecting(loading) {
    const btn = document.getElementById('traktConnectBtn');
    if (!btn) return;
    const text = btn.querySelector('.btn-text');
    const loader = btn.querySelector('.loader');
    btn.disabled = loading;
    if (text) text.classList.toggle('hidden', loading);
    if (loader) loader.classList.toggle('hidden', !loading);
}

export function showTraktStatus(displayName) {
    const statusSection = document.getElementById('traktStatusSection');
    const displayEl = document.getElementById('traktStatusDisplay');
    const avatarEl = document.getElementById('traktStatusAvatar');
    const connectBtn = document.getElementById('traktConnectBtn');

    if (displayEl) displayEl.textContent = displayName;
    if (avatarEl) avatarEl.textContent = getInitials(displayName);
    if (statusSection) statusSection.classList.remove('hidden');
    if (connectBtn) connectBtn.classList.add('hidden');

    // Sidebar profile
    const userProfileWrapper = document.getElementById('user-profile-dropdown-wrapper');
    const userEmail = document.getElementById('user-email');
    const userAvatar = document.getElementById('user-avatar');
    const loginFormCard = document.getElementById('loginFormCard');

    if (userEmail) userEmail.textContent = displayName;
    if (userAvatar) userAvatar.textContent = getInitials(displayName);
    if (userProfileWrapper) userProfileWrapper.classList.remove('hidden');
    // Keep loginFormCard visible so users can navigate back and see the Trakt tab
    // Instead, switch to Trakt tab so it's clear which provider is active
    try {
        const saved = localStorage.getItem('watchly_login_tab');
        if (!saved || saved === 'trakt') {
            const traktTab = document.getElementById('tabTrakt');
            if (traktTab) traktTab.click();
        }
    } catch(e) {}
}

function hideTraktStatus() {
    const statusSection = document.getElementById('traktStatusSection');
    const connectBtn = document.getElementById('traktConnectBtn');
    if (statusSection) statusSection.classList.add('hidden');
    if (connectBtn) connectBtn.classList.remove('hidden');

    const userProfileWrapper = document.getElementById('user-profile-dropdown-wrapper');
    if (userProfileWrapper) userProfileWrapper.classList.add('hidden');
}

function getInitials(name) {
    if (!name) return '?';
    const parts = name.trim().split(/[\s._-]+/);
    if (parts.length >= 2) return (parts[0][0] + parts[1][0]).toUpperCase();
    return name.substring(0, 2).toUpperCase();
}

// --------------------------------------------------------------------------
// Exported helpers for form.js
// --------------------------------------------------------------------------

export function getTraktTokensFromStorage() {
    return getTraktFromStorage();
}
" | base64 --decode > "$REPO/app/static/js/modules/trakt.js" +echo " wrote app/static/js/modules/trakt.js" + +mkdir -p "$REPO/app/templates/components" +echo "<!-- SECTION 1: LOGIN -->
<section id="sect-login" class="space-y-6 hidden animate-fade-in">
    <div class="mb-8">
        <h2 class="text-3xl font-bold text-white mb-2">Connect Your Library</h2>
        <p class="text-slate-400">Log in with Stremio or Trakt so Watchly can read your watch history.</p>
    </div>

    <!-- Logged In Status (shown after login - shared across both providers) -->
    <div id="loginStatusSection" class="hidden bg-neutral-900/60 border border-white/10 rounded-2xl p-6 md:p-8 backdrop-blur-sm shadow-xl shadow-black/20">
        <div class="flex items-center justify-between gap-4">
            <div class="flex items-center gap-3 flex-grow min-w-0">
                <div class="w-10 h-10 rounded-full bg-white text-black ring-1 ring-white/10 flex items-center justify-center font-bold text-sm flex-shrink-0"
                    id="loginStatusAvatar">
                </div>
                <div class="flex-grow min-w-0">
                    <div class="text-xs text-slate-500 mb-0.5">Logged in as</div>
                    <div class="text-sm text-white font-medium truncate" id="loginStatusEmail"></div>
                </div>
            </div>
            <button type="button" id="loginStatusLogoutBtn"
                class="flex-shrink-0 bg-red-600 hover:bg-red-700 text-white font-medium py-2.5 px-4 rounded-xl transition border border-red-700 shadow-lg shadow-red-900/20 flex items-center justify-center gap-2">
                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                        d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1">
                    </path>
                </svg>
                <span>Logout</span>
            </button>
        </div>
    </div>

    <div id="loginFormCard" class="bg-neutral-900/60 border border-white/10 rounded-2xl p-6 md:p-8 backdrop-blur-sm shadow-xl shadow-black/20">

        <!-- Provider Tabs -->
        <div class="flex gap-1 mb-6 bg-neutral-800/60 p-1 rounded-xl">
            <button type="button" id="tabStremio"
                class="login-tab flex-1 py-2.5 px-4 rounded-lg text-sm font-medium transition-all bg-white text-black shadow"
                data-tab="stremio">
                <span class="flex items-center justify-center gap-2">
                    <img src="https://stremio.com/website/stremio-logo-small.png" class="w-4 h-4" alt="">
                    Stremio
                </span>
            </button>
            <button type="button" id="tabTrakt"
                class="login-tab flex-1 py-2.5 px-4 rounded-lg text-sm font-medium transition-all text-slate-400 hover:text-white"
                data-tab="trakt">
                <span class="flex items-center justify-center gap-2">
                    <!-- Trakt icon (simple "t" badge) -->
                    <svg class="w-4 h-4" viewBox="0 0 24 24" fill="currentColor">
                        <path d="M12 2C6.477 2 2 6.477 2 12s4.477 10 10 10 10-4.477 10-10S17.523 2 12 2zm-.5 5h1.5v6h3v1.5h-4.5V7z"/>
                    </svg>
                    Trakt
                </span>
            </button>
        </div>

        <!-- ===== STREMIO PANEL ===== -->
        <div id="panelStremio">
            <button type="button" id="stremioLoginBtn"
                class="w-full bg-stremio text-white font-medium py-4 rounded-xl transition flex items-center justify-center gap-3 border border-stremio-border shadow-lg shadow-stremio/20 group hover:bg-white hover:text-black hover:border-white/10">
                <img src="https://stremio.com/website/stremio-logo-small.png"
                    class="w-6 h-6 group-hover:scale-110 transition-transform" alt="Stremio">
                <span id="stremioLoginText" class="text-lg">Login with Stremio</span>
            </button>

            <input type="hidden" id="authKey">

            <!-- Divider -->
            <div id="emailPwdDivider" class="flex items-center gap-3 my-6">
                <div class="h-px bg-white/10 w-full"></div>
                <div class="text-xs text-slate-500">or</div>
                <div class="h-px bg-white/10 w-full"></div>
            </div>

            <!-- Email/Password Login -->
            <div id="emailPwdSection" class="grid gap-3">
                <label class="text-xs text-slate-400">Email</label>
                <input id="emailInput" type="email" autocomplete="email" inputmode="email"
                    spellcheck="false" required placeholder="you@example.com"
                    class="w-full bg-neutral-900 border border-slate-700 rounded-xl px-4 py-3.5 text-white placeholder-slate-500 focus:ring-2 focus:ring-white/20 focus:border-white/30 outline-none transition-all">
                <label class="text-xs text-slate-400">Password</label>
                <div class="relative">
                    <input id="passwordInput" type="password" autocomplete="current-password"
                        placeholder="Your Stremio password"
                        class="w-full bg-neutral-900 border border-slate-700 rounded-xl pl-4 pr-12 py-3.5 text-white placeholder-slate-500 focus:ring-2 focus:ring-white/20 focus:border-white/30 outline-none transition-all">
                    <button type="button"
                        class="toggle-btn absolute right-2 top-1/2 -translate-y-1/2 bg-white/10 hover:bg-white/20 text-white p-2 rounded-lg"
                        aria-label="Show password" title="Show" data-target="passwordInput">
                        <svg class="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor"
                            stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
                            <path d="M1 12s4-7 11-7 11 7 11 7-4 7-11 7-11-7-11-7z" />
                            <circle cx="12" cy="12" r="3" />
                        </svg>
                    </button>
                </div>
                <button type="button" id="emailPwdContinueBtn"
                    class="mt-2 w-full bg-white text-black hover:bg-white/90 font-medium py-3 rounded-xl transition border border-white/10 flex items-center justify-center gap-2">
                    <span class="btn-text">Continue with Email</span>
                    <div class="loader hidden w-5 h-5 border-2 border-black/30 border-t-black rounded-full animate-spin">
                    </div>
                </button>
            </div>

            <!-- Inline error for email/password login -->
            <div id="emailPwdError" class="hidden mt-3 p-3 bg-red-500/10 border border-red-500/20 rounded-xl text-red-200 text-sm">
            </div>

            <!-- Disclaimer -->
            <div id="emailPwdDisclaimer"
                class="mt-4 text-xs leading-relaxed bg-yellow-500/10 border border-yellow-500/30 text-yellow-200 rounded-xl p-3">
                <strong class="text-yellow-300">Why email &amp; password?</strong>
                <span class="block mt-1">We store your credentials securely to generate a fresh Stremio auth
                    key automatically when needed. This avoids expired keys and keeps your addon working
                    without manual re-login.</span>
                <span class="block mt-2">Prefer not to share your password? Use the Stremio login above to
                    supply an auth key. Note: auth keys can expire and may require periodic
                    re-authentication.</span>
            </div>
        </div>
        <!-- end #panelStremio -->

        <!-- ===== TRAKT PANEL ===== -->
        <div id="panelTrakt" class="hidden">

            <!-- Logged-in state -->
            <div id="traktStatusSection" class="hidden mb-4">
                <div class="flex items-center justify-between gap-4 p-4 bg-neutral-800/60 rounded-xl border border-white/10">
                    <div class="flex items-center gap-3 flex-grow min-w-0">
                        <div class="w-10 h-10 rounded-full bg-[#ed1c24] text-white ring-1 ring-white/10 flex items-center justify-center font-bold text-sm flex-shrink-0"
                            id="traktStatusAvatar">T</div>
                        <div class="flex-grow min-w-0">
                            <div class="text-xs text-slate-500 mb-0.5">Connected as</div>
                            <div class="text-sm text-white font-medium truncate" id="traktStatusDisplay"></div>
                        </div>
                    </div>
                    <button type="button" id="traktLogoutBtn"
                        class="flex-shrink-0 bg-red-600 hover:bg-red-700 text-white font-medium py-2 px-3 rounded-xl transition border border-red-700 text-sm">
                        Disconnect
                    </button>
                </div>
            </div>

            <!-- Connect button -->
            <button type="button" id="traktConnectBtn"
                class="w-full bg-[#ed1c24] hover:bg-[#c41019] text-white font-medium py-4 rounded-xl transition flex items-center justify-center gap-3 border border-[#b00e15] shadow-lg shadow-red-900/20">
                <!-- Trakt "T" logo as simple SVG -->
                <svg class="w-6 h-6 flex-shrink-0" viewBox="0 0 32 32" fill="none" xmlns="http://www.w3.org/2000/svg">
                    <circle cx="16" cy="16" r="16" fill="white"/>
                    <text x="16" y="22" text-anchor="middle" font-size="18" font-weight="bold" fill="#ed1c24" font-family="sans-serif">t</text>
                </svg>
                <span class="btn-text text-lg">Connect with Trakt</span>
                <div class="loader hidden w-5 h-5 border-2 border-white/30 border-t-white rounded-full animate-spin"></div>
            </button>

            <!-- Hidden field to carry Trakt display name through to form submission -->
            <input type="hidden" id="traktDisplayName">

            <div class="mt-4 text-xs leading-relaxed bg-blue-500/10 border border-blue-500/30 text-blue-200 rounded-xl p-3">
                <strong class="text-blue-300">How it works</strong>
                <span class="block mt-1">Clicking "Connect with Trakt" opens a secure Trakt authorization
                    window. After you approve access, Watchly uses your Trakt watch history to generate
                    recommendations — no Stremio account needed.</span>
                <span class="block mt-2">Your Trakt access token is stored encrypted on the server and
                    is never shared or exposed in URLs.</span>
            </div>
        </div>
        <!-- end #panelTrakt -->

    </div>
    <!-- end #loginFormCard -->
</section>

<script>
// Tab switching logic (inline to avoid module-loading order issues)
(function () {
    function switchLoginTab(tab) {
        const tabs = document.querySelectorAll('.login-tab');
        const panelStremio = document.getElementById('panelStremio');
        const panelTrakt = document.getElementById('panelTrakt');

        tabs.forEach(t => {
            const active = t.dataset.tab === tab;
            t.classList.toggle('bg-white', active);
            t.classList.toggle('text-black', active);
            t.classList.toggle('shadow', active);
            t.classList.toggle('text-slate-400', !active);
            t.classList.toggle('hover:text-white', !active);
        });

        if (panelStremio) panelStremio.classList.toggle('hidden', tab !== 'stremio');
        if (panelTrakt) panelTrakt.classList.toggle('hidden', tab !== 'trakt');

        // Persist choice
        try { localStorage.setItem('watchly_login_tab', tab); } catch (e) { }
    }

    document.addEventListener('DOMContentLoaded', function () {
        document.querySelectorAll('.login-tab').forEach(btn => {
            btn.addEventListener('click', () => switchLoginTab(btn.dataset.tab));
        });

        // Restore last tab
        try {
            const saved = localStorage.getItem('watchly_login_tab');
            if (saved === 'trakt') switchLoginTab('trakt');
        } catch (e) { }
    });
})();
</script>

<script>
// Hide the Trakt tab if Trakt is not configured on this server
(function () {
    fetch('/tokens/trakt/config')
        .then(r => r.json())
        .then(data => {
            if (!data.configured) {
                const traktTab = document.getElementById('tabTrakt');
                if (traktTab) traktTab.style.display = 'none';
            }
        })
        .catch(() => {
            // If the endpoint fails (unlikely), leave tabs as-is
        });
})();
</script>

" | base64 --decode > "$REPO/app/templates/components/section_login.html" +echo " wrote app/templates/components/section_login.html" + +mkdir -p "$REPO/app/templates/components" +echo "<!-- Mobile Header -->
<div id="mobileHeader"
    class="md:hidden fixed top-0 left-0 right-0 z-50 px-4 py-3 bg-neutral-950 border-b border-slate-800 flex items-center gap-4">
    <button id="mobileNavToggle" aria-label="Open navigation" aria-expanded="false"
        class="hamburger p-2 rounded-md hover:bg-neutral-800/50">
        <span class="bar top"></span>
        <span class="bar middle"></span>
        <span class="bar bottom"></span>
    </button>
    <img src="/app/static/logo.png" alt="Watchly" class="w-8 h-8 rounded-lg ring-1 ring-white/15 bg-black">
    <h1 class="font-bold text-xl text-white">Watchly</h1>
</div>

<!-- Mobile Nav Backdrop -->
<div id="mobileNavBackdrop" class="fixed inset-0 bg-black/50 z-30 hidden md:hidden"></div>

<!-- Sidebar Navigation -->
<aside id="mainSidebar"
    class="fixed inset-y-0 left-0 z-40 w-72 transform -translate-x-full transition-transform duration-300 ease-out bg-neutral-950/50 backdrop-blur-xl border-b md:border-b-0 md:border-r border-slate-800 flex flex-col flex-shrink-0 md:translate-x-0 pt-[env(safe-area-inset-top)] pb-[env(safe-area-inset-bottom)]">
    <div class="p-6 md:p-8 flex-col items-start gap-4 hidden md:flex">
        <div class="flex items-center gap-3">
            <img src="/app/static/logo.png" alt="Watchly"
                class="w-10 h-10 rounded-xl shadow-lg shadow-white/10 ring-1 ring-white/10 bg-black">
            <h1 class="font-bold text-2xl text-transparent bg-clip-text bg-gradient-to-r from-white to-slate-300">
                Watchly</h1>
        </div>
    </div>

    <!-- User Profile Dropdown (Hidden by default, shown after login) -->
    <div id="user-profile-dropdown-wrapper" class="hidden px-4 md:px-6 pt-4 pb-2">
        <div class="relative">
            <button id="user-profile-trigger" type="button"
                class="w-full flex items-center gap-3 p-3 bg-neutral-800/50 border border-slate-700/50 rounded-xl hover:bg-neutral-800/70 transition-all group">
                <div class="w-10 h-10 rounded-full bg-white text-black ring-1 ring-white/10 flex items-center justify-center font-bold text-sm flex-shrink-0"
                    id="user-avatar">
                    <!-- Avatar initials will be generated from email -->
                </div>
                <div class="flex-grow min-w-0 text-left">
                    <div class="text-xs text-slate-500 mb-0.5">Logged in as</div>
                    <div class="text-sm text-white font-medium truncate" id="user-email">
                        <!-- Email will be inserted here -->
                    </div>
                </div>
                <svg class="w-4 h-4 text-slate-400 group-hover:text-white transition-colors flex-shrink-0" fill="none"
                    stroke="currentColor" viewBox="0 0 24 24" id="user-profile-chevron" style="transition: transform 200ms ease;">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M19 9l-7 7-7-7"></path>
                </svg>
            </button>

            <!-- Dropdown Menu -->
            <div id="user-profile-dropdown" class="hidden absolute top-full left-0 right-0 mt-2 bg-neutral-900 border border-slate-700/50 rounded-xl shadow-xl overflow-hidden z-50">
                <button type="button" id="user-profile-logout-btn"
                    class="w-full flex items-center gap-3 px-4 py-3 text-sm font-medium text-red-400 hover:bg-red-500/10 transition-colors text-left">
                    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                            d="M17 16l4-4m0 0l-4-4m4 4H7m6 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h4a3 3 0 013 3v1">
                        </path>
                    </svg>
                    <span>Logout</span>
                </button>
            </div>
        </div>
    </div>

    <nav
        class="flex-grow px-4 md:px-6 py-4 space-y-1 md:overflow-visible flex flex-col md:block whitespace-normal gap-2">

        <button id="nav-welcome"
            class="nav-item group w-full flex items-center gap-3 px-4 py-3 text-sm font-medium rounded-xl transition-all text-slate-400 hover:text-white hover:bg-neutral-800/50 active text-left">
            <div
                class="w-8 h-8 rounded-lg bg-blue-500/10 text-blue-400 flex items-center justify-center border border-blue-400/20 flex-shrink-0 transition-all group-hover:scale-105 group-hover:bg-blue-500/15 group-hover:border-blue-400/30 group-hover:shadow-lg group-hover:shadow-blue-900/10">
                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                        d="M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6">
                    </path>
                </svg>
            </div>
            <span>Get Started</span>
        </button>

        <button id="nav-login"
            class="nav-item group w-full flex items-center gap-3 px-4 py-3 text-sm font-medium rounded-xl transition-all text-slate-400 hover:text-white hover:bg-neutral-800/50 text-left disabled">
            <div
                class="w-8 h-8 rounded-lg bg-cyan-500/10 text-cyan-400 flex items-center justify-center border border-cyan-400/20 flex-shrink-0 transition-all group-hover:scale-105 group-hover:bg-cyan-500/15 group-hover:border-cyan-400/30 group-hover:shadow-lg group-hover:shadow-cyan-900/10">
                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                        d="M11 16l-4-4m0 0l4-4m-4 4h14m-5 4v1a3 3 0 01-3 3H6a3 3 0 01-3-3V7a3 3 0 013-3h7a3 3 0 013 3v1">
                    </path>
                </svg>
            </div>
            <span>Connect Library</span>
        </button>

        <button id="nav-config"
            class="nav-item group w-full flex items-center gap-3 px-4 py-3 text-sm font-medium rounded-xl transition-all text-slate-400 hover:text-white hover:bg-neutral-800/50 text-left disabled">
            <div
                class="w-8 h-8 rounded-lg bg-purple-500/10 text-purple-400 flex items-center justify-center border border-purple-400/20 flex-shrink-0 transition-all group-hover:scale-105 group-hover:bg-purple-500/15 group-hover:border-purple-400/30 group-hover:shadow-lg group-hover:shadow-purple-900/10">
                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                        d="M12 6V4m0 2a2 2 0 100 4m0-4a2 2 0 110 4m-6 8a2 2 0 100-4m0 4a2 2 0 110-4m0 4v2m0-6V4m6 6v10m6-2a2 2 0 100-4m0 4a2 2 0 110-4m0 4v2m0-6V4">
                    </path>
                </svg>
            </div>
            <span>Configure Options</span>
        </button>

        <button id="nav-catalogs"
            class="nav-item group w-full flex items-center gap-3 px-4 py-3 text-sm font-medium rounded-xl transition-all text-slate-400 hover:text-white hover:bg-neutral-800/50 text-left disabled">
            <div
                class="w-8 h-8 rounded-lg bg-orange-500/10 text-orange-400 flex items-center justify-center border border-orange-400/20 flex-shrink-0 transition-all group-hover:scale-105 group-hover:bg-orange-500/15 group-hover:border-orange-400/30 group-hover:shadow-lg group-hover:shadow-orange-900/10">
                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                        d="M4 6h16M4 10h16M4 14h16M4 18h16">
                    </path>
                </svg>
            </div>
            <span>Catalogs</span>
        </button>

        <button id="nav-install"
            class="nav-item group w-full flex items-center gap-3 px-4 py-3 text-sm font-medium rounded-xl transition-all text-slate-400 hover:text-white hover:bg-neutral-800/50 text-left disabled">
            <div
                class="w-8 h-8 rounded-lg bg-green-500/10 text-green-400 flex items-center justify-center border border-green-400/20 flex-shrink-0 transition-all group-hover:scale-105 group-hover:bg-green-500/15 group-hover:border-green-400/30 group-hover:shadow-lg group-hover:shadow-green-900/10">
                <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2"
                        d="M8 7H5a2 2 0 00-2 2v9a2 2 0 002 2h14a2 2 0 002-2V9a2 2 0 00-2-2h-3m-1 4l-3 3m0 0l-3-3m3 3V4">
                    </path>
                </svg>
            </div>
            <span>Save & Install</span>
        </button>

    </nav>

    <div class="p-4 md:p-6 mt-auto space-y-4">
        <!-- Support Button -->
        <button type="button" id="kofiBtn"
            class="block w-full bg-white text-black hover:bg-white/90 font-medium py-3 px-4 rounded-xl transition-all shadow-lg shadow-black/10 hover:shadow-xl hover:-translate-y-0.5 hover:ring-2 hover:ring-black/10 focus:outline-none focus:ring-2 focus:ring-black/20 active:translate-y-0 border border-white/10 group text-left"
            aria-label="Support me">
            <div class="flex items-center justify-center gap-3">
                <!-- Heart icon -->
                <svg class="w-5 h-5 group-hover:scale-110 transition-transform text-black" fill="currentColor"
                    viewBox="0 0 24 24">
                    <path
                        d="M4.318 6.318a4.5 4.5 0 000 6.364L12 20.364l7.682-7.682a4.5 4.5 0 00-6.364-6.364L12 7.636l-1.318-1.318a4.5 4.5 0 00-6.364 0z" />
                </svg>
                <span>Support me</span>
            </div>
        </button>

        <!-- Copyright -->
        <div class="text-xs text-slate-600 text-center hidden md:block">
            &copy; <span id="currentYear">2024</span> Watchly
        </div>
    </div>
</aside>
" | base64 --decode > "$REPO/app/templates/components/sidebar.html" +echo " wrote app/templates/components/sidebar.html" + +mkdir -p "$REPO/app/api" +echo "ZnJvbSBmYXN0YXBpIGltcG9ydCBBUElSb3V0ZXIKCmZyb20gLmVuZHBvaW50cy5hbm5vdW5jZW1lbnQgaW1wb3J0IHJvdXRlciBhcyBhbm5vdW5jZW1lbnRfcm91dGVyCmZyb20gLmVuZHBvaW50cy5jYXRhbG9ncyBpbXBvcnQgcm91dGVyIGFzIGNhdGFsb2dzX3JvdXRlcgpmcm9tIC5lbmRwb2ludHMuaGVhbHRoIGltcG9ydCByb3V0ZXIgYXMgaGVhbHRoX3JvdXRlcgpmcm9tIC5lbmRwb2ludHMubWFuaWZlc3QgaW1wb3J0IHJvdXRlciBhcyBtYW5pZmVzdF9yb3V0ZXIKZnJvbSAuZW5kcG9pbnRzLm1ldGEgaW1wb3J0IHJvdXRlciBhcyBtZXRhX3JvdXRlcgpmcm9tIC5lbmRwb2ludHMuc3RhdHMgaW1wb3J0IHJvdXRlciBhcyBzdGF0c19yb3V0ZXIKZnJvbSAuZW5kcG9pbnRzLnRva2VucyBpbXBvcnQgcm91dGVyIGFzIHRva2Vuc19yb3V0ZXIKZnJvbSAuZW5kcG9pbnRzLnRyYWt0IGltcG9ydCByb3V0ZXIgYXMgdHJha3Rfcm91dGVyCmZyb20gLmVuZHBvaW50cy52YWxpZGF0aW9uIGltcG9ydCByb3V0ZXIgYXMgdmFsaWRhdGlvbl9yb3V0ZXIKCmFwaV9yb3V0ZXIgPSBBUElSb3V0ZXIoKQoKCkBhcGlfcm91dGVyLmdldCgiLyIpCmFzeW5jIGRlZiByb290KCk6CiAgICByZXR1cm4geyJtZXNzYWdlIjogIldhdGNobHkgQVBJIGlzIHJ1bm5pbmcifQoKCmFwaV9yb3V0ZXIuaW5jbHVkZV9yb3V0ZXIobWFuaWZlc3Rfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKGNhdGFsb2dzX3JvdXRlcikKYXBpX3JvdXRlci5pbmNsdWRlX3JvdXRlcih0b2tlbnNfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKHRyYWt0X3JvdXRlcikKYXBpX3JvdXRlci5pbmNsdWRlX3JvdXRlcihoZWFsdGhfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKG1ldGFfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKGFubm91bmNlbWVudF9yb3V0ZXIpCmFwaV9yb3V0ZXIuaW5jbHVkZV9yb3V0ZXIoc3RhdHNfcm91dGVyKQphcGlfcm91dGVyLmluY2x1ZGVfcm91dGVyKHZhbGlkYXRpb25fcm91dGVyKQo=" | base64 --decode > "$REPO/app/api/router.py" +echo " wrote app/api/router.py" + +mkdir -p "$REPO/app/core" +echo "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" | base64 --decode > "$REPO/app/core/config.py" +echo " wrote app/core/config.py" + +mkdir -p "$REPO/app/static/js" +echo "// Main entry point - initializes all modules

import { defaultCatalogs } from './constants.js';
import { showToast, initializeFooter, initializeKofi } from './modules/ui.js';
import { initializeNavigation, switchSection, lockNavigationForLoggedOut, initializeMobileNav, updateMobileLayout, unlockNavigation } from './modules/navigation.js';
import { initializeAuth, setStremioLoggedOutState } from './modules/auth.js';
import { initializeTrakt, setTraktLoggedOutState } from './modules/trakt.js';
import { initializeCatalogList, renderCatalogList, getCatalogs, setCatalogs } from './modules/catalog.js';
import { initializeForm, clearErrors } from './modules/form.js';

// Initialize catalogs state
let catalogsState = JSON.parse(JSON.stringify(defaultCatalogs));

// DOM Elements
const configForm = document.getElementById('configForm');
const catalogList = document.getElementById('catalogList');
const movieGenreList = document.getElementById('movieGenreList');
const seriesGenreList = document.getElementById('seriesGenreList');
const submitBtn = document.getElementById('submitBtn');
const stremioLoginBtn = document.getElementById('stremioLoginBtn');
const stremioLoginText = document.getElementById('stremioLoginText');
const emailInput = document.getElementById('emailInput');
const passwordInput = document.getElementById('passwordInput');
const emailPwdContinueBtn = document.getElementById('emailPwdContinueBtn');
const languageSelect = document.getElementById('languageSelect');
const configNextBtn = document.getElementById('configNextBtn');
const catalogsNextBtn = document.getElementById('catalogsNextBtn');
const successResetBtn = document.getElementById('successResetBtn');
const btnGetStarted = document.getElementById('btn-get-started');

const navItems = {
    welcome: document.getElementById('nav-welcome'),
    login: document.getElementById('nav-login'),
    config: document.getElementById('nav-config'),
    catalogs: document.getElementById('nav-catalogs'),
    install: document.getElementById('nav-install')
};

const sections = {
    welcome: document.getElementById('sect-welcome'),
    login: document.getElementById('sect-login'),
    config: document.getElementById('sect-config'),
    catalogs: document.getElementById('sect-catalogs'),
    install: document.getElementById('sect-install'),
    success: document.getElementById('sect-success')
};

// Main scroll container
const mainEl = document.querySelector('main');

// Reset App Function
function resetApp() {
    if (configForm) configForm.reset();
    clearErrors();

    // Reset Navigation is now Back to Welcome
    switchSection('welcome');

    // Lock Navs
    Object.keys(navItems).forEach(key => {
        if (key !== 'login' && key !== 'welcome') {
            if (navItems[key]) navItems[key].classList.add('disabled');
        }
    });

    // Reset Stremio State
    setStremioLoggedOutState();

    // Reset Trakt State
    setTraktLoggedOutState();

    // Reset catalogs
    catalogsState = JSON.parse(JSON.stringify(defaultCatalogs));
    setCatalogs(catalogsState);
    renderCatalogList();

    // Show Form
    if (configForm) configForm.classList.remove('hidden');
    if (sections.success) sections.success.classList.add('hidden');
}

// Welcome Flow Logic
function initializeWelcomeFlow() {
    if (!btnGetStarted) return;

    // Support mobile taps reliably while avoiding double-fire (touch -> click)
    let touched = false;
    const handleGetStarted = (e) => {
        if (e.type === 'click' && touched) return;
        if (e.type === 'touchstart') touched = true;
        if (navItems.login) navItems.login.classList.remove('disabled');
        switchSection('login');
    };

    btnGetStarted.addEventListener('click', handleGetStarted);
    btnGetStarted.addEventListener('touchstart', handleGetStarted, { passive: true });
}

// Initialize everything
document.addEventListener('DOMContentLoaded', () => {
    // Start at Welcome
    switchSection('welcome');
    initializeWelcomeFlow();

    // Initialize all modules
    initializeNavigation({
        navItems,
        sections,
        mainEl
    });

    // By default, ensure logged-out users see only Welcome/Login
    lockNavigationForLoggedOut();

    // Initialize catalog management - set catalogs first
    setCatalogs(catalogsState);
    initializeCatalogList(
        { catalogList },
        {
            catalogs: catalogsState,
            renderCatalogList
        }
    );

    // Initialize authentication (Stremio)
    initializeAuth(
        {
            stremioLoginBtn,
            stremioLoginText,
            emailInput,
            passwordInput,
            emailPwdContinueBtn,
            languageSelect
        },
        {
            getCatalogs,
            renderCatalogList,
            resetApp
        }
    );

    // Initialize Trakt authentication
    initializeTrakt(
        { languageSelect },
        {
            getCatalogs,
            renderCatalogList,
            resetApp
        }
    );

    // Initialize form handling
    initializeForm(
        {
            configForm,
            submitBtn,
            emailInput,
            passwordInput,
            languageSelect,
            movieGenreList,
            seriesGenreList
        },
        {
            getCatalogs,
            resetApp
        }
    );

    // Initialize mobile navigation
    initializeMobileNav();

    // Initialize UI components
    initializeFooter();
    initializeKofi();

    // Layout adjustments for fixed mobile header
    updateMobileLayout();
    window.addEventListener('resize', updateMobileLayout);
    window.addEventListener('orientationchange', updateMobileLayout);

    // Next Buttons
    if (configNextBtn) configNextBtn.addEventListener('click', () => switchSection('catalogs'));
    if (catalogsNextBtn) catalogsNextBtn.addEventListener('click', () => switchSection('install'));

    // Reset Buttons
    const resetBtn = document.getElementById('resetBtn');
    if (resetBtn) resetBtn.addEventListener('click', resetApp);
    if (successResetBtn) successResetBtn.addEventListener('click', resetApp);
});

// Make resetApp available globally for auth module
window.resetApp = resetApp;
window.switchSection = switchSection;
window.unlockNavigation = unlockNavigation;
" | base64 --decode > "$REPO/app/static/js/main.js" +echo " wrote app/static/js/main.js" + +mkdir -p "$REPO/app/static/js/modules" +echo "// Form Submission and UI Helpers

import { showToast, showConfirm, escapeHtml } from './ui.js';
import { getTraktTokensFromStorage } from './trakt.js';
import { switchSection } from './navigation.js';
import { MOVIE_GENRES, SERIES_GENRES } from '../constants.js';

// DOM Elements - will be initialized
let configForm = null;
let submitBtn = null;
let emailInput = null;
let passwordInput = null;
let languageSelect = null;
let movieGenreList = null;
let seriesGenreList = null;
let getCatalogs = null;
let resetApp = null;

export function initializeForm(domElements, catalogState) {
    configForm = domElements.configForm;
    submitBtn = domElements.submitBtn;
    emailInput = domElements.emailInput;
    passwordInput = domElements.passwordInput;
    languageSelect = domElements.languageSelect;
    movieGenreList = domElements.movieGenreList;
    seriesGenreList = domElements.seriesGenreList;
    getCatalogs = catalogState.getCatalogs;
    resetApp = catalogState.resetApp;

    initializeFormSubmission();
    initializeGenreLists();
    initializeLanguageSelect();
    initializePasswordToggles();
    initializeSuccessActions();
    initializePosterRatingProvider();
    initializeTmdb();
    initializeSimkl();
    initializeGemini();
    initializeYearSlider();
}

// Form Submission
async function initializeFormSubmission() {
    if (!submitBtn) return;

    submitBtn.addEventListener("click", async (e) => {
        e.preventDefault();
        clearErrors();

        const sAuthKey = (document.getElementById("authKey").value || '').trim();
        const email = emailInput?.value.trim();
        const password = passwordInput?.value;
        const language = languageSelect.value;
        const popularity = document.getElementById("popularitySelect")?.value || "balanced";
        const yearMin = parseInt(document.getElementById("yearMin")?.value || "1980");
        const yearMax = parseInt(document.getElementById("yearMax")?.value || "2026");
        const sortingOrder = document.getElementById("sortingOrderSelect")?.value || "default";
        const posterRatingProvider = document.getElementById("posterRatingProvider")?.value || "";
        const posterRatingApiKey = document.getElementById("posterRatingApiKey")?.value.trim() || "";
        const excludedMovieGenres = Array.from(document.querySelectorAll('input[name="movie-genre"]:checked')).map(cb => cb.value);
        const excludedSeriesGenres = Array.from(document.querySelectorAll('input[name="series-genre"]:checked')).map(cb => cb.value);
        const tmdbApiKey = document.getElementById("tmdbApiKey")?.value.trim() || "";
        const simklApiKey = document.getElementById("simklApiKey")?.value.trim() || "";
        const geminiApiKey = document.getElementById("geminiApiKey")?.value.trim() || "";

        const catalogsToSend = [];
        const catalogs = getCatalogs ? getCatalogs() : [];
        // Get enabled state from catalog objects (updated by visibility button)
        catalogs.forEach(originalCatalog => {
            const catalogId = originalCatalog.id;
            const enabled = originalCatalog.enabled !== false;

            // Get enabled_movie and enabled_series from toggle buttons
            const activeBtn = document.querySelector(`.catalog-type-btn[data-catalog-id="${catalogId}"].bg-white`);
            let enabledMovie = true;
            let enabledSeries = true;

            if (activeBtn) {
                const mode = activeBtn.dataset.mode;
                if (mode === 'movie') {
                    enabledMovie = true;
                    enabledSeries = false;
                } else if (mode === 'series') {
                    enabledMovie = false;
                    enabledSeries = true;
                } else {
                    // 'both' or default
                    enabledMovie = true;
                    enabledSeries = true;
                }
            } else {
                // Fallback to catalog state
                enabledMovie = originalCatalog.enabledMovie !== false;
                enabledSeries = originalCatalog.enabledSeries !== false;
            }

            catalogsToSend.push({
                id: catalogId,
                name: originalCatalog.name,
                enabled: enabled,
                enabled_movie: enabledMovie,
                enabled_series: enabledSeries,
                display_at_home: originalCatalog.display_at_home !== false, // Default to true if not set
                shuffle: originalCatalog.shuffle === true, // Default to false if not set
            });
        });

        // Determine active provider
        const traktTokens = getTraktTokensFromStorage();
        const isTraktLogin = !!(traktTokens && traktTokens.access_token && !sAuthKey && !email);

        // Validation
        if (!sAuthKey && !(email && password) && !isTraktLogin) {
            showError("generalError", "Please login with Stremio or Trakt to continue.");
            switchSection('login');
            return;
        }

        if (!tmdbApiKey) {
            showError("generalError", "TMDB API key is required.");
            const tmdbInput = document.getElementById("tmdbApiKey");
            if (tmdbInput) {
                tmdbInput.focus();
                tmdbInput.scrollIntoView({ behavior: "smooth", block: "center" });
            }
            return;
        }

        // Validate poster rating API key if provided
        if (posterRatingProvider && posterRatingApiKey) {
            if (window.validatePosterRatingApiKey) {
                const isValid = await window.validatePosterRatingApiKey();
                if (!isValid) {
                    return;
                }
            }
        }

        setLoading(true);

        try {
            // Build poster_rating payload
            let posterRating = null;
            if (posterRatingProvider && posterRatingApiKey) {
                posterRating = {
                    provider: posterRatingProvider,
                    api_key: posterRatingApiKey
                };
            }

            let endpoint, payload;

            if (isTraktLogin) {
                // ---- Trakt submission ----
                endpoint = "/tokens/trakt/";
                payload = {
                    trakt_access_token: traktTokens.access_token,
                    trakt_refresh_token: traktTokens.refresh_token || undefined,
                    trakt_expires_at: traktTokens.expires_at || undefined,
                    catalogs: catalogsToSend,
                    language: language,
                    year_min: yearMin,
                    year_max: yearMax,
                    popularity: popularity,
                    sorting_order: sortingOrder,
                    poster_rating: posterRating,
                    tmdb_api_key: tmdbApiKey || undefined,
                    simkl_api_key: simklApiKey,
                    gemini_api_key: geminiApiKey,
                    excluded_movie_genres: excludedMovieGenres,
                    excluded_series_genres: excludedSeriesGenres
                };
            } else {
                // ---- Stremio submission ----
                endpoint = "/tokens/";
                payload = {
                    authKey: sAuthKey || undefined,
                    email: email || undefined,
                    password: password || undefined,
                    catalogs: catalogsToSend,
                    language: language,
                    year_min: yearMin,
                    year_max: yearMax,
                    popularity: popularity,
                    sorting_order: sortingOrder,
                    poster_rating: posterRating,
                    tmdb_api_key: tmdbApiKey || undefined,
                    simkl_api_key: simklApiKey,
                    gemini_api_key: geminiApiKey,
                    excluded_movie_genres: excludedMovieGenres,
                    excluded_series_genres: excludedSeriesGenres
                };
            }

            const response = await fetch(endpoint, {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify(payload)
            });

            if (!response.ok) {
                const errorData = await response.json();
                throw new Error(errorData.detail || "Failed to generate manifest URL");
            }
            const data = await response.json();
            showSuccess(data.manifestUrl);
        } catch (error) {
            console.error("Error:", error);
            showError("generalError", error.message);
        } finally {
            setLoading(false);
        }
    });
}

// UI Helpers & Genre Lists
function initializeGenreLists() {
    renderGenreList(movieGenreList, MOVIE_GENRES, 'movie-genre');
    renderGenreList(seriesGenreList, SERIES_GENRES, 'series-genre');
}

function renderGenreList(container, genres, namePrefix) {
    if (!container) return;
    container.innerHTML = genres.map(genre => `
        <label class="flex items-center gap-3 p-2 rounded-lg hover:bg-white/5 cursor-pointer transition group">
            <div class="relative flex items-center">
                <input type="checkbox" name="${namePrefix}" value="${genre.id}"
                    class="peer appearance-none w-5 h-5 border-2 border-slate-600 rounded bg-neutral-900 checked:bg-white checked:border-white transition-colors">
                <svg class="absolute w-3.5 h-3.5 text-black left-1/2 top-1/2 -translate-x-1/2 -translate-y-1/2 opacity-0 peer-checked:opacity-100 pointer-events-none transition-opacity"
                    fill="none" stroke="currentColor" viewBox="0 0 24 24">
                    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="3" d="M5 13l4 4L19 7"></path>
                </svg>
            </div>
            <span class="text-sm text-slate-300 group-hover:text-white transition-colors select-none">${genre.name}</span>
        </label>
    `).join('');
}

function initializeLanguageSelect() {
    if (!languageSelect) return;
}

// Poster Rating Provider
function initializePosterRatingProvider() {
    const providerSelect = document.getElementById("posterRatingProvider");
    const apiKeyContainer = document.getElementById("posterRatingApiKeyContainer");
    const apiKeyInput = document.getElementById("posterRatingApiKey");
    const helpContainer = document.getElementById("posterRatingHelp");
    const helpText = document.getElementById("posterRatingHelpText");
    const validateBtn = document.getElementById("posterRatingApiKeyValidate");
    const toggleBtn = document.getElementById("posterRatingApiKeyToggle");
    const eyeIcon = document.getElementById("posterRatingApiKeyEye");
    const eyeOffIcon = document.getElementById("posterRatingApiKeyEyeOff");
    const validationMessage = document.getElementById("posterRatingValidationMessage");

    if (!providerSelect || !apiKeyContainer || !apiKeyInput || !helpContainer || !helpText) return;

    const providerInfo = {
        "rpdb": {
            name: "RPDB (RatingPosterDB)",
            url: "https://ratingposterdb.com",
            description: "Enable ratings on posters via RatingPosterDB"
        },
        "top_posters": {
            name: "Top Posters",
            url: "https://api.top-streaming.stream/",
            description: "Enable ratings on posters via Top Posters"
        }
    };

    let isValidated = false;

    // Eye toggle functionality
    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    // Validation function
    async function validateApiKey() {
        const selectedProvider = providerSelect.value;
        const apiKey = apiKeyInput.value.trim();

        if (!selectedProvider || !apiKey) {
            showValidationMessage("Please select a provider and enter an API key", "error");
            return false;
        }

        if (!validateBtn) return false;

        // Show loading state
        validateBtn.disabled = true;
        validateBtn.classList.add("opacity-50", "cursor-not-allowed");
        const originalHTML = validateBtn.innerHTML;
        validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';

        try {
            const response = await fetch("/poster-rating/validate", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ provider: selectedProvider, api_key: apiKey })
            });

            const data = await response.json();

            if (data.valid) {
                showValidationMessage("API key is valid ✓", "success");
                isValidated = true;
                return true;
            } else {
                showValidationMessage(data.message || "Invalid API key", "error");
                apiKeyInput.value = ""; // Clear invalid key
                isValidated = false;
                return false;
            }
        } catch (error) {
            showValidationMessage("Validation failed. Please try again.", "error");
            isValidated = false;
            return false;
        } finally {
            validateBtn.disabled = false;
            validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
            validateBtn.innerHTML = originalHTML;
        }
    }

    // Show validation message
    function showValidationMessage(message, type) {
        if (!validationMessage) return;
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    // Clear validation message
    function clearValidationMessage() {
        if (validationMessage) {
            validationMessage.classList.add("hidden");
        }
    }

    // Validate button click
    if (validateBtn) {
        validateBtn.addEventListener("click", validateApiKey);
    }

    // Clear validation when API key changes
    apiKeyInput.addEventListener("input", () => {
        isValidated = false;
        clearValidationMessage();
    });

    function updateUI() {
        const selectedProvider = providerSelect.value;

        if (selectedProvider && providerInfo[selectedProvider]) {
            const info = providerInfo[selectedProvider];
            apiKeyContainer.style.display = "block";
            helpContainer.style.display = "block";
            helpText.innerHTML = `${info.description}. Get your API key from <a href="${info.url}" target="_blank" class="text-slate-300 hover:text-white underline">${info.name}</a>.`;
            // Don't clear the API key when switching providers - just reset validation
            isValidated = false;
            clearValidationMessage();
        } else {
            // Only clear when provider is set to "None"
            apiKeyContainer.style.display = "none";
            helpContainer.style.display = "none";
            apiKeyInput.value = "";
            isValidated = false;
            clearValidationMessage();
        }
    }

    // Handle provider change - preserve API key value, just reset validation
    providerSelect.addEventListener("change", () => {
        isValidated = false;
        clearValidationMessage();
        updateUI();
    });

    updateUI(); // Initialize on load

    // Export validate function for form submission
    window.validatePosterRatingApiKey = validateApiKey;
}

// TMDB API Key (Required)
function initializeTmdb() {
    const apiKeyInput = document.getElementById("tmdbApiKey");
    const validateBtn = document.getElementById("tmdbApiKeyValidate");
    const toggleBtn = document.getElementById("tmdbApiKeyToggle");
    const eyeIcon = document.getElementById("tmdbApiKeyEye");
    const eyeOffIcon = document.getElementById("tmdbApiKeyEyeOff");
    const validationMessage = document.getElementById("tmdbValidationMessage");

    if (!apiKeyInput || !validationMessage) return;

    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    function showTmdbValidationMessage(message, type) {
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    if (validateBtn) {
        validateBtn.addEventListener("click", async () => {
            const apiKey = apiKeyInput.value.trim();
            if (!apiKey) {
                showTmdbValidationMessage("Please enter a TMDB API key", "error");
                return;
            }
            validateBtn.disabled = true;
            validateBtn.classList.add("opacity-50", "cursor-not-allowed");
            const originalHTML = validateBtn.innerHTML;
            validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';
            try {
                const response = await fetch("/tmdb/validation", {
                    method: "POST",
                    headers: { "Content-Type": "application/json" },
                    body: JSON.stringify({ api_key: apiKey })
                });
                const data = await response.json();
                if (data.valid) {
                    showTmdbValidationMessage("TMDB API key is valid ✓", "success");
                } else {
                    showTmdbValidationMessage(data.message || "Invalid TMDB API key", "error");
                }
            } catch (error) {
                showTmdbValidationMessage("Validation failed. Please try again.", "error");
            } finally {
                validateBtn.disabled = false;
                validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
                validateBtn.innerHTML = originalHTML;
            }
        });
    }

    apiKeyInput.addEventListener("input", () => validationMessage.classList.add("hidden"));
}

// Simkl Integration
function initializeSimkl() {
    const apiKeyInput = document.getElementById("simklApiKey");
    const validateBtn = document.getElementById("simklApiKeyValidate");
    const toggleBtn = document.getElementById("simklApiKeyToggle");
    const eyeIcon = document.getElementById("simklApiKeyEye");
    const eyeOffIcon = document.getElementById("simklApiKeyEyeOff");
    const validationMessage = document.getElementById("simklValidationMessage");

    if (!apiKeyInput || !validateBtn || !validationMessage) return;

    // Eye toggle functionality
    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    // Validation function
    async function validateSimklKey() {
        const apiKey = apiKeyInput.value.trim();

        if (!apiKey) {
            showSimklValidationMessage("Please enter a Simkl API key", "error");
            return false;
        }

        // Show loading state
        validateBtn.disabled = true;
        validateBtn.classList.add("opacity-50", "cursor-not-allowed");
        const originalHTML = validateBtn.innerHTML;
        validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';

        try {
            const response = await fetch("/simkl/validation", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ api_key: apiKey })
            });

            const data = await response.json();

            if (data.valid) {
                showSimklValidationMessage("Simkl API key is valid ✓", "success");
                return true;
            } else {
                showSimklValidationMessage(data.message || "Invalid Simkl API key", "error");
                return false;
            }
        } catch (error) {
            showSimklValidationMessage("Validation failed. Please try again.", "error");
            return false;
        } finally {
            validateBtn.disabled = false;
            validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
            validateBtn.innerHTML = originalHTML;
        }
    }

    function showSimklValidationMessage(message, type) {
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    validateBtn.addEventListener("click", validateSimklKey);

    apiKeyInput.addEventListener("input", () => {
        validationMessage.classList.add("hidden");
    });
}

// Gemini AI Integration
function initializeGemini() {
    const apiKeyInput = document.getElementById("geminiApiKey");
    const validateBtn = document.getElementById("geminiApiKeyValidate");
    const toggleBtn = document.getElementById("geminiApiKeyToggle");
    const eyeIcon = document.getElementById("geminiApiKeyEye");
    const eyeOffIcon = document.getElementById("geminiApiKeyEyeOff");
    const validationMessage = document.getElementById("geminiValidationMessage");

    if (!apiKeyInput || !validateBtn || !validationMessage) return;

    // Eye toggle functionality
    if (toggleBtn && eyeIcon && eyeOffIcon) {
        toggleBtn.addEventListener("click", () => {
            const isPassword = apiKeyInput.type === "password";
            apiKeyInput.type = isPassword ? "text" : "password";
            eyeIcon.classList.toggle("hidden", !isPassword);
            eyeOffIcon.classList.toggle("hidden", isPassword);
        });
    }

    // Validation function
    async function validateGeminiKey() {
        const apiKey = apiKeyInput.value.trim();

        if (!apiKey) {
            showGeminiValidationMessage("Please enter a Gemini API key", "error");
            return false;
        }

        // Show loading state
        validateBtn.disabled = true;
        validateBtn.classList.add("opacity-50", "cursor-not-allowed");
        const originalHTML = validateBtn.innerHTML;
        validateBtn.innerHTML = '<svg class="w-5 h-5 animate-spin" fill="none" stroke="currentColor" viewBox="0 0 24 24"><circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle><path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path></svg>';

        try {
            const response = await fetch("/gemini/validation", {
                method: "POST",
                headers: { "Content-Type": "application/json" },
                body: JSON.stringify({ api_key: apiKey })
            });

            const data = await response.json();

            if (data.valid) {
                showGeminiValidationMessage("Gemini API key is valid ✓", "success");
                return true;
            } else {
                showGeminiValidationMessage(data.message || "Invalid Gemini API key", "error");
                return false;
            }
        } catch (error) {
            showGeminiValidationMessage("Validation failed. Please try again.", "error");
            return false;
        } finally {
            validateBtn.disabled = false;
            validateBtn.classList.remove("opacity-50", "cursor-not-allowed");
            validateBtn.innerHTML = originalHTML;
        }
    }

    function showGeminiValidationMessage(message, type) {
        validationMessage.textContent = message;
        validationMessage.className = `mt-2 text-xs ${type === "success" ? "text-green-400" : "text-red-400"}`;
        validationMessage.classList.remove("hidden");
    }

    validateBtn.addEventListener("click", validateGeminiKey);

    apiKeyInput.addEventListener("input", () => {
        validationMessage.classList.add("hidden");
    });
}

// Password Toggles
function initializePasswordToggles() {
    document.querySelectorAll('.toggle-btn').forEach(btn => {
        btn.addEventListener('click', () => {
            const targetId = btn.getAttribute('data-target');
            const input = document.getElementById(targetId);
            if (!input) return;
            const isHidden = input.type === 'password';
            input.type = isHidden ? 'text' : 'password';
            // Swap icon and labels
            if (isHidden) {
                // Now visible: show eye-off icon
                btn.setAttribute('title', 'Hide');
                btn.setAttribute('aria-label', 'Hide password');
                btn.innerHTML = '<svg class="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M17.94 17.94A10.94 10.94 0 0 1 12 20c-7 0-11-8-11-8a21.77 21.77 0 0 1 5.06-6.17M9.9 4.24A10.94 10.94 0 0 1 12 4c7 0 11 8 11 8a21.8 21.8 0 0 1-3.22 4.31"/><path d="M1 1l22 22"/><path d="M14.12 14.12A3 3 0 0 1 9.88 9.88"/></svg>';
            } else {
                // Now hidden: show eye icon
                btn.setAttribute('title', 'Show');
                btn.setAttribute('aria-label', 'Show password');
                btn.innerHTML = '<svg class="w-4 h-4" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M1 12s4-7 11-7 11 7 11 7-4 7-11 7-11-7-11-7z"/><circle cx="12" cy="12" r="3"/></svg>';
            }
        });
    });
}

// Delete & Success Helpers
function initializeSuccessActions() {
    const copyBtn = document.getElementById('copyBtn');
    if (copyBtn) {
        copyBtn.addEventListener('click', async (e) => {
            e.preventDefault();
            e.stopPropagation();
            const urlText = document.getElementById('addonUrl').textContent;
            try {
                await navigator.clipboard.writeText(urlText);
                const originalText = copyBtn.innerHTML;
                copyBtn.innerHTML = 'Copied!';
                setTimeout(() => { copyBtn.innerHTML = originalText; }, 2000);
            } catch (err) { }
        });
    }

    const installDesktopBtn = document.getElementById('installDesktopBtn');
    if (installDesktopBtn) {
        installDesktopBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            const url = document.getElementById('addonUrl').textContent;
            window.location.href = `stremio://${url.replace(/^https?:\/\//, '')}`;
        });
    }
    const installWebBtn = document.getElementById('installWebBtn');
    if (installWebBtn) {
        installWebBtn.addEventListener('click', (e) => {
            e.preventDefault();
            e.stopPropagation();
            const url = document.getElementById('addonUrl').textContent;
            window.open(`https://web.stremio.com/#/addons?addon=${encodeURIComponent(url)}`, '_blank');
        });
    }

    const deleteAccountBtn = document.getElementById('deleteAccountBtn');
    if (deleteAccountBtn) {
        deleteAccountBtn.addEventListener('click', async () => {
            const confirmed = await showConfirm(
                'Delete Account?',
                'Are you sure you want to delete your settings? This action is irreversible and all your data will be permanently removed.'
            );

            if (!confirmed) return;

            const sAuthKey = (document.getElementById("authKey").value || '').trim();
            const email = emailInput?.value.trim();
            const password = passwordInput?.value;

            if (!sAuthKey && !(email && password)) {
                showError('generalError', "Provide Stremio auth key or email & password to delete your account.");
                switchSection('login');
                return;
            }

            setLoading(true);
            try {
                const payload = { authKey: sAuthKey || undefined, email: email || undefined, password: password || undefined };
                const res = await fetch('/tokens/', { method: 'DELETE', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(payload) });
                if (!res.ok) throw new Error((await res.json()).detail || 'Failed to delete');
                showToast('Account deleted successfully.', 'success');
                if (resetApp) resetApp();
            } catch (e) {
                showError('generalError', e.message);
            } finally {
                setLoading(false);
            }
        });
    }
}

function setLoading(loading) {
    if (!submitBtn) return;
    const btnText = submitBtn.querySelector('.btn-text');
    const loader = submitBtn.querySelector('.loader');
    submitBtn.disabled = loading;
    if (loading) {
        if (btnText) btnText.classList.add('hidden');
        if (loader) loader.classList.remove('hidden');
    } else {
        if (btnText) btnText.classList.remove('hidden');
        if (loader) loader.classList.add('hidden');
    }
}

function showError(target, message) {
    if (target === 'generalError') {
        const errEl = document.getElementById('errorMessage');
        if (errEl) {
            errEl.querySelector('.message-content').textContent = message;
            errEl.classList.remove('hidden');
        } else { showToast(message, 'error'); }
    } else if (target === 'stremioAuthSection') {
        showToast(message, 'error');
    } else {
        const el = document.getElementById(target);
        if (el) {
            el.classList.add('border-red-500');
            el.focus();
        }
    }
}

export function clearErrors() {
    const errEl = document.getElementById('errorMessage');
    if (errEl) errEl.classList.add('hidden');
    document.querySelectorAll('.border-red-500').forEach(e => e.classList.remove('border-red-500'));
}

function showSuccess(url) {
    // Hide form entirely by hiding the active section
    const sections = {
        welcome: document.getElementById('sect-welcome'),
        login: document.getElementById('sect-login'),
        config: document.getElementById('sect-config'),
        catalogs: document.getElementById('sect-catalogs'),
        install: document.getElementById('sect-install'),
        success: document.getElementById('sect-success')
    };
    Object.values(sections).forEach(s => { if (s) s.classList.add('hidden') });

    // Show Success Section
    if (sections.success) {
        sections.success.classList.remove('hidden');
        document.getElementById('addonUrl').textContent = url;
    }
}

// Year Slider Logic
function initializeYearSlider() {
    const yearMin = document.getElementById('yearMin');
    const yearMax = document.getElementById('yearMax');
    const yearMinLabel = document.getElementById('yearMinLabel');
    const yearMaxLabel = document.getElementById('yearMaxLabel');
    const track = document.getElementById('yearSliderTrack');

    if (!yearMin || !yearMax || !yearMinLabel || !yearMaxLabel || !track) return;

    function updateSlider() {
        const minVal = parseInt(yearMin.value);
        const maxVal = parseInt(yearMax.value);

        if (minVal > maxVal) {
            // Prevent crossing: if min > max, snap them
            // This is handled by input listeners to avoid jerky movement
        }

        yearMinLabel.textContent = minVal;
        yearMaxLabel.textContent = maxVal;

        const range = yearMin.max - yearMin.min;
        const left = ((minVal - yearMin.min) / range) * 100;
        const right = ((yearMin.max - maxVal) / range) * 100;

        track.style.left = left + '%';
        track.style.right = right + '%';
    }

    yearMin.addEventListener('input', () => {
        if (parseInt(yearMin.value) > parseInt(yearMax.value)) {
            yearMin.value = yearMax.value;
        }
        yearMin.classList.add('year-slider-active');
        yearMax.classList.remove('year-slider-active');
        updateSlider();
    });

    yearMax.addEventListener('input', () => {
        if (parseInt(yearMax.value) < parseInt(yearMin.value)) {
            yearMax.value = yearMin.value;
        }
        yearMax.classList.add('year-slider-active');
        yearMin.classList.remove('year-slider-active');
        updateSlider();
    });

    // Initial update
    updateSlider();

    // Export update function for external population
    window.updateYearSlider = updateSlider;
}
" | base64 --decode > "$REPO/app/static/js/modules/form.js" +echo " wrote app/static/js/modules/form.js" + +mkdir -p "$REPO/app/services" +echo "from typing import Any

from fastapi import HTTPException
from loguru import logger

from app.core.config import settings
from app.core.security import redact_token
from app.core.settings import UserSettings, resolve_tmdb_api_key
from app.core.version import __version__
from app.services.catalog import DynamicCatalogService
from app.services.profile.integration import ProfileIntegration
from app.services.stremio.service import StremioBundle
from app.services.token_store import token_store
from app.services.translation import apply_catalog_translation
from app.services.user_cache import user_cache
from app.utils.catalog import cache_profile_and_watched_sets, sort_catalogs


class ManifestService:
    """Service for generating Stremio manifest files."""

    @staticmethod
    def get_base_manifest() -> dict[str, Any]:
        """Get the base manifest structure."""
        return {
            "id": settings.ADDON_ID,
            "version": __version__,
            "name": settings.ADDON_NAME,
            "description": "Movie and series recommendations based on your Stremio library.",
            "logo": ("https://raw.githubusercontent.com/TimilsinaBimal/Watchly/refs/heads/main/app/static/logo.png"),
            "background": (
                "https://raw.githubusercontent.com/TimilsinaBimal/Watchly/refs/heads/main/app/static/cover.png"
            ),
            "resources": ["catalog"],
            "types": ["movie", "series"],
            "idPrefixes": ["tt"],
            "catalogs": [],
            "behaviorHints": {"configurable": True, "configurationRequired": False},
            "stremioAddonsConfig": {
                "issuer": "https://stremio-addons.net",
                "signature": (
                    "eyJhbGciOiJkaXIiLCJlbmMiOiJBMTI4Q0JDLUhTMjU2In0..WSrhzzlj1TuDycD6QoVLuA.Dzmxzr4y83uqQF15r4tC1bB9-vtZRh1Rvy4BqgDYxu91c2esiJuov9KnnI_cboQCgZS7hjwnIqRSlQ-jEyGwXHHRerh9QklyfdxpXqNUyBgTWFzDOVdVvDYJeM_tGMmR.sezAChlWGV7lNS-t9HWB6A"  # noqa
                ),
            },
        }

    async def _resolve_auth_key(self, bundle: StremioBundle, credentials: dict[str, Any], token: str) -> str | None:
        """Resolve and validate auth key, refreshing if needed."""
        auth_key = credentials.get("authKey")
        email = credentials.get("email")
        password = credentials.get("password")

        is_valid = False
        if auth_key:
            try:
                await bundle.auth.get_user_info(auth_key)
                is_valid = True
            except Exception as e:
                logger.debug(f"Auth key check failed for {email or 'unknown'}: {e}")

        if not is_valid and email and password:
            try:
                auth_key = await bundle.auth.login(email, password)
                # Update store
                credentials["authKey"] = auth_key
                await token_store.update_user_data(token, credentials)
            except Exception as e:
                logger.error(f"Failed to refresh auth key during manifest fetch: {e}")
                return None

        return auth_key

    async def cache_library_and_profiles(
        self, bundle: StremioBundle, auth_key: str, user_settings: UserSettings, token: str
    ) -> dict[str, Any]:
        """
        Fetch and cache library items and profiles for a user.

        This should be called during token creation to pre-cache data
        so manifest generation is fast.

        Args:
            bundle: StremioBundle instance
            auth_key: Stremio auth key
            user_settings: User settings
            token: User token

        Returns:
            Library items dictionary
        """
        # Fetch library items
        logger.info(f"[{redact_token(token)}] Fetching library items for caching")
        library_items = await bundle.library.get_library_items(auth_key)

        # Cache library items using centralized cache service
        await user_cache.set_library_items(token, library_items)
        logger.debug(f"[{redact_token(token)}] Cached library items")

        # Build and cache profiles for both movie and series
        language = user_settings.language
        tmdb_key = resolve_tmdb_api_key(user_settings)
        integration_service = ProfileIntegration(language=language, tmdb_api_key=tmdb_key)

        for content_type in ["movie", "series"]:
            try:
                logger.info(f"[{redact_token(token)}] Building and caching profile for {content_type}")
                _, _, _ = await cache_profile_and_watched_sets(
                    token, content_type, integration_service, library_items, bundle, auth_key
                )
                logger.debug(f"[{redact_token(token)}] Cached profile and watched sets for {content_type}")
            except Exception as e:
                logger.warning(f"[{redact_token(token)}] Failed to build/cache profile for {content_type}: {e}")

        return library_items

    async def cache_library_and_profiles_from_items(
        self, library_items: dict, user_settings: UserSettings, token: str
    ) -> None:
        """
        Cache library items and build profiles from an already-fetched library dict.
        Used by Trakt (and any future non-Stremio provider) where library data is
        obtained outside of the Stremio bundle.
        """
        await user_cache.set_library_items(token, library_items)
        logger.debug(f"[{redact_token(token)}] Cached library items (provider-agnostic)")

        language = user_settings.language
        tmdb_key = resolve_tmdb_api_key(user_settings)
        integration_service = ProfileIntegration(language=language, tmdb_api_key=tmdb_key)

        for content_type in ["movie", "series"]:
            try:
                profile, watched_tmdb, watched_imdb = await integration_service.build_profile_from_library(
                    library_items, content_type
                )
                await user_cache.set_profile_and_watched_sets(token, content_type, profile, watched_tmdb, watched_imdb)
                logger.debug(f"[{redact_token(token)}] Cached profile for {content_type}")
            except Exception as e:
                logger.warning(f"[{redact_token(token)}] Failed to cache profile for {content_type}: {e}")


    async def _ensure_library_and_profiles_cached(
        self, bundle: StremioBundle, auth_key: str, user_settings: UserSettings, token: str
    ) -> dict[str, Any]:
        """Ensure library items and profiles are cached, fetching and building if needed."""
        # Try to get cached library items first
        library_items = await user_cache.get_library_items(token)

        if library_items:
            logger.debug(f"[{redact_token(token)}] Using cached library items for manifest")
            return library_items

        # If not cached, fetch and cache
        logger.info(f"[{redact_token(token)}] Library items not cached, fetching from Stremio for manifest")
        return await self.cache_library_and_profiles(bundle, auth_key, user_settings, token)

    async def _build_dynamic_catalogs(
        self, bundle: StremioBundle, auth_key: str, user_settings: UserSettings | None, token: str
    ) -> list[dict[str, Any]]:
        """Build dynamic catalogs for the manifest."""
        # check if cached, if not, fetch and cache
        library_items = await user_cache.get_library_items(token)
        if not library_items:
            library_items = await self._ensure_library_and_profiles_cached(bundle, auth_key, user_settings, token)
            await user_cache.set_library_items(token, library_items)

        tmdb_key = resolve_tmdb_api_key(user_settings)
        dynamic_catalog_service = DynamicCatalogService(language=user_settings.language, tmdb_api_key=tmdb_key)
        return await dynamic_catalog_service.get_dynamic_catalogs(library_items, user_settings, token=token)

    async def _translate_catalogs(self, catalogs: list[dict[str, Any]], language: str | None) -> list[dict[str, Any]]:
        """Translate catalog names to target language."""
        if not language:
            return catalogs

        translated_catalogs = []
        for cat in catalogs:
            await apply_catalog_translation(cat, language)
            translated_catalogs.append(cat)

        return translated_catalogs

    def _sort_catalogs(
        self, catalogs: list[dict[str, Any]], user_settings: UserSettings | None
    ) -> list[dict[str, Any]]:
        """Sort catalogs according to user settings order."""
        if not user_settings:
            return catalogs

        return sort_catalogs(catalogs, user_settings)

    async def _build_dynamic_catalogs_trakt(
        self, creds: dict, user_settings: UserSettings | None, token: str
    ) -> list[dict[str, Any]]:
        """Build dynamic catalogs for a Trakt-backed account."""
        from app.core.config import settings as app_settings
        from app.services.trakt.service import TraktBundle

        # Use cached library if available
        library_items = await user_cache.get_library_items(token)
        if not library_items:
            access_token = creds.get("authKey")  # stored as authKey after encryption/decryption
            if not access_token or not app_settings.TRAKT_CLIENT_ID or not app_settings.TRAKT_CLIENT_SECRET:
                logger.warning(f"[{redact_token(token)}] Trakt credentials missing, cannot fetch library")
                return []
            redirect_uri = f"{app_settings.HOST_NAME}/tokens/trakt/callback"
            trakt_bundle = TraktBundle(
                client_id=app_settings.TRAKT_CLIENT_ID,
                client_secret=app_settings.TRAKT_CLIENT_SECRET,
                redirect_uri=redirect_uri,
                access_token=access_token,
            )
            try:
                library_items = await trakt_bundle.library.get_library_items()
                await user_cache.set_library_items(token, library_items)
            finally:
                await trakt_bundle.close()

        if not library_items:
            return []

        tmdb_key = resolve_tmdb_api_key(user_settings)
        dynamic_catalog_service = DynamicCatalogService(
            language=user_settings.language if user_settings else "en-US",
            tmdb_api_key=tmdb_key,
        )
        return await dynamic_catalog_service.get_dynamic_catalogs(library_items, user_settings, token=token)

    async def get_manifest_for_token(self, token: str) -> dict[str, Any]:
        """
        Generate manifest for a given token.

        Args:
            token: User token

        Returns:
            Complete manifest dictionary

        Raises:
            HTTPException: If token is invalid or credentials are missing
        """
        if not token:
            raise HTTPException(status_code=401, detail="Missing token. Please reconfigure the addon.")

        # Load user credentials and settings
        creds = await token_store.get_user_data(token)
        if not creds:
            raise HTTPException(status_code=401, detail="Token not found. Please reconfigure the addon.")

        user_settings = None
        try:
            if creds.get("settings"):
                user_settings = UserSettings(**creds["settings"])
        except Exception as e:
            logger.error(f"[{redact_token(token)}] Error loading user data from token store: {e}")
            raise HTTPException(status_code=401, detail="Invalid token session. Please reconfigure.")

        base_manifest = self.get_base_manifest()

        fetched_catalogs = []
        try:
            if creds.get("auth_provider") == "trakt":
                # Trakt-backed account: fetch library from Trakt, bypass Stremio
                fetched_catalogs = await self._build_dynamic_catalogs_trakt(creds, user_settings, token)
            else:
                bundle = StremioBundle()
                try:
                    # Resolve auth key
                    auth_key = await self._resolve_auth_key(bundle, creds, token)

                    if auth_key:
                        fetched_catalogs = await self._build_dynamic_catalogs(bundle, auth_key, user_settings, token)
                finally:
                    await bundle.close()
        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Dynamic catalog build failed: {e}")
            fetched_catalogs = []

        # Combine base catalogs with fetched catalogs
        all_catalogs = [c.copy() for c in base_manifest["catalogs"]] + [c.copy() for c in fetched_catalogs]

        # Translate catalogs
        language = user_settings.language if user_settings else None
        translated_catalogs = await self._translate_catalogs(all_catalogs, language)

        # Sort catalogs
        sorted_catalogs = self._sort_catalogs(translated_catalogs, user_settings)

        if sorted_catalogs:
            base_manifest["catalogs"] = sorted_catalogs

        return base_manifest


manifest_service = ManifestService()
" | base64 --decode > "$REPO/app/services/manifest.py" +echo " wrote app/services/manifest.py" + +mkdir -p "$REPO/app/services" +echo "import asyncio
from datetime import datetime, timezone
from typing import Any

from fastapi import HTTPException
from loguru import logger

from app.core.config import settings
from app.core.security import redact_token
from app.core.settings import UserSettings
from app.services.catalog import DynamicCatalogService
from app.services.manifest import manifest_service
from app.services.stremio.service import StremioBundle
from app.services.token_store import token_store
from app.services.translation import apply_catalog_translation
from app.utils.catalog import sort_catalogs


class CatalogUpdater:
    """
    Catalog updater that triggers updates on-demand when users request catalogs.
    Uses in-memory locking to prevent duplicate concurrent updates.
    """

    def __init__(self):
        # In-memory lock to prevent duplicate updates for the same token
        self._updating_tokens: set[str] = set()

    def _needs_update(self, credentials: dict[str, Any]) -> bool:
        """Check if catalog update is needed based on last_updated timestamp."""
        if not credentials:
            return False

        last_updated = credentials.get("last_updated")
        if not last_updated:
            # No timestamp means never updated, needs update
            return True

        try:
            # Parse ISO format timestamp
            if isinstance(last_updated, str):
                last_update_time = datetime.fromisoformat(last_updated.replace("Z", "+00:00"))
            else:
                last_update_time = last_updated

            # Check if more than 11 hours have passed (update if less than 1 hour remaining)
            now = datetime.now(timezone.utc)
            if last_update_time.tzinfo is None:
                last_update_time = last_update_time.replace(tzinfo=timezone.utc)

            time_since_update = (now - last_update_time).total_seconds()
            # Update if less than 1 hour remaining until next update
            return time_since_update >= (settings.CATALOG_REFRESH_INTERVAL_SECONDS - 3600)
        except (ValueError, TypeError, AttributeError) as e:
            logger.warning(f"Failed to parse last_updated timestamp: {e}. Treating as needs update.")
            return True

    async def refresh_catalogs_for_credentials(
        self, token: str, credentials: dict[str, Any], update_timestamp: bool = True
    ) -> bool:
        """
        Refresh catalogs for a user's credentials.

        Args:
            token: User token
            credentials: User credentials dict
            update_timestamp: Whether to update last_updated timestamp on success

        Returns:
            True if update was successful, False otherwise
        """
        if not credentials:
            logger.warning(f"[{redact_token(token)}] Attempted to refresh catalogs with no credentials.")
            raise HTTPException(status_code=401, detail="Invalid or expired token. Please reconfigure the addon.")

        # Trakt-backed accounts use a different refresh path
        if credentials.get("auth_provider") == "trakt":
            return await self._refresh_trakt_catalogs(token, credentials, update_timestamp)

        auth_key = credentials.get("authKey")
        # check if auth key is valid
        bundle = StremioBundle()
        try:
            try:
                await bundle.auth.get_user_info(auth_key)
            except Exception as e:
                logger.exception(f"[{redact_token(token)}] Invalid auth key. Falling back to login: {e}")
                email = credentials.get("email")
                password = credentials.get("password")
                if email and password:
                    auth_key = await bundle.auth.login(email, password)
                    credentials["authKey"] = auth_key
                    await token_store.update_user_data(token, credentials)
                else:
                    return True  # true since we won't be able to update it again. so no need to try again.

            # 1. Check if addon is still installed
            try:
                addon_installed = await bundle.addons.is_addon_installed(auth_key)
                if not addon_installed:
                    logger.info(f"[{redact_token(token)}] User has not installed addon. Removing token from redis")
                    return True
            except Exception as e:
                logger.exception(f"[{redact_token(token)}] Failed to check if addon is installed: {e}")
                return False

            # 2. Extract settings and refresh
            user_settings = None
            if credentials.get("settings"):
                try:
                    user_settings = UserSettings(**credentials["settings"])
                except Exception as e:
                    logger.exception(f"[{redact_token(token)}] Failed to parse user settings: {e}")
                    # if user doesn't have setting, we can't update the catalogs.
                    # so no need to try again.
                    return True

            library_items = await manifest_service.cache_library_and_profiles(bundle, auth_key, user_settings, token)
            language = user_settings.language if user_settings else "en-US"

            from app.core.settings import resolve_tmdb_api_key

            tmdb_key = resolve_tmdb_api_key(user_settings)
            dynamic_catalog_service = DynamicCatalogService(
                language=language,
                tmdb_api_key=tmdb_key,
            )

            catalogs = await dynamic_catalog_service.get_dynamic_catalogs(
                library_items=library_items, user_settings=user_settings, token=token
            )

            lang = user_settings.language if user_settings else None
            for cat in catalogs:
                await apply_catalog_translation(cat, lang)

            # sort catalogs by order in user settings
            if user_settings:
                catalogs = sort_catalogs(catalogs, user_settings)

            success = await bundle.addons.update_catalogs(auth_key, catalogs)

            # Update timestamp and invalidate cache only on success
            if success and update_timestamp:
                try:
                    # Update last_updated timestamp to current time
                    # This represents when the update completed successfully
                    now = datetime.now(timezone.utc)
                    last_updated_str = now.replace(microsecond=0).isoformat()
                    credentials["last_updated"] = last_updated_str
                    await token_store.update_user_data(token, credentials)
                    logger.debug(f"[{redact_token(token)}] Updated last_updated timestamp to {last_updated_str}")
                except Exception as e:
                    logger.warning(f"[{redact_token(token)}] Failed to update last_updated timestamp: {e}")

            return success

        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Failed to update catalogs in background: {e}")
            try:
                error_msg = f"Failed to update catalogs: {str(e)}"
                description = (
                    f"Movie and series recommendations based on your Stremio library.\n\n⚠️ Status: Error\n{error_msg}"
                )
                await bundle.addons.update_description(auth_key, description)
            except Exception as update_err:
                logger.warning(f"[{redact_token(token)}] Failed to update addon description with error: {update_err}")
            return False
        finally:
            await bundle.close()

    async def _refresh_trakt_catalogs(
        self, token: str, credentials: dict[str, Any], update_timestamp: bool = True
    ) -> bool:
        """Refresh catalogs for a Trakt-backed account."""
        from app.core.settings import resolve_tmdb_api_key
        from app.services.trakt.service import TraktBundle

        user_settings = None
        if credentials.get("settings"):
            try:
                user_settings = UserSettings(**credentials["settings"])
            except Exception as e:
                logger.warning(f"[{redact_token(token)}] Failed to parse Trakt user settings: {e}")
                return True

        access_token = credentials.get("authKey")  # stored as authKey after decrypt
        if not access_token or not settings.TRAKT_CLIENT_ID or not settings.TRAKT_CLIENT_SECRET:
            logger.warning(f"[{redact_token(token)}] Trakt credentials missing, skipping refresh")
            return True

        redirect_uri = f"{settings.HOST_NAME}/tokens/trakt/callback"
        trakt_bundle = TraktBundle(
            client_id=settings.TRAKT_CLIENT_ID,
            client_secret=settings.TRAKT_CLIENT_SECRET,
            redirect_uri=redirect_uri,
            access_token=access_token,
        )
        try:
            library_items = await trakt_bundle.library.get_library_items()
            await manifest_service.cache_library_and_profiles_from_items(library_items, user_settings, token)

            if update_timestamp:
                now = datetime.now(timezone.utc)
                credentials["last_updated"] = now.replace(microsecond=0).isoformat()
                await token_store.update_user_data(token, credentials)

            logger.info(f"[{redact_token(token)}] Trakt catalog refresh complete")
            return True
        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Trakt catalog refresh failed: {e}")
            return False
        finally:
            await trakt_bundle.close()

    async def trigger_update(self, token: str, credentials: dict[str, Any]) -> None:
        """
        Trigger a catalog update if needed.
        This function checks if update is needed and fires a background task.
        Uses in-memory lock to prevent duplicate updates.
        """
        # Check if already updating
        if token in self._updating_tokens:
            logger.debug(f"[{redact_token(token)}] Update already in progress, skipping")
            return

        # Check if update is needed
        if not self._needs_update(credentials):
            logger.debug(f"[{redact_token(token)}] Catalog update not needed yet")
            return

        # Add to lock and fire background update
        self._updating_tokens.add(token)
        logger.info(f"[{redact_token(token)}] Triggering catalog update")

        # Fire and forget background task
        asyncio.create_task(self._update_task(token, credentials))

    async def _update_task(self, token: str, credentials: dict[str, Any]) -> None:
        """Background task that performs the actual catalog update."""
        try:
            success = await self.refresh_catalogs_for_credentials(token, credentials, update_timestamp=True)
            if success:
                logger.info(f"[{redact_token(token)}] Catalog update completed successfully")
            else:
                logger.warning(f"[{redact_token(token)}] Catalog update completed with failure")
        except Exception as e:
            logger.exception(f"[{redact_token(token)}] Catalog update task failed: {e}")
        finally:
            # Always remove from lock
            self._updating_tokens.discard(token)


logger.info(f"Catalog updater initialized with refresh interval of {settings.CATALOG_REFRESH_INTERVAL_SECONDS} seconds")
catalog_updater = CatalogUpdater()
" | base64 --decode > "$REPO/app/services/catalog_updater.py" +echo " wrote app/services/catalog_updater.py" + +mkdir -p "$REPO/app/services" +echo "import base64
import json
from typing import Any

import redis.asyncio as redis
from async_lru import alru_cache
from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from loguru import logger

from app.core.config import settings
from app.core.security import redact_token
from app.services.redis_service import redis_service
from app.services.user_cache import user_cache


class TokenStore:
    """Redis-backed store for user credentials and auth tokens."""

    KEY_PREFIX = settings.REDIS_TOKEN_KEY

    def __init__(self) -> None:
        if not settings.TOKEN_SALT or settings.TOKEN_SALT == "change-me":
            logger.warning(
                "TOKEN_SALT is missing or using the default placeholder. Set a strong value to secure tokens."
            )

    def _ensure_secure_salt(self) -> None:
        if not settings.TOKEN_SALT or settings.TOKEN_SALT == "change-me":
            logger.error("TOKEN_SALT is unset or using the insecure default.")
            raise RuntimeError("TOKEN_SALT must be set to a non-default value before storing credentials.")

    def _get_cipher(self) -> Fernet:
        salt = b"x7FDf9kypzQ1LmR32b8hWv49sKq2Pd8T"
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=salt,
            iterations=200_000,
        )

        key = base64.urlsafe_b64encode(kdf.derive(settings.TOKEN_SALT.encode("utf-8")))
        return Fernet(key)

    def encrypt_token(self, token: str) -> str:
        cipher = self._get_cipher()
        return cipher.encrypt(token.encode("utf-8")).decode("utf-8")

    def decrypt_token(self, enc: str) -> str:
        cipher = self._get_cipher()
        return cipher.decrypt(enc.encode("utf-8")).decode("utf-8")

    def _format_key(self, token: str) -> str:
        """Format Redis key from token."""
        return f"{self.KEY_PREFIX}{token}"

    def get_token_from_user_id(self, user_id: str) -> str:
        """
        For Trakt users, generate a stable opaque token from the user_id
        so the username is not exposed in the manifest URL.
        Stremio users keep their existing behaviour (user_id == token).
        """
        if user_id.startswith("trakt:"):
            import hashlib
            salt = settings.TOKEN_SALT or "watchly"
            digest = hashlib.sha256(f"{salt}:{user_id}".encode()).hexdigest()
            return digest[:40]
        return user_id.strip()

    def get_user_id_from_token(self, token: str) -> str:
        return token.strip() if token else ""

    async def store_user_data(self, user_id: str, payload: dict[str, Any]) -> str:
        self._ensure_secure_salt()
        token = self.get_token_from_user_id(user_id)
        key = self._format_key(token)

        # Prepare data for storage (Plain JSON, no encryption needed)
        storage_data = payload.copy()

        # Store user_id in payload for convenience
        storage_data["user_id"] = user_id

        if storage_data.get("authKey"):
            storage_data["authKey"] = self.encrypt_token(storage_data["authKey"])

        # Encrypt Trakt refresh token if present
        if storage_data.get("trakt_refresh_token"):
            try:
                if not storage_data["trakt_refresh_token"].startswith("gAAAAAB"):
                    storage_data["trakt_refresh_token"] = self.encrypt_token(storage_data["trakt_refresh_token"])
            except Exception as exc:
                logger.warning(f"Failed to encrypt trakt_refresh_token: {exc}")

        # Securely store password if provided (primary login mode)
        if storage_data.get("password"):
            try:
                storage_data["password"] = self.encrypt_token(storage_data["password"])
            except Exception as exc:
                logger.error(f"Password encryption failed for {redact_token(user_id)}: {exc}")
                # Do not store plaintext passwords
                raise RuntimeError("PASSWORD_ENCRYPT_FAILED")

        # Encrypt poster_rating API key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            poster_rating = storage_data["settings"].get("poster_rating")
            if poster_rating and isinstance(poster_rating, dict) and poster_rating.get("api_key"):
                try:
                    # Only encrypt if it's not already encrypted (check if it's a valid encrypted string)
                    api_key = poster_rating["api_key"]
                    # Simple check: encrypted tokens are base64-like and longer
                    # If it looks like plaintext, encrypt it
                    # Fernet encrypted tokens start with "gAAAAAB"
                    if not api_key.startswith("gAAAAAB"):
                        poster_rating["api_key"] = self.encrypt_token(api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt poster_rating api_key for {redact_token(user_id)}: {exc}")

        # Encrypt simkl_api_key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            simkl_api_key = storage_data["settings"].get("simkl_api_key")
            if simkl_api_key:
                try:
                    if not simkl_api_key.startswith("gAAAAAB"):
                        storage_data["settings"]["simkl_api_key"] = self.encrypt_token(simkl_api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt simkl_api_key for {redact_token(user_id)}: {exc}")

        # Encrypt gemini_api_key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            gemini_api_key = storage_data["settings"].get("gemini_api_key")
            if gemini_api_key:
                try:
                    if not gemini_api_key.startswith("gAAAAAB"):
                        storage_data["settings"]["gemini_api_key"] = self.encrypt_token(gemini_api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt gemini_api_key for {redact_token(user_id)}: {exc}")

        # Encrypt tmdb_api_key if present
        if storage_data.get("settings") and isinstance(storage_data["settings"], dict):
            tmdb_api_key = storage_data["settings"].get("tmdb_api_key")
            if tmdb_api_key:
                try:
                    if not tmdb_api_key.startswith("gAAAAAB"):
                        storage_data["settings"]["tmdb_api_key"] = self.encrypt_token(tmdb_api_key)
                except Exception as exc:
                    logger.warning(f"Failed to encrypt tmdb_api_key for {redact_token(user_id)}: {exc}")
        json_str = json.dumps(storage_data)

        if settings.TOKEN_TTL_SECONDS and settings.TOKEN_TTL_SECONDS > 0:
            await redis_service.set(key, json_str, settings.TOKEN_TTL_SECONDS)
        else:
            await redis_service.set(key, json_str)

        # Invalidate async LRU cache for fresh reads on subsequent requests
        try:
            self._get_user_data_cached.cache_invalidate(token)
        except KeyError:
            pass
        except Exception as e:
            logger.warning(f"Targeted cache invalidation failed: {e}. Falling back to clearing cache.")
            try:
                self._get_user_data_cached.cache_clear()
            except Exception as e_clear:
                logger.error(f"Error while clearing cache: {e_clear}")

        return token

    async def update_user_data(self, token: str, payload: dict[str, Any]) -> str:
        """Update user data by token. This is a convenience wrapper around store_user_data."""
        user_id = self.get_user_id_from_token(token)
        return await self.store_user_data(user_id, payload)

    async def _migrate_poster_rating_format_raw(self, token: str, redis_key: str, data: dict) -> dict | None:
        """Migrate old rpdb_key format to new poster_rating format in raw Redis data if needed."""
        if not data:
            return None

        settings_dict = data.get("settings")
        if not settings_dict or not isinstance(settings_dict, dict):
            return None

        rpdb_key = settings_dict.get("rpdb_key")
        poster_rating = settings_dict.get("poster_rating")
        needs_save = False

        # Case 1: Migrate rpdb_key to poster_rating if rpdb_key exists and poster_rating doesn't
        if rpdb_key and not poster_rating:
            logger.info(f"[MIGRATION] Migrating rpdb_key to poster_rating format for {redact_token(token)}")
            settings_dict["poster_rating"] = {
                "provider": "rpdb",
                "api_key": self.encrypt_token(rpdb_key),  # Encrypt the API key
            }
            needs_save = True

        # Case 2: Clean up deprecated rpdb_key field if it exists (even if empty/null)
        # Remove it since we've migrated to poster_rating or it's no longer needed
        if "rpdb_key" in settings_dict:
            settings_dict.pop("rpdb_key")
            # keep empty poster_rating field for now
            settings_dict["poster_rating"] = {
                "provider": "rpdb",
                "api_key": None,
            }
            if not needs_save:  # Only log if we didn't already log migration
                logger.info(f"[MIGRATION] Removing deprecated rpdb_key field for {redact_token(token)}")
            needs_save = True

        # Save back to redis if any changes were made
        if needs_save:
            try:
                if settings.TOKEN_TTL_SECONDS and settings.TOKEN_TTL_SECONDS > 0:
                    await redis_service.set(redis_key, json.dumps(data), settings.TOKEN_TTL_SECONDS)
                else:
                    await redis_service.set(redis_key, json.dumps(data))

                # Invalidate cache so next read gets the migrated data
                try:
                    self.get_user_data.cache_invalidate(token)
                except Exception:
                    pass

                logger.info(
                    "[MIGRATION] Successfully migrated and encrypted poster_rating " f"format for {redact_token(token)}"
                )
                return data
            except Exception as e:
                logger.warning(f"[MIGRATION] Failed to save migrated data for {redact_token(token)}: {e}")
                return None

        return None

    async def get_user_data(self, token: str) -> dict[str, Any] | None:
        data = await self._get_user_data_cached(token)
        if data is None:
            # Don't let a missing-token result get pinned in the per-process cache;
            # otherwise a token created on another worker would 401 here for hours.
            try:
                self._get_user_data_cached.cache_invalidate(token)
            except Exception:
                pass
        return data

    @alru_cache(maxsize=2000, ttl=43200)
    async def _get_user_data_cached(self, token: str) -> dict[str, Any] | None:
        logger.debug(f"[REDIS] Cache miss. Fetching data from redis for {token}")
        key = self._format_key(token)
        data_raw = await redis_service.get(key)

        if not data_raw:
            return None

        try:
            data = json.loads(data_raw)
        except json.JSONDecodeError:
            return None

        updated_data = await self._migrate_poster_rating_format_raw(token, key, data)
        if updated_data:
            data = updated_data

        # Decrypt fields individually; do not fail entire record on decryption errors
        if data.get("authKey"):
            try:
                data["authKey"] = self.decrypt_token(data["authKey"])
            except Exception as e:
                logger.warning(f"Decryption failed for authKey associated with {redact_token(token)}: {e}")
                # Leave as-is (legacy plaintext or previous failure)
                pass

        if data.get("trakt_refresh_token"):
            try:
                if data["trakt_refresh_token"].startswith("gAAAAA"):
                    data["trakt_refresh_token"] = self.decrypt_token(data["trakt_refresh_token"])
            except Exception as e:
                logger.debug(f"Decryption failed for trakt_refresh_token associated with {redact_token(token)}: {e}")
        if data.get("password"):
            try:
                data["password"] = self.decrypt_token(data["password"])
            except Exception as e:
                logger.warning(f"Decryption failed for password associated with {redact_token(token)}: {e}")
                # require re-login path when needed
                data["password"] = None

        # Decrypt poster_rating API key if present
        if data.get("settings") and isinstance(data["settings"], dict):
            poster_rating = data["settings"].get("poster_rating")
            if poster_rating and isinstance(poster_rating, dict) and poster_rating.get("api_key"):
                try:
                    if poster_rating["api_key"].startswith("gAAAAA"):
                        poster_rating["api_key"] = self.decrypt_token(poster_rating["api_key"])
                except Exception as e:
                    logger.debug(
                        f"Decryption failed for poster_rating api_key associated with {redact_token(token)}: {e}"
                    )

            simkl_api_key = data["settings"].get("simkl_api_key")
            if simkl_api_key:
                try:
                    if simkl_api_key.startswith("gAAAAA"):
                        data["settings"]["simkl_api_key"] = self.decrypt_token(simkl_api_key)
                except Exception as e:
                    logger.debug(f"Decryption failed for simkl_api_key associated with {redact_token(token)}: {e}")

            gemini_api_key = data["settings"].get("gemini_api_key")
            if gemini_api_key:
                try:
                    if gemini_api_key.startswith("gAAAAA"):
                        data["settings"]["gemini_api_key"] = self.decrypt_token(gemini_api_key)
                except Exception as e:
                    logger.debug(f"Decryption failed for gemini_api_key associated with {redact_token(token)}: {e}")

            tmdb_api_key = data["settings"].get("tmdb_api_key")
            if tmdb_api_key:
                try:
                    if tmdb_api_key.startswith("gAAAAA"):
                        data["settings"]["tmdb_api_key"] = self.decrypt_token(tmdb_api_key)
                except Exception as e:
                    logger.debug(f"Decryption failed for tmdb_api_key associated with {redact_token(token)}: {e}")

        return data

    async def delete_token(self, token: str = None, key: str = None) -> None:
        if not token and not key:
            raise ValueError("Either token or key must be provided")
        if token:
            key = self._format_key(token)

        await redis_service.delete(key)
        # we also need to delete the cached library items, profiles and watched sets
        if token:
            try:
                await user_cache.invalidate_all_user_data(token)
            except Exception as e:
                logger.warning(f"Failed to invalidate all user data for {redact_token(token)}: {e}")

        # Invalidate async LRU cache so future reads reflect deletion
        try:
            if token:
                self._get_user_data_cached.cache_invalidate(token)
            else:
                # If only key is provided, clear cache entirely to be safe
                self._get_user_data_cached.cache_clear()
        except KeyError:
            pass
        except Exception as e:
            logger.warning(f"Failed to invalidate user data cache during token deletion: {e}")

    async def count_users(self) -> int:
        """Count total users by scanning Redis keys with the configured prefix.

        Cached for 12 hours to avoid frequent Redis scans.
        """
        try:
            client = await redis_service.get_client()
        except (redis.RedisError, OSError) as exc:
            logger.warning(f"Cannot count users; Redis unavailable: {exc}")
            return 0

        pattern = f"{self.KEY_PREFIX}*"
        total = 0
        try:
            async for _ in client.scan_iter(match=pattern, count=500):
                total += 1
        except (redis.RedisError, OSError) as exc:
            logger.warning(f"Failed to scan for user count: {exc}")
            return 0
        return total


token_store = TokenStore()
" | base64 --decode > "$REPO/app/services/token_store.py" +echo " wrote app/services/token_store.py" + +mkdir -p "$REPO/app/services/recommendation" +echo "import random
import re
import time
from typing import Any

from fastapi import HTTPException
from loguru import logger

from app.core.config import settings
from app.core.constants import DEFAULT_CATALOG_LIMIT, DEFAULT_MIN_ITEMS
from app.core.security import redact_token
from app.core.settings import UserSettings, get_default_settings, resolve_tmdb_api_key
from app.models.taste_profile import TasteProfile
from app.services.catalog_updater import catalog_updater
from app.services.profile.integration import ProfileIntegration
from app.services.recommendation.all_based import AllBasedService
from app.services.recommendation.creators import CreatorsService
from app.services.recommendation.item_based import ItemBasedService
from app.services.recommendation.theme_based import ThemeBasedService
from app.services.recommendation.top_picks import TopPicksService
from app.services.recommendation.utils import pad_to_min
from app.services.stremio.service import StremioBundle
from app.services.tmdb.service import get_tmdb_service
from app.services.token_store import token_store
from app.services.user_cache import user_cache
from app.utils.catalog import cache_profile_and_watched_sets


def should_shuffle(user_settings: UserSettings, catalog_id: str) -> bool:
    config = next((c for c in user_settings.catalogs if c.id == catalog_id), None)
    return getattr(config, "shuffle", False) if config else False


def shuffle_data_if_needed(
    user_settings: UserSettings, catalog_id: str, data: list[dict[str, Any]]
) -> list[dict[str, Any]]:
    if should_shuffle(user_settings, catalog_id):
        random.shuffle(data)
    return data


def _clean_meta(meta: dict) -> dict | None:
    """Return a sanitized Stremio meta object without internal fields.

    Keeps only public keys and drops internal scoring/IDs/keywords/cast, etc.
    """
    allowed = {
        "id",
        "type",
        "name",
        "poster",
        "logo",
        "background",
        "description",
        "releaseInfo",
        "imdbRating",
        "genres",
        "runtime",
    }
    cleaned = {k: v for k, v in meta.items() if k in allowed}
    # Drop empty values
    cleaned = {k: v for k, v in cleaned.items() if v not in (None, "", [], {}, ())}

    # Normalize IMDb rating to a string with 1 decimal place
    rating = cleaned.get("imdbRating")
    if rating not in (None, ""):
        try:
            cleaned["imdbRating"] = f"{float(rating):.1f}"
        except (TypeError, ValueError):
            # Keep original value if it cannot be parsed
            pass

    imdb_id = cleaned.get("id", "")
    # if id does not start with tt, return None
    if not imdb_id.startswith("tt"):
        return None
    # Use Metahub logo only when no language-aware logo was set (e.g. from TMDB)
    if not cleaned.get("logo"):
        cleaned["logo"] = f"https://live.metahub.space/logo/medium/{imdb_id}/img"
    return cleaned


class CatalogService:
    def __init__(self):
        pass

    async def get_catalog(
        self, token: str, content_type: str, catalog_id: str
    ) -> tuple[dict[str, Any], dict[str, Any]]:
        """
        Get catalog recommendations.

        Args:
            token: User token
            content_type: Content type (movie/series)
            catalog_id: Catalog ID (watchly.rec, watchly.creators, watchly.theme.*, etc.)

        Returns:
            Tuple of (recommendations dict, response headers dict)
        """
        # Validate inputs
        self._validate_inputs(token, content_type, catalog_id)

        # Prepare response headers

        headers: dict[str, Any] = {
            "Access-Control-Allow-Origin": "*",
            "Access-Control-Allow-Headers": "*",
            "Content-Type": "application/json",
            "Cache-Control": (
                f"public, max-age={settings.CATALOG_CACHE_TTL}," "stale-while-revalidate=3600, stale-if-error=1800"
            ),
        }

        logger.info(f"[{redact_token(token)}...] Fetching catalog for {content_type} with id {catalog_id}")

        # Get credentials
        credentials = await token_store.get_user_data(token)
        if not credentials:
            logger.error("No credentials found for token")
            raise HTTPException(
                status_code=401,
                detail="Invalid or expired token. Please reconfigure the addon.",
            )

        # Trigger lazy update if needed
        if settings.AUTO_UPDATE_CATALOGS:
            logger.info(f"[{redact_token(token)}...] Triggering auto update for token")
            try:
                await catalog_updater.trigger_update(token, credentials)
            except Exception as e:
                logger.error(f"[{redact_token(token)}...] Failed to trigger auto update: {e}")
                # continue with the request even if the auto update fails
                pass

        bundle = StremioBundle()
        user_settings = None
        stale_data = None

        try:
            # get cached catalog
            cached_result = await user_cache.get_catalog(token, content_type, catalog_id)

            if cached_result:
                data, created_at = cached_result
                age = int(time.time()) - created_at

                # If data is fresh enough (within refresh interval), return it
                if age < settings.CATALOG_REFRESH_INTERVAL_SECONDS:
                    logger.debug(f"[{redact_token(token)}...] Using cached catalog for {content_type}/{catalog_id}")
                    # Try to extract settings from credentials for shuffling, even on cached path
                    user_settings = self._extract_settings(credentials)
                    meta_data = data["metas"]
                    meta_data = shuffle_data_if_needed(user_settings, catalog_id, meta_data)
                    data["metas"] = meta_data
                    return data, headers

                # If data is stale, keep it for fallback
                stale_data = data
                logger.info(
                    f"[{redact_token(token)}...] Catalog is stale (age: {age}s) for {content_type}/{catalog_id},"
                    "refreshing..."
                )
            else:
                logger.info(
                    f"[{redact_token(token)}...] Catalog not cached for {content_type}/{catalog_id}, building from"
                    " scratch"
                )

            # Resolve auth and settings
            auth_key = await self._resolve_auth(bundle, credentials, token)
            user_settings = self._extract_settings(credentials)

            language = user_settings.language if user_settings else "en-US"

            # Try to get cached library items first
            library_items = await user_cache.get_library_items(token)

            if library_items:
                logger.debug(f"[{redact_token(token)}...] Using cached library items")
            else:
                # Fetch library if not cached
                logger.info(f"[{redact_token(token)}...] Library items not cached, fetching from Stremio")
                library_items = await bundle.library.get_library_items(auth_key)
                # Cache it for future use
                await user_cache.set_library_items(token, library_items)

            services = self._initialize_services(language, user_settings)
            integration_service: ProfileIntegration = services["integration"]

            # Try to get cached profile and watched sets
            cached_data = await user_cache.get_profile_and_watched_sets(token, content_type)

            if cached_data:
                # Use cached profile and watched sets
                profile, watched_tmdb, watched_imdb = cached_data
                logger.debug(f"[{redact_token(token)}...] Using cached profile and watched sets for {content_type}")
            else:
                # Build profile if not cached
                logger.info(f"[{redact_token(token)}...] Profile not cached for {content_type}, building from library")
                (
                    profile,
                    watched_tmdb,
                    watched_imdb,
                ) = await cache_profile_and_watched_sets(
                    token,
                    content_type,
                    integration_service,
                    library_items,
                    bundle,
                    auth_key,
                )

            whitelist = await integration_service.get_genre_whitelist(profile, content_type) if profile else set()

            # Route to appropriate recommendation service
            recommendations = await self._get_recommendations(
                catalog_id=catalog_id,
                content_type=content_type,
                services=services,
                profile=profile,
                watched_tmdb=watched_tmdb,
                watched_imdb=watched_imdb,
                whitelist=whitelist,
                library_items=library_items,
                limit=DEFAULT_CATALOG_LIMIT,
                user_settings=user_settings,
            )

            # Pad if needed to meet minimum of 8 items
            # # TODO: This is risky because it can fetch too many unrelated items.
            if recommendations and len(recommendations) < DEFAULT_MIN_ITEMS:
                recommendations = await pad_to_min(
                    content_type,
                    recommendations,
                    DEFAULT_MIN_ITEMS,
                    services["tmdb"],
                    user_settings,
                    watched_tmdb,
                    watched_imdb,
                )

            logger.info(f"Returning {len(recommendations)} items for {content_type}")

            # Clean and format metadata
            cleaned = [_clean_meta(m) for m in recommendations]
            cleaned = [m for m in cleaned if m is not None]

            cleaned = shuffle_data_if_needed(user_settings, catalog_id, cleaned)

            data = {"metas": cleaned}
            # if catalog data is not empty, set the cache with STALE_TTL (7 days)
            # This ensures we have fallback data available if the next refresh fails
            if cleaned:
                await user_cache.set_catalog(token, content_type, catalog_id, data, settings.CATALOG_STALE_TTL)

            return data, headers

        except Exception as e:
            logger.error(f"[{redact_token(token)}...] Failed to generate catalog: {e}")

            # Fallback 1: Return Stale Data if available
            if stale_data:
                logger.warning(
                    f"[{redact_token(token)}...] Serving stale content for {content_type}/{catalog_id} due to error"
                )
                # Shuffle stale data too if needed
                user_settings = user_settings or self._extract_settings(credentials)
                meta_data = stale_data.get("metas", [])
                meta_data = shuffle_data_if_needed(user_settings, catalog_id, meta_data)
                stale_data["metas"] = meta_data
                return stale_data, headers

            # Fallback 2: Return Empty (prevents 500 error)
            return {"metas": []}, headers

        finally:
            await bundle.close()

    def _validate_inputs(self, token: str, content_type: str, catalog_id: str) -> None:
        if not token:
            raise HTTPException(
                status_code=400,
                detail="Missing credentials token. Please open Watchly from a configured manifest URL.",
            )

        if content_type not in ["movie", "series"]:
            logger.warning(f"Invalid type: {content_type}")
            raise HTTPException(status_code=400, detail="Invalid type. Use 'movie' or 'series'")

        # Supported IDs
        supported_base = [
            "watchly.rec",
            "watchly.creators",
            "watchly.all.loved",
            "watchly.liked.all",
        ]
        supported_prefixes = ("watchly.theme.", "watchly.loved.", "watchly.watched.")
        if catalog_id not in supported_base and not any(catalog_id.startswith(p) for p in supported_prefixes):
            logger.warning(f"Invalid id: {catalog_id}")
            raise HTTPException(
                status_code=400,
                detail=(
                    "Invalid id. Supported: 'watchly.rec', 'watchly.creators', "
                    "'watchly.theme.<params>', 'watchly.all.loved', 'watchly.liked.all'"
                ),
            )

    async def _resolve_auth(self, bundle: StremioBundle, credentials: dict, token: str) -> str:
        auth_key = credentials.get("authKey")

        # Trakt accounts use a Trakt access token stored as authKey.
        # Skip Stremio session validation entirely for these accounts.
        if credentials.get("auth_provider") == "trakt":
            if not auth_key:
                raise HTTPException(status_code=401, detail="Trakt session expired. Please reconfigure.")
            return auth_key

        email = credentials.get("email")
        password = credentials.get("password")

        # Validate existing auth key
        is_valid = False
        if auth_key:
            try:
                await bundle.auth.get_user_info(auth_key)
                is_valid = True
            except Exception as e:
                logger.error(f"Failed to validate auth key during catalog fetch: {e}")
                pass

        # Try to refresh if invalid
        if not is_valid and email and password:
            try:
                auth_key = await bundle.auth.login(email, password)
                credentials["authKey"] = auth_key
                # Update token store with refreshed credentials
                await token_store.update_user_data(token, credentials)
            except Exception as e:
                logger.error(f"Failed to refresh auth key during catalog fetch: {e}")

        if not auth_key:
            logger.error("No auth key found during catalog fetch")
            raise HTTPException(status_code=401, detail="Stremio session expired. Please reconfigure.")

        return auth_key

    def _extract_settings(self, credentials: dict) -> UserSettings:
        settings_dict = credentials.get("settings", {})
        return UserSettings(**settings_dict) if settings_dict else get_default_settings()

    async def _get_trending_fallback(
        self, content_type: str, limit: int = 20, user_settings: UserSettings | None = None
    ) -> list[dict[str, Any]]:
        """Get trending items for new users without profiles."""
        from app.services.recommendation.utils import content_type_to_mtype

        mtype = content_type_to_mtype(content_type)
        tmdb_key = resolve_tmdb_api_key(user_settings)
        language = user_settings.language if user_settings else "en-US"
        tmdb_service = get_tmdb_service(language=language, api_key=tmdb_key)

        try:
            # Fetch trending week
            trending = await tmdb_service.get_trending(mtype, "week")
            items = trending.get("results", [])

            # Enrich metadata
            from app.services.recommendation.metadata import RecommendationMetadata

            return await RecommendationMetadata.fetch_batch(tmdb_service, items, content_type, user_settings=None)
        except Exception as e:
            logger.warning(f"Failed to fetch trending items: {e}")
            return []

    def _initialize_services(self, language: str, user_settings: UserSettings) -> dict[str, Any]:
        tmdb_key = resolve_tmdb_api_key(user_settings)
        tmdb_service = get_tmdb_service(language=language, api_key=tmdb_key)
        return {
            "tmdb": tmdb_service,
            "integration": ProfileIntegration(language=language, tmdb_api_key=tmdb_key),
            "item": ItemBasedService(tmdb_service, user_settings),
            "theme": ThemeBasedService(tmdb_service, user_settings),
            "top_picks": TopPicksService(tmdb_service, user_settings),
            "creators": CreatorsService(tmdb_service, user_settings),
            "all_based": AllBasedService(tmdb_service, user_settings),
        }

    async def _get_recommendations(
        self,
        catalog_id: str,
        content_type: str,
        services: dict[str, Any],
        profile: TasteProfile | None,
        watched_tmdb: set[int],
        watched_imdb: set[str],
        whitelist: set[int],
        library_items: dict,
        limit: int,
        user_settings: UserSettings | None = None,
    ) -> list[dict[str, Any]]:
        """Route to appropriate recommendation service based on catalog ID."""
        # Item-based recommendations
        if any(
            catalog_id.startswith(p)
            for p in (
                "watchly.loved.",
                "watchly.watched.",
            )
        ):
            # Extract item ID
            item_id = re.sub(r"^watchly\.(loved|watched)\.", "", catalog_id)

            item_service: ItemBasedService = services["item"]

            recommendations = await item_service.get_recommendations_for_item(
                item_id=item_id,
                content_type=content_type,
                watched_tmdb=watched_tmdb,
                watched_imdb=watched_imdb,
                limit=limit,
                whitelist=whitelist,
            )
            logger.info(f"Found {len(recommendations)} recommendations for item {item_id}")

        # Theme-based recommendations
        elif catalog_id.startswith("watchly.theme."):
            theme_service: ThemeBasedService = services["theme"]

            recommendations = await theme_service.get_recommendations_for_theme(
                theme_id=catalog_id,
                content_type=content_type,
                profile=profile,
                watched_tmdb=watched_tmdb,
                watched_imdb=watched_imdb,
                limit=limit,
                whitelist=whitelist,
            )
            logger.info(f"Found {len(recommendations)} recommendations for theme {catalog_id}")

        # Creators-based recommendations
        elif catalog_id == "watchly.creators":
            creators_service: CreatorsService = services["creators"]

            if profile:
                recommendations = await creators_service.get_recommendations_from_creators(
                    profile=profile,
                    content_type=content_type,
                    watched_tmdb=watched_tmdb,
                    watched_imdb=watched_imdb,
                    limit=limit,
                )
            else:
                logger.info(f"No profile for creators, showing trending {content_type}")
                recommendations = await self._get_trending_fallback(content_type, limit, user_settings)
            logger.info(f"Found {len(recommendations)} recommendations from creators")

        # Top picks
        elif catalog_id == "watchly.rec":
            if profile:
                top_picks_service: TopPicksService = services["top_picks"]

                recommendations = await top_picks_service.get_top_picks(
                    profile=profile,
                    content_type=content_type,
                    library_items=library_items,
                    watched_tmdb=watched_tmdb,
                    watched_imdb=watched_imdb,
                    limit=limit,
                )
            else:
                logger.info(f"No profile for top picks, showing trending {content_type}")
                recommendations = await self._get_trending_fallback(content_type, limit, user_settings)
            logger.info(f"Found {len(recommendations)} top picks for {content_type}")

        # Based on what you loved
        elif catalog_id in ("watchly.all.loved", "watchly.liked.all"):
            item_type = "loved" if catalog_id == "watchly.all.loved" else "liked"
            all_based_service: AllBasedService = services["all_based"]
            recommendations = await all_based_service.get_recommendations_from_all_items(
                library_items=library_items,
                content_type=content_type,
                watched_tmdb=watched_tmdb,
                watched_imdb=watched_imdb,
                whitelist=whitelist,
                limit=limit,
                item_type=item_type,
                profile=profile,
            )
            logger.info(f"Found {len(recommendations)} recommendations based on all {item_type} items")

        else:
            logger.warning(f"Unknown catalog ID: {catalog_id}")
            recommendations = []

        return recommendations


catalog_service = CatalogService()
" | base64 --decode > "$REPO/app/services/recommendation/catalog_service.py" +echo " wrote app/services/recommendation/catalog_service.py" + +echo "VE1EQl9BUElfS0VZPTx5b3VyX3RtZGJfYXBpX2tleT4KUkVESVNfVVJMPXJlZGlzOi8vcmVkaXM6NjM3OS8wClRPS0VOX1NBTFQ9Y2hhbmdlLW1lICMgZ2VuZXJhdGUgc2VjdXJlIHNhbHQuLi4KCiMgYXBwIHNldHVwCkFQUF9FTlY9ImRldmVsb3BtZW50IiAgIyBhdmFpbGFibGUgdmFsdWVzIGFyZSBbImRldmVsb3BtZW50IiwgInByb2R1Y3Rpb24iXQpIT1NUX05BTUU9PHlvdXJfYWRkb25fdXJsPgpQT1JUPTgwMDAKCiMgcmVkaXMKUkVESVNfTUFYX0NPTk5FQ1RJT05TPTIwClJFRElTX0NPTk5FQ1RJT05TX1RIUkVTSE9MRD0xMDAKCiMgVVBEQVRFUgpBVVRPX1VQREFURV9DQVRBTE9HUz1UcnVlCkNBVEFMT0dfUkVGUkVTSF9JTlRFUlZBTF9TRUNPTkRTPTIxNjAwICMgNio2MCo2MCBldmVyeSB+NiBob3VycwoKIyBBSSBDYXRhbG9nIG5hbWUgZ2VuZXJhdGlvbgpHRU1JTklfQVBJX0tFWT08eW91cl9nZW1pbmlfYXBpX2tleT4gICAjIE9wdGlvbmFsCkRFRkFVTFRfR0VNSU5JX01PREVMPSJnZW1tYS0zLTI3Yi1pdCIKCiMgVHJha3QgT0F1dGggKG9wdGlvbmFsIC0gZW5hYmxlcyBUcmFrdCBsb2dpbiBvbiB0aGUgY29uZmlndXJlIHBhZ2UpCiMgUmVnaXN0ZXIgeW91ciBhcHAgYXQgaHR0cHM6Ly90cmFrdC50di9vYXV0aC9hcHBsaWNhdGlvbnMKVFJBS1RfQ0xJRU5UX0lEPTx5b3VyX3RyYWt0X2NsaWVudF9pZD4KVFJBS1RfQ0xJRU5UX1NFQ1JFVD08eW91cl90cmFrdF9jbGllbnRfc2VjcmV0Pgo=" | base64 --decode > "$REPO/.env.example" +echo " wrote .env.example" + +echo "IyBXYXRjaGx5Cgo8ZGl2IGFsaWduPSJjZW50ZXIiPgoKPCEtLSBQcmVtaXVtIEJhZGdlIENvbGxlY3Rpb24gLS0+ClshW1ZlcnNpb25dKGh0dHBzOi8vaW1nLnNoaWVsZHMuaW8vZ2l0aHViL3YvcmVsZWFzZS90aW1pbHNpbmFiaW1hbC93YXRjaGx5P3N0eWxlPWZvci10aGUtYmFkZ2UmbG9nbz1zZW12ZXImY29sb3I9NjM2NmYxKV0oaHR0cHM6Ly9naXRodWIuY29tL3RpbWlsc2luYWJpbWFsL3dhdGNobHkvcmVsZWFzZXMpClshW0xpY2Vuc2VdKGh0dHBzOi8vaW1nLnNoaWVsZHMuaW8vYmFkZ2UvTGljZW5zZS1NSVQtMjJjNTVlP3N0eWxlPWZvci10aGUtYmFkZ2UmbG9nbz1vcGVuc291cmNlaW5pdGlhdGl2ZSZsb2dvQ29sb3I9d2hpdGUpXShMSUNFTlNFKQpbIVtHaXRIdWIgU3RhcnNdKGh0dHBzOi8vaW1nLnNoaWVsZHMuaW8vZ2l0aHViL3N0YXJzL3RpbWlsc2luYWJpbWFsL3dhdGNobHk/c3R5bGU9Zm9yLXRoZS1iYWRnZSZjb2xvcj1mNTllMGImbG9nbz1naXRodWIpXShodHRwczovL2dpdGh1Yi5jb20vdGltaWxzaW5hYmltYWwvd2F0Y2hseS9zdGFyZ2F6ZXJzKQpbIVtCdXkgbWUgIENvZmZlZV0oaHR0cHM6Ly9pbWcuc2hpZWxkcy5pby9iYWRnZS9Lby0tZmktU3VwcG9ydC1GMTYwNjE/c3R5bGU9Zm9yLXRoZS1iYWRnZSZsb2dvPWtvZmkmbG9nb0NvbG9yPXdoaXRlKV0oaHR0cHM6Ly9rby1maS5jb20vdGltaWxzaW5hYmltYWwpCgo8L2Rpdj4KPGJyLz4KCioqV2F0Y2hseSoqIGlzIGEgU3RyZW1pbyBjYXRhbG9nIGFkZG9uIHRoYXQgcHJvdmlkZXMgcGVyc29uYWxpemVkIG1vdmllIGFuZCBzZXJpZXMgcmVjb21tZW5kYXRpb25zIGJhc2VkIG9uIHlvdXIgU3RyZW1pbyBsaWJyYXJ5LiBJdCB1c2VzIFRoZSBNb3ZpZSBEYXRhYmFzZSAoVE1EQikgQVBJIHRvIGdlbmVyYXRlIGludGVsbGlnZW50IHJlY29tbWVuZGF0aW9ucyBmcm9tIHRoZSBjb250ZW50IHlvdSd2ZSB3YXRjaGVkIGFuZCBsb3ZlZC4KCiMjIEZlYXR1cmVzCgotICoqUGVyc29uYWxpemVkIFJlY29tbWVuZGF0aW9ucyoqOiBBbmFseXplcyB5b3VyIFN0cmVtaW8gb3IgVHJha3QgbGlicmFyeSB0byB1bmRlcnN0YW5kIHlvdXIgdmlld2luZyBwcmVmZXJlbmNlcy4KLSAqKlRyYWt0IEludGVncmF0aW9uKio6IExvZyBpbiB3aXRoIFRyYWt0IGluc3RlYWQgb2YgU3RyZW1pbyDigJQgbm8gU3RyZW1pbyBhY2NvdW50IHJlcXVpcmVkLgotICoqU21hcnQgRmlsdGVyaW5nKio6IEF1dG9tYXRpY2FsbHkgZXhjbHVkZXMgY29udGVudCB5b3UndmUgYWxyZWFkeSB3YXRjaGVkLgotICoqQWR2YW5jZWQgU2NvcmluZyoqOiBSZWNvbW1lbmRhdGlvbnMgYXJlIGludGVsbGlnZW50bHkgd2VpZ2h0ZWQgYnkgcmVjZW5jeSBhbmQgcmVsZXZhbmNlLgotICoqR2VucmUtQmFzZWQgRGlzY292ZXJ5Kio6IE9mZmVycyBnZW5yZS1zcGVjaWZpYyBjYXRhbG9ncyBiYXNlZCBvbiB5b3VyIHZpZXdpbmcgaGlzdG9yeS4KLSAqKlNpbWlsYXIgQ29udGVudCoqOiBEaXNjb3ZlciBjb250ZW50IHNpbWlsYXIgdG8gc3BlY2lmaWMgdGl0bGVzIGluIHlvdXIgbGlicmFyeS4KLSAqKldlYiBDb25maWd1cmF0aW9uKio6IEVhc3ktdG8tdXNlIHdlYiBpbnRlcmZhY2UgZm9yIHNlY3VyZSBzZXR1cC4KLSAqKlNlY3VyZSBBcmNoaXRlY3R1cmUqKjogQ3JlZGVudGlhbHMgYXJlIHN0b3JlZCBzZWN1cmVseSBhbmQgbmV2ZXIgZXhwb3NlZCBpbiBVUkxzLgotICoqQmFja2dyb3VuZCBTeW5jKio6IEtlZXBzIHlvdXIgY2F0YWxvZ3MgdXBkYXRlZCBhdXRvbWF0aWNhbGx5IGluIHRoZSBiYWNrZ3JvdW5kLgotICoqUGVyZm9ybWFuY2UgT3B0aW1pemVkKio6IEludGVsbGlnZW50IGNhY2hpbmcgZm9yIGZhc3QgYW5kIHJlbGlhYmxlIHJlc3BvbnNlcy4KCiMjIyBTY3JlZW5zaG90CjxpbWcgc3JjPSIuL2FwcC9zdGF0aWMvc2NyZWVuc2hvdHMvaG9tZXBhZ2UucG5nIiBhbHQ9IlRvcCBQaWNrcyIgd2lkdGg9IjgwMCIvPgoKCkZpbmQgbW9yZSBzY3JlZW5zaG90cyBbaGVyZV0oLi9hcHAvc3RhdGljL3NjcmVlbnNob3RzLykKIyMgSW5zdGFsbGF0aW9uCgojIyMgVXNpbmcgRG9ja2VyIChSZWNvbW1lbmRlZCkKCllvdSBjYW4gcHVsbCB0aGUgbGF0ZXN0IGltYWdlIGZyb20gdGhlIEdpdEh1YiBDb250YWluZXIgUmVnaXN0cnkuCgoxLiAgKipDcmVhdGUgYSBgZG9ja2VyLWNvbXBvc2UueW1sYCBmaWxlOioqCgogICAgYGBgeWFtbAogICAgc2VydmljZXM6CiAgICAgIHJlZGlzOgogICAgICAgIGltYWdlOiByZWRpczo3LWFscGluZQogICAgICAgIGNvbnRhaW5lcl9uYW1lOiB3YXRjaGx5LXJlZGlzCiAgICAgICAgcmVzdGFydDogdW5sZXNzLXN0b3BwZWQKICAgICAgICB2b2x1bWVzOgogICAgICAgICAgLSByZWRpc19kYXRhOi9kYXRhCgogICAgICB3YXRjaGx5OgogICAgICAgIGltYWdlOiBnaGNyLmlvL3RpbWlsc2luYWJpbWFsL3dhdGNobHk6bGF0ZXN0CiAgICAgICAgY29udGFpbmVyX25hbWU6IHdhdGNobHkKICAgICAgICByZXN0YXJ0OiB1bmxlc3Mtc3RvcHBlZAogICAgICAgIHBvcnRzOgogICAgICAgICAgLSAiODAwMDo4MDAwIgogICAgICAgIGVudl9maWxlOgogICAgICAgICAgLSAuZW52CiAgICAgICAgZGVwZW5kc19vbjoKICAgICAgICAgIC0gcmVkaXMKCiAgICB2b2x1bWVzOgogICAgICByZWRpc19kYXRhOgogICAgYGBgCgoyLiAgKipDcmVhdGUgYSBgLmVudmAgZmlsZToqKgoKICAgIGBgYGVudgogICAgIyBSZXF1aXJlZAogICAgVE1EQl9BUElfS0VZPXlvdXJfdG1kYl9hcGlfa2V5X2hlcmUKICAgIFRPS0VOX1NBTFQ9Z2VuZXJhdGVfYV9yYW5kb21fc2VjdXJlX3N0cmluZ19oZXJlICAjIHB5dGhvbjMgLWMgImltcG9ydCBzZWNyZXRzOyBwcmludChzZWNyZXRzLnRva2VuX2hleCgzMikpIgogICAgSE9TVF9OQU1FPXlvdXJfYWRkb25fdXJsCgogICAgIyBPcHRpb25hbAogICAgUE9SVD04MDAwCiAgICBSRURJU19VUkw9cmVkaXM6Ly9yZWRpczo2Mzc5LzAKICAgIEFERE9OX0lEPWNvbS5iaW1hbC53YXRjaGx5CiAgICBBRERPTl9OQU1FPVdhdGNobHkKICAgIFRPS0VOX1RUTF9TRUNPTkRTPTAKICAgIEFVVE9fVVBEQVRFX0NBVEFMT0dTPXRydWUKCiAgICAjIFRyYWt0IEludGVncmF0aW9uIChvcHRpb25hbCDigJQgZW5hYmxlcyBUcmFrdCBsb2dpbiBvbiB0aGUgY29uZmlndXJlIHBhZ2UpCiAgICAjIFJlZ2lzdGVyIHlvdXIgYXBwIGF0IGh0dHBzOi8vdHJha3QudHYvb2F1dGgvYXBwbGljYXRpb25zL25ldwogICAgIyBTZXQgdGhlIHJlZGlyZWN0IFVSSSB0bzogaHR0cHM6Ly95b3VyX2FkZG9uX3VybC90b2tlbnMvdHJha3QvY2FsbGJhY2sKICAgIFRSQUtUX0NMSUVOVF9JRD15b3VyX3RyYWt0X2NsaWVudF9pZAogICAgVFJBS1RfQ0xJRU5UX1NFQ1JFVD15b3VyX3RyYWt0X2NsaWVudF9zZWNyZXQKICAgIGBgYAoKMy4gICoqU3RhcnQgdGhlIGFwcGxpY2F0aW9uOioqCgogICAgYGBgYmFzaAogICAgZG9ja2VyLWNvbXBvc2UgdXAgLWQKICAgIGBgYAoKNC4gICoqQ29uZmlndXJlIHRoZSBhZGRvbjoqKgogICAgT3BlbiBgaHR0cDovL2xvY2FsaG9zdDo4MDAwL2NvbmZpZ3VyZWAgaW4geW91ciBicm93c2VyLiBMb2cgaW4gd2l0aCBlaXRoZXIgeW91ciAqKlN0cmVtaW8qKiBjcmVkZW50aWFscyBvciB5b3VyICoqVHJha3QqKiBhY2NvdW50LCB0aGVuIGNvbmZpZ3VyZSB5b3VyIHByZWZlcmVuY2VzIGFuZCBpbnN0YWxsIHRoZSBhZGRvbi4KCiMjIERldmVsb3BtZW50CgpUbyBydW4gdGhlIHByb2plY3QgbG9jYWxseToKCjEuICAqKkNsb25lIHRoZSByZXBvc2l0b3J5OioqCiAgICBgYGBiYXNoCiAgICBnaXQgY2xvbmUgaHR0cHM6Ly9naXRodWIuY29tL1RpbWlsc2luYUJpbWFsL1dhdGNobHkuZ2l0CiAgICBjZCBXYXRjaGx5CiAgICBgYGAKCjIuICAqKkluc3RhbGwgZGVwZW5kZW5jaWVzOioqCiAgICBJIHJlY29tbWVuZCB1c2luZyBbdXZdKGh0dHBzOi8vZ2l0aHViLmNvbS9hc3RyYWwtc2gvdXYpIGZvciBmYXN0IGRlcGVuZGVuY3kgbWFuYWdlbWVudC4KICAgIGBgYGJhc2gKICAgIHV2IHN5bmMKICAgIGBgYAoKMy4gICoqUnVuIHRoZSBhcHBsaWNhdGlvbjoqKgogICAgYGBgYmFzaAogICAgdXYgcnVuIG1haW4ucHkgLS1kZXYKICAgIGBgYAoKIyMgQ29udHJpYnV0aW5nCgpJIHdlbGNvbWUgY29udHJpYnV0aW9ucyBvZiBhbGwgc2l6ZXMhCgotICoqU21hbGwgQnVnIEZpeGVzICYgSW1wcm92ZW1lbnRzKio6IEZlZWwgZnJlZSB0byBvcGVuIGEgUHVsbCBSZXF1ZXN0IGRpcmVjdGx5LgotICoqTWFqb3IgRmVhdHVyZXMgJiBSZWZhY3RvcnMqKjogUGxlYXNlICoqW29wZW4gYW4gaXNzdWVdKGh0dHBzOi8vZ2l0aHViLmNvbS9UaW1pbHNpbmFCaW1hbC9XYXRjaGx5L2lzc3VlcykqKiB0byBkaXNjdXNzIHlvdXIgcHJvcG9zZWQgY2hhbmdlcy4gVGhpcyBoZWxwcyBlbnN1cmUgeW91ciB3b3JrIGFsaWducyB3aXRoIHRoZSBwcm9qZWN0J3MgZGlyZWN0aW9uIGFuZCBzYXZlcyB5b3UgdGltZS4KCiMjIEZ1bmRpbmcgJiBTdXBwb3J0CgpJZiB5b3UgZmluZCBXYXRjaGx5IHVzZWZ1bCwgcGxlYXNlIGNvbnNpZGVyIHN1cHBvcnRpbmcgdGhlIHByb2plY3Q6Ci0gW0J1eSBtZSBNbzpNb10oaHR0cHM6Ly9idXltZW1vbW8uY29tL3RpbWlsc2luYWJpbWFsKQotIFtTdXBwb3J0IG9uIEtvLWZpXShodHRwczovL2tvLWZpLmNvbS9JMkk4MU9WSkVIKQotIFtEb25hdGUgdmlhIFBheVBhbF0oaHR0cHM6Ly93d3cucGF5cGFsLmNvbS9kb25hdGUvP2hvc3RlZF9idXR0b25faWQ9S1JRTVZTMzRGQzVLQykKCiMjIEJ1ZyBSZXBvcnRzCgpGb3VuZCBhIGJ1ZyBvciBoYXZlIGEgZmVhdHVyZSByZXF1ZXN0PyBQbGVhc2UgW29wZW4gYW4gaXNzdWVdKGh0dHBzOi8vZ2l0aHViLmNvbS9UaW1pbHNpbmFCaW1hbC9XYXRjaGx5L2lzc3Vlcykgb24gR2l0SHViLgoKIyMgQ29udHJpYnV0b3JzCgpUaGFuayB5b3UgdG8gZXZlcnlvbmUgd2hvIGhhcyBjb250cmlidXRlZCB0byB0aGUgcHJvamVjdCEKCjxhIGhyZWY9Imh0dHBzOi8vZ2l0aHViLmNvbS9UaW1pbHNpbmFCaW1hbC93YXRjaGx5L2dyYXBocy9jb250cmlidXRvcnMiPgogIDxpbWcgc3JjPSJodHRwczovL2NvbnRyaWIucm9ja3MvaW1hZ2U/cmVwbz1UaW1pbHNpbmFCaW1hbC93YXRjaGx5IiAvPgo8L2E+CgojIyBBY2tub3dsZWRnZW1lbnRzCgpTcGVjaWFsIHRoYW5rcyB0byAqKltUaGUgTW92aWUgRGF0YWJhc2UgKFRNREIpXShodHRwczovL3d3dy50aGVtb3ZpZWRiLm9yZy8pKiogZm9yIHByb3ZpZGluZyB0aGUgcmljaCBtZXRhZGF0YSB0aGF0IHBvd2VycyBXYXRjaGx5J3MgcmVjb21tZW5kYXRpb25zLgo=" | base64 --decode > "$REPO/README.md" +echo " wrote README.md" + +echo "" +echo "All done! Restart the server with: uv run main.py" \ No newline at end of file