Update main.py

main.py

@@ -7,12 +7,15 @@ from google.oauth2.service_account import Credentials
 
 app = FastAPI()
 
+# Config
 TMDB_KEY = os.getenv("TMDB_KEY")
 SHEET_ID = os.getenv("SHEET_ID")
 SERVICE_ACCOUNT_STR = os.getenv("SERVICE_ACCOUNT_JSON")
 
+# Cache
 db_cache = {"movies": [], "tv_shows": [], "users": {}}
 tmdb_cache = {}
+filter_options = {"years": set(), "genres": set(), "casts": set()}
 
 def get_sheet():
     creds = Credentials.from_service_account_info(
@@ -22,15 +25,14 @@ def get_sheet():
     return gspread.authorize(creds).open_by_key(SHEET_ID)
 
 async def fetch_tmdb_meta(tmdb_id, media_type="movie"):
-    cache_key = f"{media_type}_{tmdb_id}"
-    if cache_key in tmdb_cache: return tmdb_cache[cache_key]
-    
-    url = f"https://api.themoviedb.org/3/{media_type}/{tmdb_id}?api_key={TMDB_KEY}"
+    ck = f"{media_type}_{tmdb_id}"
+    if ck in tmdb_cache: return tmdb_cache[ck]
+    url = f"https://api.themoviedb.org/3/{media_type}/{tmdb_id}?api_key={TMDB_KEY}&append_to_response=credits"
     async with httpx.AsyncClient() as client:
         res = await client.get(url)
         if res.status_code == 200:
             data = res.json()
-            tmdb_cache[cache_key] = data
+            tmdb_cache[ck] = data
             return data
     return None
 
@@ -38,91 +40,150 @@ async def fetch_tmdb_meta(tmdb_id, media_type="movie"):
 async def refresh_db():
     try:
         ss = get_sheet()
+        db_cache["movies"] = ss.worksheet("movies").get_all_records()
+        db_cache["tv_shows"] = ss.worksheet("tv_shows").get_all_records()
+        db_cache["users"] = {r["user_token"]: r for r in ss.worksheet("users").get_all_records() if r["status"] == "active"}
         
-        # Sync Movies
-        movie_ws = ss.worksheet("movies")
-        movies = movie_ws.get_all_records()
-        db_cache["movies"] = movies
-        for i, row in enumerate(movies):
-            if not row.get("status"):
-                movie_ws.update_cell(i + 2, 4, "synced") # Column D
-
-        # Sync TV Shows
-        tv_ws = ss.worksheet("tv_shows")
-        tvs = tv_ws.get_all_records()
-        db_cache["tv_shows"] = tvs
-        for i, row in enumerate(tvs):
-            if not row.get("status"):
-                tv_ws.update_cell(i + 2, 6, "synced") # Column F
-
-        # Sync Users
-        user_ws = ss.worksheet("users")
-        db_cache["users"] = {r["user_token"]: r for r in user_ws.get_all_records() if r["status"] == "active"}
-
-        return {"status": "success", "message": "Database Refreshed & Status Updated"}
+        # Filter Options များကို ပြန်ဆန်းသစ်ခြင်း
+        filter_options["years"].clear()
+        filter_options["genres"].clear()
+        filter_options["casts"].clear()
+
+        all_items = db_cache["movies"] + db_cache["tv_shows"]
+        for item in all_items:
+            m_type = "movie" if item in db_cache["movies"] else "tv"
+            data = await fetch_tmdb_meta(item["tmdb_id"], m_type)
+            if data:
+                rd = data.get("release_date") or data.get("first_air_date", "0000")
+                filter_options["years"].add(rd.split("-")[0])
+                for g in data.get("genres", []): filter_options["genres"].add(g["name"])
+                for person in data.get("credits", {}).get("cast", [])[:5]:
+                    filter_options["casts"].add(person["name"])
+
+        return {"status": "success", "message": "Database & Filters Synced"}
     except Exception as e:
         return {"status": "error", "message": str(e)}
 
 @app.get("/{token}/manifest.json")
 async def get_manifest(token: str):
     if token not in db_cache["users"]: raise HTTPException(status_code=403)
+    
+    # Sidebar Filters စီစဉ်ခြင်း
+    years = [f"Year: {y}" for y in sorted(list(filter_options["years"]), reverse=True)]
+    genres = [f"Genre: {g}" for g in sorted(list(filter_options["genres"]))]
+    casts = [f"Actor: {c}" for c in sorted(list(filter_options["casts"]))]
+    combined = ["All"] + years + genres + casts
+
     return {
-        "id": f"org.gemini.{token}",
-        "version": "1.0.0",
-        "name": "My Private Addon",
+        "id": f"ms.private.{token}",
+        "version": "2.1.0",
+        "name": "MyanmarSwe Private Cinema",
         "resources": ["catalog", "meta", "stream"],
         "types": ["movie", "series"],
         "catalogs": [
-            {"type": "movie", "id": "my_movies", "name": "Movies"},
-            {"type": "series", "id": "my_series", "name": "TV Series"}
+            {
+                "type": "movie", "id": "ms_latest", "name": "✨ New Arrivals",
+                "extra": [{"name": "genre", "options": combined}]
+            },
+            {
+                "type": "movie", "id": "ms_collections", "name": "📚 Movie Collections",
+                "extra": [{"name": "genre", "options": combined}]
+            },
+            {
+                "type": "series", "id": "ms_series", "name": "📺 TV Series",
+                "extra": [{"name": "genre", "options": combined}]
+            }
         ]
     }
 
 @app.get("/{token}/catalog/{type}/{id}.json")
-async def get_catalog(token: str, type: str, id: str):
+async def get_catalog(token: str, type: str, id: str, genre: str = None):
     items = db_cache["movies"] if type == "movie" else db_cache["tv_shows"]
     metas = []
     processed_ids = set()
+    processed_collections = set()
+
+    # Sort: New Arrivals အတွက် နောက်ဆုံးထည့်ထားတာကို အရင်ပြရန်
+    if id == "ms_latest": items = items[::-1]
 
     for item in items:
         tid = str(item["tmdb_id"])
         if tid in processed_ids: continue
         
         tmdb_data = await fetch_tmdb_meta(tid, "movie" if type == "movie" else "tv")
-        if tmdb_data:
+        if not tmdb_data: continue
+
+        # --- Filter Logic ---
+        show_item = False
+        if not genre or genre == "All":
+            show_item = True
+        else:
+            try:
+                prefix, value = genre.split(": ")
+                if prefix == "Year":
+                    rd = tmdb_data.get("release_date") or tmdb_data.get("first_air_date", "0000")
+                    if rd.startswith(value): show_item = True
+                elif prefix == "Genre":
+                    if any(g["name"] == value for g in tmdb_data.get("genres", [])): show_item = True
+                elif prefix == "Actor":
+                    cast = [p["name"] for p in tmdb_data.get("credits", {}).get("cast", [])[:5]]
+                    if value in cast: show_item = True
+            except: show_item = True
+
+        # --- Catalog Specific Logic ---
+        if id == "ms_collections":
+            col = tmdb_data.get("belongs_to_collection")
+            if not col or col["id"] in processed_collections: continue
+            processed_collections.add(col["id"])
+            name, poster = col["name"], col["poster_path"]
+        else:
+            name, poster = tmdb_data.get("title") or tmdb_data.get("name"), tmdb_data.get("poster_path")
+
+        if show_item:
             metas.append({
                 "id": f"tmdb:{tid}",
                 "type": type,
-                "name": tmdb_data.get("title") or tmdb_data.get("name"),
-                "poster": f"https://image.tmdb.org/t/p/w500{tmdb_data.get('poster_path')}"
+                "name": name,
+                "poster": f"https://image.tmdb.org/t/p/w500{poster}"
             })
             processed_ids.add(tid)
+
     return {"metas": metas}
 
 @app.get("/{token}/meta/{type}/tmdb:{tmdb_id}.json")
 async def get_meta(token: str, type: str, tmdb_id: str):
     tmdb_data = await fetch_tmdb_meta(tmdb_id, "movie" if type == "movie" else "tv")
-    return {"meta": {
+    if not tmdb_data: return {"meta": {}}
+    meta = {
         "id": f"tmdb:{tmdb_id}",
         "type": type,
         "name": tmdb_data.get("title") or tmdb_data.get("name"),
-        "poster": f"https://image.tmdb.org/t/p/w500{tmdb_data.get('poster_path')}",
-        "background": f"https://image.tmdb.org/t/p/original{tmdb_data.get('backdrop_path')}",
+        "poster": f"https://image.tmdb.org/t/p/w500{tmdb_data['poster_path']}",
+        "background": f"https://image.tmdb.org/t/p/original{tmdb_data['backdrop_path']}",
         "description": tmdb_data.get("overview")
-    }}
+    }
+    if type == "series":
+        videos = []
+        episodes = [row for row in db_cache["tv_shows"] if str(row["tmdb_id"]) == str(tmdb_id)]
+        for ep in episodes:
+            videos.append({
+                "id": f"tmdb:{tmdb_id}:{ep['season']}:{ep['episode']}",
+                "title": ep.get("name", f"Episode {ep['episode']}"),
+                "season": int(ep["season"]), "episode": int(ep["episode"]),
+                "released": "2020-01-01T00:00:00.000Z"
+            })
+        meta["videos"] = sorted(videos, key=lambda x: (x['season'], x['episode']))
+    return {"meta": meta}
 
 @app.get("/{token}/stream/{type}/{id}.json")
 async def get_stream(token: str, type: str, id: str):
     if token not in db_cache["users"]: return {"streams": []}
-    
-    parts = id.split(":") # tmdb:1399:1:1
+    parts = id.split(":") 
     tmdb_id = parts[1]
-    
-    if type == "series":
-        season, episode = parts[2], parts[3]
-        matched = next((i for i in db_cache["tv_shows"] if str(i["tmdb_id"]) == tmdb_id and str(i["season"]) == season and str(i["episode"]) == episode), None)
+    if type == "series" and len(parts) >= 4:
+        s, e = str(parts[2]), str(parts[3])
+        matched = next((i for i in db_cache["tv_shows"] if str(i["tmdb_id"]) == tmdb_id and str(i["season"]) == s and str(i["episode"]) == e), None)
     else:
         matched = next((i for i in db_cache["movies"] if str(i["tmdb_id"]) == tmdb_id), None)
-
     if not matched: return {"streams": []}
-    return {"streams": [{"title": "Direct Link", "url": matched["link"]}]}
+    return {"streams": [{"title": "🚀 MyanmarSwe Direct", "url": matched["link"]}]}