Update app.py

app.py

@@ -1,6 +1,5 @@
-from fastapi import FastAPI, Request, Form
+from fastapi import FastAPI, Request, Form, HTTPException, Query
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
 from fastapi.responses import HTMLResponse, RedirectResponse, JSONResponse
 import httpx
 import json
@@ -8,8 +7,12 @@ import logging
 import os
 import asyncio
 import secrets
+import shutil
+import tempfile
 import html as html_escape_lib
+from typing import Optional, List
 from datetime import datetime, timezone
+from huggingface_hub import HfApi, hf_hub_download
 
 # ==================================================
 # APP SETUP
@@ -25,19 +28,24 @@ app.add_middleware(
 )
 
 # ==================================================
-# STORAGE
+# CONFIG & CONSTANTS
 # ==================================================
-DATA_ROOT = os.environ.get("PERSISTENT_DIR", "/data")
-VIDEO_DIR = os.path.join(DATA_ROOT, "videos")
-INDEX_FILE = os.path.join(DATA_ROOT, "index.json")
-ADMIN_CONFIG_FILE = os.path.join(DATA_ROOT, "admin_config.json")
+# Hugging Face Configuration
+HF_TOKEN = os.environ.get("hf1")
+HF_REPO_ID = "SalexAI/fundata-2.0"
+HF_REPO_TYPE = "dataset"
 
-os.makedirs(VIDEO_DIR, exist_ok=True)
+# Division Configuration
+TOTAL_DIVISIONS = 25
+VALID_DIVISIONS = set(range(1, TOTAL_DIVISIONS + 1))
+
+# Local Temporary Storage (for processing before upload)
+TEMP_DIR = tempfile.mkdtemp()
 
 # ==================================================
-# ADMIN AUTH (ENV ONLY)
+# ADMIN AUTH
 # ==================================================
-ADMIN_KEY = os.environ.get("ADMIN_KEY")  # REQUIRED (no default; code can be public)
+ADMIN_KEY = os.environ.get("ADMIN_KEY")
 ADMIN_COOKIE = "admin_session"
 ADMIN_SESSIONS = set()
 
@@ -48,14 +56,13 @@ def is_admin(req: Request) -> bool:
     return req.cookies.get(ADMIN_COOKIE) in ADMIN_SESSIONS
 
 def secure_equals(a: str, b: str) -> bool:
-    # constant-time compare
     try:
         return secrets.compare_digest(a.encode("utf-8"), b.encode("utf-8"))
     except Exception:
         return False
 
 # ==================================================
-# DEFAULT ALBUM MAPS (used only if admin_config.json missing)
+# DEFAULT MAPS
 # ==================================================
 DEFAULT_ALBUM_PUBLISHERS = {
     "B2c5n8hH4uWRoAW": "Alex Rose",
@@ -79,97 +86,156 @@ ALBUM_PUBLISHERS = dict(DEFAULT_ALBUM_PUBLISHERS)
 ALBUM_CATEGORIES = dict(DEFAULT_ALBUM_CATEGORIES)
 
 # ==================================================
-# LOCKS (avoid json corruption)
+# LOCKS & STATE
 # ==================================================
-INDEX_LOCK = asyncio.Lock()
-CONFIG_LOCK = asyncio.Lock()
+# We use in-memory cache for the index to avoid spamming HF API,
+# but we write back to HF on changes.
+INDEX_CACHE = {"videos": []}
+CONFIG_CACHE = {}
+DATA_LOCK = asyncio.Lock()
 
 # ==================================================
 # HTTP CLIENT
 # ==================================================
 async def get_client() -> httpx.AsyncClient:
     if not hasattr(app.state, "client"):
-        app.state.client = httpx.AsyncClient(timeout=20.0)
+        app.state.client = httpx.AsyncClient(timeout=30.0)
     return app.state.client
 
 # ==================================================
-# JSON FILE HELPERS (atomic)
+# HUGGING FACE STORAGE HELPERS
 # ==================================================
-def _atomic_write_json(path: str, data: dict):
-    tmp = path + ".tmp"
-    with open(tmp, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2)
-    os.replace(tmp, path)
+api = HfApi(token=HF_TOKEN)
+
+def get_hf_url(path_in_repo: str) -> str:
+    """Returns the direct download URL for a file in the dataset."""
+    return f"https://huggingface.co/datasets/{HF_REPO_ID}/resolve/main/{path_in_repo}"
+
+async def sync_pull_json(filename: str, default: dict) -> dict:
+    """Download JSON from HF. Returns default if not found."""
+    try:
+        # Run blocking HF call in thread
+        loop = asyncio.get_event_loop()
+        local_path = await loop.run_in_executor(
+            None,
+            lambda: hf_hub_download(
+                repo_id=HF_REPO_ID,
+                filename=filename,
+                repo_type=HF_REPO_TYPE,
+                token=HF_TOKEN,
+                local_dir=TEMP_DIR
+            )
+        )
+        with open(local_path, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except Exception as e:
+        logging.warning(f"Could not pull {filename} from HF (using default): {e}")
+        return default
+
+async def sync_push_json(filename: str, data: dict):
+    """Upload JSON to HF."""
+    if not HF_TOKEN:
+        logging.error("No HF_TOKEN set, cannot save data.")
+        return
 
-def load_index_sync() -> dict:
-    if not os.path.exists(INDEX_FILE):
-        return {"videos": []}
-    with open(INDEX_FILE, "r", encoding="utf-8") as f:
-        return json.load(f)
+    try:
+        # Save to temp
+        temp_path = os.path.join(TEMP_DIR, filename)
+        with open(temp_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+        
+        # Upload
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            None, 
+            lambda: api.upload_file(
+                path_or_fileobj=temp_path,
+                path_in_repo=filename,
+                repo_id=HF_REPO_ID,
+                repo_type=HF_REPO_TYPE,
+                commit_message=f"Update {filename}"
+            )
+        )
+    except Exception as e:
+        logging.error(f"Failed to push {filename} to HF: {e}")
 
-def save_index_sync(data: dict):
-    _atomic_write_json(INDEX_FILE, data)
+async def sync_push_file(local_path: str, remote_path: str):
+    """Upload media file to HF."""
+    if not HF_TOKEN: 
+        return
+    try:
+        loop = asyncio.get_event_loop()
+        await loop.run_in_executor(
+            None,
+            lambda: api.upload_file(
+                path_or_fileobj=local_path,
+                path_in_repo=remote_path,
+                repo_id=HF_REPO_ID,
+                repo_type=HF_REPO_TYPE,
+                commit_message=f"Add media {remote_path}"
+            )
+        )
+    except Exception as e:
+        logging.error(f"Failed to push media {remote_path}: {e}")
 
-def load_admin_config_sync() -> dict:
-    if not os.path.exists(ADMIN_CONFIG_FILE):
-        return {
+# ==================================================
+# STATE MANAGEMENT
+# ==================================================
+async def load_state_from_hf():
+    global INDEX_CACHE, CONFIG_CACHE, ALBUM_PUBLISHERS, ALBUM_CATEGORIES
+    
+    async with DATA_LOCK:
+        INDEX_CACHE = await sync_pull_json("index.json", {"videos": []})
+        
+        default_config = {
             "album_publishers": dict(DEFAULT_ALBUM_PUBLISHERS),
             "album_categories": dict(DEFAULT_ALBUM_CATEGORIES),
         }
-    with open(ADMIN_CONFIG_FILE, "r", encoding="utf-8") as f:
-        return json.load(f)
-
-def save_admin_config_sync(cfg: dict):
-    _atomic_write_json(ADMIN_CONFIG_FILE, cfg)
+        CONFIG_CACHE = await sync_pull_json("admin_config.json", default_config)
+        
+        ALBUM_PUBLISHERS = dict(CONFIG_CACHE.get("album_publishers", {}))
+        ALBUM_CATEGORIES = dict(CONFIG_CACHE.get("album_categories", {}))
 
-async def load_admin_config():
-    async with CONFIG_LOCK:
-        return load_admin_config_sync()
+async def save_index():
+    # Caller should hold lock usually, but atomic write helps
+    await sync_push_json("index.json", INDEX_CACHE)
 
-async def write_admin_config(cfg: dict):
-    async with CONFIG_LOCK:
-        save_admin_config_sync(cfg)
-
-async def refresh_album_maps_from_disk():
-    global ALBUM_PUBLISHERS, ALBUM_CATEGORIES
-    cfg = await load_admin_config()
-    ALBUM_PUBLISHERS = dict(cfg.get("album_publishers", {}))
-    ALBUM_CATEGORIES = dict(cfg.get("album_categories", {}))
+async def save_config():
+    async with DATA_LOCK:
+        await sync_push_json("admin_config.json", CONFIG_CACHE)
 
 # ==================================================
-# BACKFILL CATEGORIES/PUBLISHERS
+# BACKFILL / UTILS
 # ==================================================
 async def backfill_index_categories():
-    try:
-        async with INDEX_LOCK:
-            idx = load_index_sync()
-            changed = False
-
-            for v in idx.get("videos", []):
-                token = v.get("source_album", "")
-                correct_category = ALBUM_CATEGORIES.get(token, "Uncategorized")
-                correct_publisher = ALBUM_PUBLISHERS.get(token, "Unknown")
-
-                if v.get("publisher") in (None, "", "Unknown") and correct_publisher != "Unknown":
-                    v["publisher"] = correct_publisher
-                    changed = True
-
-                if v.get("category") in (None, "", v.get("publisher")) or v.get("category") != correct_category:
-                    v["category"] = correct_category
-                    changed = True
-
-            if changed:
-                save_index_sync(idx)
-                logging.info("Backfilled index.json categories/publishers")
-    except Exception:
-        logging.exception("Backfill failed (non-fatal)")
+    async with DATA_LOCK:
+        changed = False
+        for v in INDEX_CACHE.get("videos", []):
+            token = v.get("source_album", "")
+            correct_category = ALBUM_CATEGORIES.get(token, "Uncategorized")
+            correct_publisher = ALBUM_PUBLISHERS.get(token, "Unknown")
+
+            if v.get("publisher") in (None, "", "Unknown") and correct_publisher != "Unknown":
+                v["publisher"] = correct_publisher
+                changed = True
+
+            if v.get("category") in (None, "", v.get("publisher")) or v.get("category") != correct_category:
+                v["category"] = correct_category
+                changed = True
+            
+            # Ensure allowed_divs exists
+            if "allowed_divs" not in v:
+                v["allowed_divs"] = [] # Default to empty (Global)
+                changed = True
+
+        if changed:
+            await save_index()
+            logging.info("Backfilled metadata and division fields")
 
 # ==================================================
-# BASE62 HELPERS
+# BASE62 & ICLOUD HELPERS
 # ==================================================
-BASE_62_MAP = {c: i for i, c in enumerate(
-    "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-)}
+BASE_62_MAP = {c: i for i, c in enumerate("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")}
 
 def base62_to_int(token: str) -> int:
     n = 0
@@ -177,13 +243,7 @@ def base62_to_int(token: str) -> int:
         n = n * 62 + BASE_62_MAP[c]
     return n
 
-# ==================================================
-# iCLOUD HELPERS
-# ==================================================
-ICLOUD_HEADERS = {
-    "Origin": "https://www.icloud.com",
-    "Content-Type": "text/plain",
-}
+ICLOUD_HEADERS = {"Origin": "https://www.icloud.com", "Content-Type": "text/plain"}
 ICLOUD_PAYLOAD = '{"streamCtag":null}'
 
 async def get_base_url(token: str) -> str:
@@ -195,31 +255,17 @@ async def get_base_url(token: str) -> str:
 
 async def get_redirected_base_url(base_url: str, token: str) -> str:
     client = await get_client()
-    r = await client.post(
-        f"{base_url}webstream",
-        headers=ICLOUD_HEADERS,
-        data=ICLOUD_PAYLOAD,
-        follow_redirects=False,
-    )
-
+    r = await client.post(f"{base_url}webstream", headers=ICLOUD_HEADERS, data=ICLOUD_PAYLOAD, follow_redirects=False)
     if r.status_code == 330:
         host = r.json().get("X-Apple-MMe-Host")
-        if not host:
-            raise RuntimeError("Missing redirect host")
         return f"https://{host}/{token}/sharedstreams/"
-
     if r.status_code == 200:
         return base_url
-
     r.raise_for_status()
 
 async def post_json(path: str, base_url: str, payload: str) -> dict:
     client = await get_client()
-    r = await client.post(
-        f"{base_url}{path}",
-        headers=ICLOUD_HEADERS,
-        data=payload,
-    )
+    r = await client.post(f"{base_url}{path}", headers=ICLOUD_HEADERS, data=payload)
     r.raise_for_status()
     return r.json()
 
@@ -230,175 +276,147 @@ async def get_asset_urls(base_url: str, guids: list) -> dict:
     payload = json.dumps({"photoGuids": guids})
     return (await post_json("webasseturls", base_url, payload)).get("items", {})
 
-# ==================================================
-# DOWNLOADER
-# ==================================================
-async def download_file(url: str, path: str):
+async def download_to_temp(url: str, filename: str) -> str:
+    path = os.path.join(TEMP_DIR, filename)
     client = await get_client()
     async with client.stream("GET", url) as r:
         r.raise_for_status()
         with open(path, "wb") as f:
             async for chunk in r.aiter_bytes():
                 f.write(chunk)
+    return path
 
 # ==================================================
 # POLL + INGEST ALBUM
 # ==================================================
 async def poll_album(token: str):
-    base_url = await get_base_url(token)
-    base_url = await get_redirected_base_url(base_url, token)
-
-    metadata = await get_metadata(base_url)
-    guids = [p["photoGuid"] for p in metadata]
-    assets = await get_asset_urls(base_url, guids)
-
-    async with INDEX_LOCK:
-        index = load_index_sync()
-        known = {v["id"] for v in index.get("videos", [])}
-
-    publisher = ALBUM_PUBLISHERS.get(token, "Unknown")
-    category = ALBUM_CATEGORIES.get(token, "Uncategorized")
-
-    album_dir = os.path.join(VIDEO_DIR, token)
-    os.makedirs(album_dir, exist_ok=True)
-
-    new_entries = []
-
-    for photo in metadata:
-        if photo.get("mediaAssetType", "").lower() != "video":
-            continue
-
-        vid = photo["photoGuid"]
-        if vid in known:
-            continue
-
-        derivatives = photo.get("derivatives", {})
-        best = max(
-            (d for k, d in derivatives.items() if k.lower() != "posterframe"),
-            key=lambda d: int(d.get("fileSize") or 0),
-            default=None,
-        )
-        if not best:
-            continue
-
-        asset = assets.get(best["checksum"])
-        if not asset:
-            continue
-
-        video_url = f"https://{asset['url_location']}{asset['url_path']}"
-        video_path = os.path.join(album_dir, f"{vid}.mp4")
-        await download_file(video_url, video_path)
-
-        thumb_path = ""
-        pf = derivatives.get("PosterFrame")
-        if pf:
-            pf_asset = assets.get(pf.get("checksum"))
-            if pf_asset:
+    try:
+        base_url = await get_base_url(token)
+        base_url = await get_redirected_base_url(base_url, token)
+
+        metadata = await get_metadata(base_url)
+        guids = [p["photoGuid"] for p in metadata]
+        assets = await get_asset_urls(base_url, guids)
+
+        async with DATA_LOCK:
+            known = {v["id"] for v in INDEX_CACHE.get("videos", [])}
+
+        publisher = ALBUM_PUBLISHERS.get(token, "Unknown")
+        category = ALBUM_CATEGORIES.get(token, "Uncategorized")
+        
+        new_entries = []
+
+        for photo in metadata:
+            if photo.get("mediaAssetType", "").lower() != "video":
+                continue
+
+            vid = photo["photoGuid"]
+            if vid in known:
+                continue
+
+            derivatives = photo.get("derivatives", {})
+            best = max(
+                (d for k, d in derivatives.items() if k.lower() != "posterframe"),
+                key=lambda d: int(d.get("fileSize") or 0),
+                default=None,
+            )
+            if not best or best["checksum"] not in assets:
+                continue
+
+            asset = assets[best["checksum"]]
+            video_url = f"https://{asset['url_location']}{asset['url_path']}"
+            
+            # Download to temp then Push to HF
+            temp_vid = await download_to_temp(video_url, f"{vid}.mp4")
+            hf_vid_path = f"videos/{token}/{vid}.mp4"
+            await sync_push_file(temp_vid, hf_vid_path)
+            os.remove(temp_vid)
+
+            # Handle Thumbnail
+            hf_thumb_path = ""
+            pf = derivatives.get("PosterFrame")
+            if pf and pf.get("checksum") in assets:
+                pf_asset = assets[pf["checksum"]]
                 poster_url = f"https://{pf_asset['url_location']}{pf_asset['url_path']}"
-                thumb_path = os.path.join(album_dir, f"{vid}.jpg")
-                await download_file(poster_url, thumb_path)
-
-        new_entries.append({
-            "id": vid,
-            "name": photo.get("caption") or "Untitled",
-            "video_url": f"/media/{token}/{vid}.mp4",
-            "thumbnail": f"/media/{token}/{vid}.jpg" if thumb_path else "",
-            "upload_date": photo.get("creationDate") or datetime.now(timezone.utc).isoformat(),
-            "category": category,
-            "publisher": publisher,
-            "source_album": token,
-        })
-
-    if new_entries:
-        async with INDEX_LOCK:
-            idx = load_index_sync()
-            existing = {v["id"] for v in idx.get("videos", [])}
-            for e in new_entries:
-                if e["id"] not in existing:
-                    idx["videos"].append(e)
-            save_index_sync(idx)
+                temp_thumb = await download_to_temp(poster_url, f"{vid}.jpg")
+                hf_thumb_path = f"videos/{token}/{vid}.jpg"
+                await sync_push_file(temp_thumb, hf_thumb_path)
+                os.remove(temp_thumb)
+
+            new_entries.append({
+                "id": vid,
+                "name": photo.get("caption") or "Untitled",
+                "video_url": get_hf_url(hf_vid_path),
+                "thumbnail": get_hf_url(hf_thumb_path) if hf_thumb_path else "",
+                "upload_date": photo.get("creationDate") or datetime.now(timezone.utc).isoformat(),
+                "category": category,
+                "publisher": publisher,
+                "source_album": token,
+                "allowed_divs": [] # Default: Allowed for all
+            })
+
+        if new_entries:
+            async with DATA_LOCK:
+                INDEX_CACHE["videos"].extend(new_entries)
+                await save_index()
+                logging.info(f"Added {len(new_entries)} videos from {token}")
+
+    except Exception as e:
+        logging.error(f"Error polling {token}: {e}")
 
 # ==================================================
 # STARTUP
 # ==================================================
 @app.on_event("startup")
 async def start_polling():
-    if not os.path.exists(ADMIN_CONFIG_FILE):
-        save_admin_config_sync({
-            "album_publishers": dict(DEFAULT_ALBUM_PUBLISHERS),
-            "album_categories": dict(DEFAULT_ALBUM_CATEGORIES),
-        })
-
-    await refresh_album_maps_from_disk()
+    if not HF_TOKEN:
+        logging.error("CRITICAL: 'hf1' environment variable not set. Dataset storage will fail.")
+    
+    await load_state_from_hf()
     await backfill_index_categories()
 
-    if not admin_enabled():
-        logging.warning("ADMIN_KEY is not set. Admin panel is disabled until you set ADMIN_KEY.")
-
     async def loop():
         while True:
             tokens = list(ALBUM_PUBLISHERS.keys())
             for token in tokens:
-                try:
-                    await poll_album(token)
-                except Exception:
-                    logging.exception(f"Polling failed for {token}")
+                await poll_album(token)
             await asyncio.sleep(60)
 
     asyncio.create_task(loop())
 
 # ==================================================
-# FEED
+# FEED (With Div Support)
 # ==================================================
 @app.get("/feed/videos")
-async def get_video_feed():
-    async with INDEX_LOCK:
-        return load_index_sync()
-
-# ==================================================
-# LEGACY ENDPOINTS
-# ==================================================
-@app.get("/album/{token}")
-async def legacy_album(token: str):
-    base_url = await get_base_url(token)
-    base_url = await get_redirected_base_url(base_url, token)
-    metadata = await get_metadata(base_url)
-    guids = [p["photoGuid"] for p in metadata]
-    assets = await get_asset_urls(base_url, guids)
-
-    videos = []
-    for photo in metadata:
-        if photo.get("mediaAssetType", "").lower() != "video":
-            continue
-
-        derivatives = photo.get("derivatives", {})
-        best = max(
-            (d for k, d in derivatives.items() if k.lower() != "posterframe"),
-            key=lambda d: int(d.get("fileSize") or 0),
-            default=None,
-        )
-        if not best:
-            continue
-
-        asset = assets.get(best["checksum"])
-        if not asset:
-            continue
-
-        videos.append({
-            "caption": photo.get("caption", ""),
-            "url": f"https://{asset['url_location']}{asset['url_path']}",
-        })
-
-    return {"videos": videos}
-
-@app.get("/album/{token}/raw")
-async def legacy_album_raw(token: str):
-    base_url = await get_base_url(token)
-    base_url = await get_redirected_base_url(base_url, token)
-    metadata = await get_metadata(base_url)
-    guids = [p["photoGuid"] for p in metadata]
-    assets = await get_asset_urls(base_url, guids)
-    return {"metadata": metadata, "asset_urls": assets}
+async def get_video_feed(div: Optional[int] = Query(None, description="School Division (1-25)")):
+    """
+    Returns videos. 
+    If 'div' is provided, returns:
+      1. Videos with NO specific allowed_divs (Global).
+      2. Videos where 'div' is explicitly in allowed_divs.
+    """
+    async with DATA_LOCK:
+        videos = INDEX_CACHE.get("videos", [])
+    
+    # If no div specified, return everything? Or everything that isn't restricted?
+    # Usually feed returns everything accessible.
+    if div is None:
+        return {"videos": videos}
+
+    # Validate Div
+    if div not in VALID_DIVISIONS:
+        # If invalid div provided, maybe return empty or error? 
+        # For safety, let's return empty or just global ones.
+        return {"videos": [v for v in videos if not v.get("allowed_divs")]}
+
+    filtered_videos = []
+    for v in videos:
+        allowed = v.get("allowed_divs", [])
+        # Include if: No restrictions defined OR Div is in list
+        if not allowed or div in allowed:
+            filtered_videos.append(v)
+
+    return {"videos": filtered_videos}
 
 # ==================================================
 # ADMIN: LOGIN
@@ -406,387 +424,178 @@ async def legacy_album_raw(token: str):
 @app.get("/admin/login", response_class=HTMLResponse)
 async def admin_login_page():
     if not admin_enabled():
-        return HTMLResponse(
-            "<h3>Admin disabled</h3><p>Set environment variable <code>ADMIN_KEY</code> to enable.</p>",
-            status_code=503
-        )
-
+        return HTMLResponse("Admin disabled (ADMIN_KEY missing)", status_code=503)
     return """
-    <html>
-      <head>
-        <title>Admin Login</title>
-        <meta name="viewport" content="width=device-width, initial-scale=1" />
-        <style>
-          body { font-family: system-ui, sans-serif; background:#111; color:#fff; display:flex; min-height:100vh; align-items:center; justify-content:center; }
-          .card { width: 360px; padding: 18px; border: 1px solid #333; border-radius: 12px; background:#161616; }
-          input, button { width:100%; padding:12px; font-size:16px; border-radius:10px; border:1px solid #333; background:#0f0f0f; color:#fff; }
-          button { background:#2a2a2a; cursor:pointer; margin-top:10px; }
-          button:hover { background:#3a3a3a; }
-          .small { font-size:12px; opacity:0.8; margin-top:10px; }
-        </style>
-      </head>
-      <body>
-        <form class="card" method="post">
-          <h2 style="margin:0 0 10px 0;">Admin Panel</h2>
-          <input type="password" name="key" placeholder="ADMIN_KEY" autofocus />
-          <button type="submit">Enter</button>
-          <div class="small">This requires <code>ADMIN_KEY</code> env var set on the server.</div>
-        </form>
-      </body>
-    </html>
+    <html><body style="background:#111;color:#fff;display:flex;justify-content:center;align-items:center;height:100vh;font-family:sans-serif;">
+    <form method="post" style="padding:20px;border:1px solid #333;border-radius:10px;background:#1a1a1a;">
+    <h2>Admin</h2><input type="password" name="key" placeholder="Key" style="padding:10px;width:100%;margin-bottom:10px;">
+    <button style="padding:10px;width:100%;cursor:pointer;">Login</button>
+    </form></body></html>
     """
 
 @app.post("/admin/login")
 async def admin_login(key: str = Form(...)):
-    if not admin_enabled():
-        return HTMLResponse("Admin disabled (ADMIN_KEY not set)", status_code=503)
-
-    if not secure_equals(str(key).strip(), str(ADMIN_KEY).strip()):
-        return HTMLResponse("Wrong key", status_code=401)
-
+    if not admin_enabled() or not secure_equals(key.strip(), str(ADMIN_KEY).strip()):
+        return HTMLResponse("Unauthorized", status_code=401)
     session = secrets.token_hex(16)
     ADMIN_SESSIONS.add(session)
-
     resp = RedirectResponse("/admin", status_code=302)
     resp.set_cookie(ADMIN_COOKIE, session, httponly=True)
     return resp
 
 @app.get("/admin/logout")
 async def admin_logout(req: Request):
-    session = req.cookies.get(ADMIN_COOKIE)
-    if session in ADMIN_SESSIONS:
-        ADMIN_SESSIONS.remove(session)
-    resp = RedirectResponse("/admin/login", status_code=302)
-    resp.delete_cookie(ADMIN_COOKIE)
-    return resp
+    if (s := req.cookies.get(ADMIN_COOKIE)) in ADMIN_SESSIONS: ADMIN_SESSIONS.remove(s)
+    return RedirectResponse("/admin/login")
 
 # ==================================================
-# ADMIN UI TEMPLATE
+# ADMIN DASHBOARD
 # ==================================================
-def esc(v) -> str:
-    return html_escape_lib.escape("" if v is None else str(v), quote=True)
+def esc(v) -> str: return html_escape_lib.escape("" if v is None else str(v), quote=True)
 
 ADMIN_TEMPLATE = """
 <html>
-  <head>
-    <title>Admin</title>
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <style>
-      body { font-family: system-ui, sans-serif; background:#111; color:#fff; margin:0; padding:16px; }
-      a { color:#9ad; }
-      h1 { margin: 0 0 10px 0; }
-      .row { display:flex; gap:10px; align-items:center; margin-bottom:12px; flex-wrap:wrap; }
-      .pill { padding:6px 10px; border:1px solid #333; border-radius:999px; background:#161616; }
-      .card { border:1px solid #333; border-radius:12px; background:#161616; padding:12px; margin: 14px 0; }
-      table { width:100%; border-collapse: collapse; }
-      th, td { border-bottom:1px solid #2a2a2a; padding:8px; vertical-align: top; }
-      th { text-align:left; position:sticky; top:0; background:#161616; }
-      input { width:100%; padding:8px; border-radius:10px; border:1px solid #333; background:#0f0f0f; color:#fff; }
-      button { padding:10px 12px; border-radius:10px; border:1px solid #333; background:#2a2a2a; color:#fff; cursor:pointer; }
-      button:hover { background:#3a3a3a; }
-      .danger { background:#3a1d1d; border-color:#6a2a2a; }
-      .danger:hover { background:#5a2424; }
-      .small { font-size:12px; opacity:0.85; }
-      .grid2 { display:grid; grid-template-columns: 1fr 1fr; gap:10px; }
-      @media (max-width: 900px) { .grid2 { grid-template-columns: 1fr; } }
-    </style>
-  </head>
-  <body>
-    <div class="row">
-      <h1 style="margin-right:auto;">Admin</h1>
-      <span class="pill">Session active</span>
-      <a href="/admin/logout" class="pill">Logout</a>
-    </div>
-
-    <div class="card">
-      <h2 style="margin:0 0 8px 0;">Albums</h2>
-      <div class="small">Add/edit albums here. Polling loop uses this list.</div>
-      <table>
-        <thead>
-          <tr>
-            <th style="width:28%;">Album Token</th>
-            <th>Publisher</th>
-            <th>Category</th>
-          </tr>
-        </thead>
-        <tbody>
-          __ALBUM_ROWS__
-          <tr>
-            <td><input id="new_token" placeholder="New token"></td>
-            <td><input id="new_publisher" placeholder="Publisher"></td>
-            <td>
-              <div class="grid2">
-                <input id="new_category" placeholder="Category">
-                <button onclick="addAlbum()">Add Album</button>
-              </div>
-            </td>
-          </tr>
-        </tbody>
-      </table>
-    </div>
-
-    <div class="card">
-      <h2 style="margin:0 0 8px 0;">Videos</h2>
-      <div class="small">
-        Thumbnail supports either a local path like <code>/media/TOKEN/ID.jpg</code> or a full URL like <code>https://...</code>
-      </div>
-      <table>
-        <thead>
-          <tr>
-            <th style="width:12%;">ID</th>
-            <th style="width:14%;">Name</th>
-            <th style="width:16%;">Upload Date</th>
-            <th style="width:10%;">Category</th>
-            <th style="width:12%;">Publisher</th>
-            <th style="width:18%;">Thumbnail</th>
-            <th style="width:13%;">Source Album</th>
-            <th style="width:5%;">Action</th>
-          </tr>
-        </thead>
-        <tbody>
-          __VIDEO_ROWS__
-        </tbody>
-      </table>
-    </div>
-
-    <script>
-      async function postJSON(url, obj) {
-        const r = await fetch(url, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(obj),
-        });
-        return r.json();
-      }
-
-      // autosave video fields
-      document.addEventListener("change", async (e) => {
-        const t = e.target;
-        if (!t || !t.dataset || !t.dataset.id) return;
-
-        await postJSON("/admin/update", {
-          id: t.dataset.id,
-          field: t.dataset.field,
-          value: t.value
-        });
-      });
-
-      // autosave album fields
-      document.addEventListener("change", async (e) => {
-        const t = e.target;
-        if (!t || !t.dataset || !t.dataset.album) return;
-
-        await postJSON("/admin/albums/update", {
-          token: t.dataset.album,
-          field: t.dataset.field,
-          value: t.value
-        });
-      });
-
-      async function addAlbum() {
-        const token = document.getElementById("new_token").value.trim();
-        const publisher = document.getElementById("new_publisher").value.trim();
-        const category = document.getElementById("new_category").value.trim();
-        if (!token) return alert("Token required");
-
-        const out = await postJSON("/admin/albums/add", { token, publisher, category });
-        if (out && out.ok) location.reload();
-        else alert(out.error || "failed");
-      }
-
-      async function deleteVideo(id) {
-        if (!confirm("Delete this video? This removes it from the feed and deletes local files if present.")) return;
-        const out = await postJSON("/admin/videos/delete", { id });
-        if (out && out.ok) location.reload();
-        else alert(out.error || "failed");
-      }
-    </script>
-  </body>
+<head>
+<title>Admin</title>
+<style>
+body{font-family:sans-serif;background:#111;color:#ddd;padding:20px;}
+table{width:100%;border-collapse:collapse;margin-top:20px;}
+th,td{border-bottom:1px solid #333;padding:8px;text-align:left;}
+input{background:#222;border:1px solid #444;color:#fff;padding:5px;border-radius:4px;width:100%;}
+button{background:#444;color:#fff;border:none;padding:5px 10px;cursor:pointer;border-radius:4px;}
+.pill{padding:4px 8px;background:#004400;border-radius:10px;font-size:0.8em;}
+</style>
+</head>
+<body>
+<h1>Admin Panel <a href="/admin/logout" style="font-size:0.5em;color:#888;">Logout</a></h1>
+
+<h3>Albums</h3>
+<table>
+<tr><th>Token</th><th>Publisher</th><th>Category</th><th>Action</th></tr>
+__ALBUM_ROWS__
+<tr>
+<td><input id="n_t" placeholder="Token"></td>
+<td><input id="n_p" placeholder="Publisher"></td>
+<td><input id="n_c" placeholder="Category"></td>
+<td><button onclick="addAlbum()">Add</button></td>
+</tr>
+</table>
+
+<h3>Videos</h3>
+<p style="font-size:0.8em;color:#888;">Allowed Divs: Comma separated (e.g. <code>1,5,25</code>). Leave empty for ALL.</p>
+<table>
+<tr><th>ID</th><th>Name</th><th>Divs (1-25)</th><th>Category</th><th>Publisher</th><th>Action</th></tr>
+__VIDEO_ROWS__
+</table>
+
+<script>
+async function api(ep, data) {
+    await fetch(ep, {method:'POST', headers:{'Content-Type':'application/json'}, body:JSON.stringify(data)});
+    location.reload();
+}
+document.querySelectorAll('input[data-id]').forEach(i => {
+    i.addEventListener('change', (e) => api('/admin/update', {
+        id: e.target.dataset.id, 
+        field: e.target.dataset.field, 
+        value: e.target.value
+    }));
+});
+function addAlbum(){
+    api('/admin/albums/add', {
+        token: document.getElementById('n_t').value,
+        publisher: document.getElementById('n_p').value,
+        category: document.getElementById('n_c').value
+    });
+}
+</script>
+</body>
 </html>
 """
 
-# ==================================================
-# ADMIN: DASHBOARD
-# ==================================================
 @app.get("/admin", response_class=HTMLResponse)
-async def admin_dashboard(req: Request):
-    if not admin_enabled():
-        return HTMLResponse("Admin disabled (ADMIN_KEY not set)", status_code=503)
-    if not is_admin(req):
-        return RedirectResponse("/admin/login", status_code=302)
-
-    async with INDEX_LOCK:
-        idx = load_index_sync()
-    cfg = await load_admin_config()
-
-    ap = cfg.get("album_publishers", {})
-    ac = cfg.get("album_categories", {})
-    album_tokens = sorted(set(ap.keys()) | set(ac.keys()))
-
-    album_rows = ""
-    for token in album_tokens:
-        album_rows += (
-            "<tr>"
-            f"<td><input data-album=\"{esc(token)}\" data-field=\"token\" value=\"{esc(token)}\" disabled></td>"
-            f"<td><input data-album=\"{esc(token)}\" data-field=\"publisher\" value=\"{esc(ap.get(token, ''))}\"></td>"
-            f"<td><input data-album=\"{esc(token)}\" data-field=\"category\" value=\"{esc(ac.get(token, ''))}\"></td>"
-            "</tr>"
-        )
-
-    video_rows = ""
-    for v in idx.get("videos", []):
-        vid = esc(v.get("id", ""))
-        video_rows += (
-            "<tr>"
-            f"<td class='small'>{vid}</td>"
-            f"<td><input data-id=\"{vid}\" data-field=\"name\" value=\"{esc(v.get('name',''))}\"></td>"
-            f"<td><input data-id=\"{vid}\" data-field=\"upload_date\" value=\"{esc(v.get('upload_date',''))}\"></td>"
-            f"<td><input data-id=\"{vid}\" data-field=\"category\" value=\"{esc(v.get('category',''))}\"></td>"
-            f"<td><input data-id=\"{vid}\" data-field=\"publisher\" value=\"{esc(v.get('publisher',''))}\"></td>"
-            f"<td><input data-id=\"{vid}\" data-field=\"thumbnail\" value=\"{esc(v.get('thumbnail',''))}\" placeholder=\"/media/TOKEN/ID.jpg or https://...\"></td>"
-            f"<td><input data-id=\"{vid}\" data-field=\"source_album\" value=\"{esc(v.get('source_album',''))}\"></td>"
-            f"<td><button class=\"danger\" onclick=\"deleteVideo('{vid}')\">Del</button></td>"
-            "</tr>"
-        )
-
-    page = ADMIN_TEMPLATE.replace("__ALBUM_ROWS__", album_rows).replace("__VIDEO_ROWS__", video_rows)
-    return HTMLResponse(page)
-
-# ==================================================
-# ADMIN: UPDATE VIDEO METADATA
+async def admin_dash(req: Request):
+    if not is_admin(req): return RedirectResponse("/admin/login")
+    
+    async with DATA_LOCK:
+        videos = INDEX_CACHE.get("videos", [])
+        
+    v_rows = ""
+    for v in videos:
+        divs = ",".join(map(str, v.get("allowed_divs", [])))
+        v_rows += f"""<tr>
+        <td>{esc(v['id'])[:8]}...</td>
+        <td><input data-id="{v['id']}" data-field="name" value="{esc(v.get('name'))}"></td>
+        <td><input data-id="{v['id']}" data-field="allowed_divs" value="{esc(divs)}" placeholder="All"></td>
+        <td><input data-id="{v['id']}" data-field="category" value="{esc(v.get('category'))}"></td>
+        <td><input data-id="{v['id']}" data-field="publisher" value="{esc(v.get('publisher'))}"></td>
+        <td><button onclick="api('/admin/videos/delete', {{id:'{v['id']}'}})" style="background:#500;">Del</button></td>
+        </tr>"""
+
+    a_rows = ""
+    for t, p in ALBUM_PUBLISHERS.items():
+        c = ALBUM_CATEGORIES.get(t, "")
+        a_rows += f"<tr><td>{t}</td><td>{p}</td><td>{c}</td><td>-</td></tr>"
+
+    return ADMIN_TEMPLATE.replace("__VIDEO_ROWS__", v_rows).replace("__ALBUM_ROWS__", a_rows)
+
+# ==================================================
+# ADMIN ACTIONS
 # ==================================================
-ALLOWED_VIDEO_FIELDS = {"name", "upload_date", "category", "publisher", "thumbnail", "source_album"}
-
 @app.post("/admin/update")
 async def admin_update(req: Request, payload: dict):
-    if not admin_enabled():
-        return JSONResponse({"error": "admin disabled"}, status_code=503)
-    if not is_admin(req):
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-
-    vid = str(payload.get("id", "")).strip()
-    field = str(payload.get("field", "")).strip()
-    value = payload.get("value", "")
-
-    if not vid or field not in ALLOWED_VIDEO_FIELDS:
-        return JSONResponse({"error": "bad request"}, status_code=400)
-
-    async with INDEX_LOCK:
-        idx = load_index_sync()
-        for v in idx.get("videos", []):
-            if v.get("id") == vid:
-                v[field] = value
-                save_index_sync(idx)
+    if not is_admin(req): return JSONResponse({}, 403)
+    
+    vid_id = payload.get("id")
+    field = payload.get("field")
+    value = payload.get("value")
+    
+    async with DATA_LOCK:
+        for v in INDEX_CACHE["videos"]:
+            if v["id"] == vid_id:
+                if field == "allowed_divs":
+                    # Parse comma string to list of ints
+                    try:
+                        if not value.strip():
+                            v[field] = []
+                        else:
+                            # Filter only valid integers 1-25
+                            nums = [int(x.strip()) for x in value.split(",") if x.strip().isdigit()]
+                            v[field] = [n for n in nums if n in VALID_DIVISIONS]
+                    except:
+                        pass # Ignore bad input
+                else:
+                    v[field] = value
+                
+                await save_index()
                 return {"ok": True}
-
-    return JSONResponse({"error": "video not found"}, status_code=404)
-
-# ==================================================
-# ADMIN: DELETE VIDEO (index + local files)
-# ==================================================
-def _safe_remove_file(path: str):
-    try:
-        if path and os.path.isfile(path):
-            os.remove(path)
-    except Exception:
-        logging.exception(f"Failed to remove file: {path}")
+    return {"error": "not found"}
 
 @app.post("/admin/videos/delete")
-async def admin_delete_video(req: Request, payload: dict):
-    if not admin_enabled():
-        return JSONResponse({"error": "admin disabled"}, status_code=503)
-    if not is_admin(req):
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-
-    vid = str(payload.get("id", "")).strip()
-    if not vid:
-        return JSONResponse({"error": "id required"}, status_code=400)
-
-    async with INDEX_LOCK:
-        idx = load_index_sync()
-        videos = idx.get("videos", [])
-
-        target = None
-        for v in videos:
-            if v.get("id") == vid:
-                target = v
-                break
-
-        if not target:
-            return JSONResponse({"error": "video not found"}, status_code=404)
-
-        # Delete local files if they exist
-        token = target.get("source_album", "")
-        if token:
-            mp4_path = os.path.join(VIDEO_DIR, token, f"{vid}.mp4")
-            jpg_path = os.path.join(VIDEO_DIR, token, f"{vid}.jpg")
-            _safe_remove_file(mp4_path)
-            _safe_remove_file(jpg_path)
-
-        # Remove from index
-        idx["videos"] = [v for v in videos if v.get("id") != vid]
-        save_index_sync(idx)
-
+async def admin_delete(req: Request, payload: dict):
+    if not is_admin(req): return JSONResponse({}, 403)
+    vid_id = payload.get("id")
+    
+    async with DATA_LOCK:
+        # We only remove from index. We don't delete actual files from HF to avoid complexity 
+        # (Git operations are heavy), but removing from index hides them from feed.
+        original_len = len(INDEX_CACHE["videos"])
+        INDEX_CACHE["videos"] = [v for v in INDEX_CACHE["videos"] if v["id"] != vid_id]
+        
+        if len(INDEX_CACHE["videos"]) < original_len:
+            await save_index()
+            
     return {"ok": True}
 
-# ==================================================
-# ADMIN: ALBUM MANAGEMENT (persisted)
-# ==================================================
 @app.post("/admin/albums/add")
-async def admin_albums_add(req: Request, payload: dict):
-    if not admin_enabled():
-        return JSONResponse({"error": "admin disabled"}, status_code=503)
-    if not is_admin(req):
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-
-    token = str(payload.get("token", "")).strip()
-    publisher = str(payload.get("publisher", "")).strip() or "Unknown"
-    category = str(payload.get("category", "")).strip() or "Uncategorized"
-    if not token:
-        return JSONResponse({"error": "token required"}, status_code=400)
-
-    cfg = await load_admin_config()
-    cfg.setdefault("album_publishers", {})
-    cfg.setdefault("album_categories", {})
-    cfg["album_publishers"][token] = publisher
-    cfg["album_categories"][token] = category
-
-    await write_admin_config(cfg)
-    await refresh_album_maps_from_disk()
-    await backfill_index_categories()
-
-    return {"ok": True}
-
-@app.post("/admin/albums/update")
-async def admin_albums_update(req: Request, payload: dict):
-    if not admin_enabled():
-        return JSONResponse({"error": "admin disabled"}, status_code=503)
-    if not is_admin(req):
-        return JSONResponse({"error": "unauthorized"}, status_code=403)
-
-    token = str(payload.get("token", "")).strip()
-    field = str(payload.get("field", "")).strip()
-    value = str(payload.get("value", "")).strip()
-
-    if not token or field not in ("publisher", "category"):
-        return JSONResponse({"error": "bad request"}, status_code=400)
-
-    cfg = await load_admin_config()
-    cfg.setdefault("album_publishers", {})
-    cfg.setdefault("album_categories", {})
-
-    if field == "publisher":
-        cfg["album_publishers"][token] = value or "Unknown"
-    else:
-        cfg["album_categories"][token] = value or "Uncategorized"
-
-    await write_admin_config(cfg)
-    await refresh_album_maps_from_disk()
-    await backfill_index_categories()
-
-    return {"ok": True}
-
-# ==================================================
-# STATIC MEDIA
-# ==================================================
-app.mount("/media", StaticFiles(directory=VIDEO_DIR), name="media")
+async def admin_album_add(req: Request, payload: dict):
+    if not is_admin(req): return JSONResponse({}, 403)
+    t = payload.get("token")
+    if t:
+        async with DATA_LOCK:
+            CONFIG_CACHE["album_publishers"][t] = payload.get("publisher", "Unknown")
+            CONFIG_CACHE["album_categories"][t] = payload.get("category", "Uncategorized")
+            global ALBUM_PUBLISHERS, ALBUM_CATEGORIES
+            ALBUM_PUBLISHERS = CONFIG_CACHE["album_publishers"]
+            ALBUM_CATEGORIES = CONFIG_CACHE["album_categories"]
+            await save_config()
+    return {"ok": True}