import customtkinter as ctk

import os, re, subprocess, sys, random, webbrowser

from PIL import Image, ImageSequence

from tkinter import filedialog, messagebox, simpledialog

import tkinter as tk

from functools import partial

from typing import Optional, Tuple

import textwrap

import requests

import urllib.parse

from pathlib import Path

from core.vault_core import (

BASE_DIR,

POSTERS,

db,

load_settings,

save_settings,

resolve_existing_path,

init_db,

delete_movie,

guess_title_year_from_filename,

ffprobe_info,

list_movies,

list_show_episodes,

get_genres,

increment_watch,

upsert_movie,

get_stats,

ensure_show_row,

parse_encoded_episode_filename,

parse_episode_tag,

get_item,

get_show_progress,

play_item,

start_tv_mode,

stop_tv_mode,

open_tv_mode_in_browser,

get_tv_mode_url,

is_tv_mode_running,

)

THEMES = {

"Blue": {

"accent": "#1f6aa5",

"accent_hover": "#184f7d",

"selected_border": "#4a90e2",

"hover_border": "#4a90e2",

"danger": "#c0392b",

"danger_hover": "#962d22",

},

"Emerald": {

"accent": "#198754",

"accent_hover": "#146c43",

"selected_border": "#38d996",

"hover_border": "#38d996",

"danger": "#c0392b",

"danger_hover": "#962d22",

},

"Purple": {

"accent": "#7b61ff",

"accent_hover": "#634cd1",

"selected_border": "#a78bfa",

"hover_border": "#a78bfa",

"danger": "#c0392b",

"danger_hover": "#962d22",

},

"Amber": {

"accent": "#d97706",

"accent_hover": "#b45309",

"selected_border": "#f59e0b",

"hover_border": "#f59e0b",

"danger": "#c0392b",

"danger_hover": "#962d22",

},

"Crimson": {

"accent": "#b91c1c",

"accent_hover": "#991b1b",

"selected_border": "#ef4444",

"hover_border": "#ef4444",

"danger": "#7f1d1d",

"danger_hover": "#641818",

},

"Slate": {

"accent": "#475569",

"accent_hover": "#334155",

"selected_border": "#94a3b8",

"hover_border": "#94a3b8",

"danger": "#b91c1c",

"danger_hover": "#991b1b",

},

}

# -------------------- Wikipedia search helpers (Discover tab) --------------------

def wiki_search_titles(query, limit=10, lang="en"):

"""

Returns list of dicts: [{pageid, title, description}]

Uses Wikipedia Action API search.

"""

q = (query or "").strip()

if not q:

return []

headers = {"User-Agent": "MovieInventoryOffline/0.1 (contact: [email protected])"}

# 1) search

params = {

"action": "query",

"format": "json",

"list": "search",

"srsearch": q,

"srlimit": int(limit),

}

try:

r = requests.get(f"https://{lang}.wikipedia.org/w/api.php", params=params, headers=headers, timeout=12)

if r.status_code != 200:

return []

hits = r.json().get("query", {}).get("search", []) or []

except Exception:

return []

if not hits:

return []

pageids = [str(h.get("pageid")) for h in hits if h.get("pageid")]

if not pageids:

return []

# 2) fetch descriptions for these pageids (optional but nice)

params2 = {

"action": "query",

"format": "json",

"pageids": "|".join(pageids),

"prop": "pageterms",

"wbptterms": "description",

}

desc_map = {}

try:

r2 = requests.get(f"https://{lang}.wikipedia.org/w/api.php", params=params2, headers=headers, timeout=12)

if r2.status_code == 200:

pages = (r2.json().get("query", {}) or {}).get("pages", {}) or {}

for pid, p in pages.items():

terms = p.get("terms") or {}

d = ""

if isinstance(terms.get("description"), list) and terms["description"]:

d = terms["description"][0]

desc_map[int(pid)] = d

except Exception:

pass

out = []

for h in hits:

pid = h.get("pageid")

title = h.get("title") or ""

if not pid or not title:

continue

out.append({

"pageid": int(pid),

"title": title,

"description": desc_map.get(int(pid), "")

})

return out

def fetch_wikipedia_metadata_by_pageid(pageid, dest_folder="posters", lang="en"):

"""

Fetches a specific Wikipedia page by pageid for reliable selection.

Returns same dict format as fetch_wikipedia_metadata().

"""

headers = {"User-Agent": "MovieInventoryOffline/0.1 (contact: [email protected])"}

params = {

"action": "query",

"format": "json",

"pageids": str(int(pageid)),

"prop": "pageimages|extracts|pageterms",

"exintro": 1,

"explaintext": 1,

"piprop": "original|thumbnail",

"pithumbsize": 800,

}

try:

r = requests.get(f"https://{lang}.wikipedia.org/w/api.php", params=params, headers=headers, timeout=12)

if r.status_code != 200:

return None

pages = (r.json().get("query", {}) or {}).get("pages", {}) or {}

page = pages.get(str(int(pageid)))

if not page:

return None

except Exception:

return None

page_title = page.get("title") or ""

page_title = re.sub(r"\s*\((film|movie)\)\s*$", "", page_title, flags=re.IGNORECASE)

overview = page.get("extract") or ""

# try to detect year from description/overview

desc = ""

terms = page.get("terms") or {}

if isinstance(terms.get("description"), list) and terms["description"]:

desc = terms["description"][0]

yr = None

for source in filter(None, [desc, overview]):

m = re.search(r"\b(19|20)\d{2}\b", source)

if m:

try:

y = int(m.group(0))

if 1878 <= y <= 2100:

yr = y

break

except:

pass

# poster

img_url = None

if isinstance(page.get("original"), dict) and page["original"].get("source"):

img_url = page["original"]["source"]

elif isinstance(page.get("thumbnail"), dict) and page["thumbnail"].get("source"):

img_url = page["thumbnail"]["source"]

poster_path = None

if img_url:

try:

os.makedirs(dest_folder, exist_ok=True)

stem = (page_title or f"page_{pageid}").replace(" ", "_")[:64]

fn = Path(dest_folder) / f"{stem}.jpg"

img_r = requests.get(img_url, headers=headers, timeout=15)

if img_r.status_code == 200 and len(img_r.content) > 1000:

with open(fn, "wb") as f:

f.write(img_r.content)

poster_path = str(fn)

except Exception:

poster_path = None

if not poster_path:

poster_path = fetch_wikipedia_poster_fallback(page_title, dest_folder=dest_folder, lang=lang)

wikidata_entity = _wikidata_get_entity_id_from_pageid(pageid, lang=lang)

wd_meta = fetch_wikidata_metadata(wikidata_entity, lang=lang) if wikidata_entity else {}

final_year = wd_meta.get("year") or yr

result = {

"title": page_title,

"year": final_year,

"overview": overview,

"poster_path": poster_path,

"genres": wd_meta.get("genres", "") or "",

"runtime_minutes": wd_meta.get("runtime_minutes"),

}

print("fetch_wikipedia_metadata_by_pageid result:", result)

return result

# -------------------- Wikipedia fetch + summary shortener --------------------

def fetch_wikipedia_metadata(title, year=None, dest_folder="posters", lang="en"):

"""

Robust metadata fetch via Wikipedia Action API.

Returns {title, year, overview, poster_path, genres, runtime_minutes}

"""

if not title:

return None

headers = {

"User-Agent": "MovieInventoryOffline/0.1 (contact: [email protected])"

}

def try_query(query_text):

params = {

"action": "query",

"format": "json",

"generator": "search",

"gsrsearch": query_text,

"gsrlimit": 1,

"prop": "pageimages|extracts|pageterms|pageprops",

"ppprop": "wikibase_item",

"exintro": 1,

"explaintext": 1,

"piprop": "original|thumbnail",

"pithumbsize": 800,

}

r = requests.get(f"https://{lang}.wikipedia.org/w/api.php",

params=params, headers=headers, timeout=12)

if r.status_code != 200:

return None

pages = r.json().get("query", {}).get("pages", {})

if not pages:

return None

return next(iter(pages.values()))

q = title.strip()

queries = []

if year:

queries.append(f"{q} {year} film")

queries += [f"{q} film", q]

page = None

for query_text in queries:

page = try_query(query_text)

if page:

break

if not page:

return None

page_title = page.get("title") or title

page_title = re.sub(r"\s*\((film|movie)\)\s*$", "", page_title, flags=re.IGNORECASE)

overview = page.get("extract") or ""

# Year from description/overview

desc = ""

terms = page.get("terms") or {}

if isinstance(terms.get("description"), list) and terms["description"]:

desc = terms["description"][0]

yr = year

for source in filter(None, [desc, overview]):

m = re.search(r"\b(19|20)\d{2}\b", source)

if m:

try:

y = int(m.group(0))

if 1878 <= y <= 2100:

yr = y

break

except:

pass

# Poster URL

img_url = None

if isinstance(page.get("original"), dict) and page["original"].get("source"):

img_url = page["original"]["source"]

elif isinstance(page.get("thumbnail"), dict) and page["thumbnail"].get("source"):

img_url = page["thumbnail"]["source"]

poster_path = None

if img_url:

try:

os.makedirs(dest_folder, exist_ok=True)

stem = page_title.replace(" ", "_")[:64]

fn = Path(dest_folder) / f"{stem}.jpg"

img_r = requests.get(img_url, headers=headers, timeout=15)

if img_r.status_code == 200 and len(img_r.content) > 1000:

with open(fn, "wb") as f:

f.write(img_r.content)

poster_path = str(fn)

except Exception:

poster_path = None

if not poster_path:

poster_path = fetch_wikipedia_poster_fallback(page_title, dest_folder=dest_folder, lang=lang)

wikidata_entity = (page.get("pageprops") or {}).get("wikibase_item")

wd_meta = fetch_wikidata_metadata(wikidata_entity, lang=lang) if wikidata_entity else {}

final_year = wd_meta.get("year") or yr

result = {

"title": page_title,

"year": final_year,

"overview": overview,

"poster_path": poster_path,

"genres": wd_meta.get("genres", "") or "",

"runtime_minutes": wd_meta.get("runtime_minutes"),

}

print("fetch_wikipedia_metadata result:", result)

return result

def shorten_overview(text, max_sentences=3, max_chars=700):

if not text:

return ""

sentences = re.split(r'(?<=[.!?])\s+', text.strip())

out = " ".join(sentences[:max_sentences]).strip()

if len(out) > max_chars:

out = out[:max_chars].rstrip() + "…"

return out

def fetch_wikipedia_poster_fallback(page_title: str, dest_folder="posters", lang="en") -> Optional[str]:

"""

Fallback poster fetch using Wikipedia REST summary endpoint.

Returns local poster path or None.

"""

if not page_title:

return None

try:

safe_title = urllib.parse.quote(page_title.replace(" ", "_"))

url = f"https://{lang}.wikipedia.org/api/rest_v1/page/summary/{safe_title}"

headers = {

"User-Agent": "MovieInventoryOffline/0.1 (contact: [email protected])"

}

r = requests.get(url, headers=headers, timeout=12)

if r.status_code != 200:

return None

data = r.json()

thumb = (data.get("thumbnail") or {}).get("source")

if not thumb:

return None

os.makedirs(dest_folder, exist_ok=True)

stem = re.sub(r"[^A-Za-z0-9_-]+", "_", page_title)[:64]

fn = Path(dest_folder) / f"{stem}.jpg"

img_r = requests.get(thumb, headers=headers, timeout=15)

if img_r.status_code == 200 and len(img_r.content) > 1000:

with open(fn, "wb") as f:

f.write(img_r.content)

return str(fn)

except Exception:

pass

return None

# -------------------- Wikidata helpers --------------------

def _safe_int_from_time_string(val: str) -> Optional[int]:

"""

Parses values like '+1999-03-31T00:00:00Z' and returns 1999.

"""

if not val:

return None

m = re.match(r"^\+?(-?\d{1,6})-", str(val))

if not m:

return None

try:

return int(m.group(1))

except Exception:

return None

def _wikidata_get_entity_id_from_pageid(pageid: int, lang="en") -> Optional[str]:

"""

Gets the Wikidata entity id (like Q12345) linked to a Wikipedia page.

"""

headers = {"User-Agent": "MovieInventoryOffline/0.1 (contact: [email protected])"}

params = {

"action": "query",

"format": "json",

"pageids": str(int(pageid)),

"prop": "pageprops",

"ppprop": "wikibase_item",

}

try:

r = requests.get(

f"https://{lang}.wikipedia.org/w/api.php",

params=params,

headers=headers,

timeout=12

)

if r.status_code != 200:

return None

pages = (r.json().get("query", {}) or {}).get("pages", {}) or {}

page = pages.get(str(int(pageid))) or {}

return page.get("pageprops", {}).get("wikibase_item")

except Exception:

return None

def _wikidata_label_map(ids: list[str], lang="en") -> dict[str, str]:

"""

Resolve Wikidata ids to labels using wbgetentities.

Returns { 'Q11424': 'film', ... }

"""

ids = [x for x in ids if x]

if not ids:

return {}

try:

params = {

"action": "wbgetentities",

"format": "json",

"ids": "|".join(ids),

"props": "labels",

"languages": f"{lang}|en",

}

r = requests.get("https://www.wikidata.org/w/api.php", params=params, timeout=15)

if r.status_code != 200:

return {}

data = r.json()

entities = data.get("entities", {}) or {}

out = {}

for qid, ent in entities.items():

labels = ent.get("labels", {}) or {}

label = None

if lang in labels:

label = labels[lang].get("value")

elif "en" in labels:

label = labels["en"].get("value")

if label:

out[qid] = label

return out

except Exception:

return {}

def _wikidata_extract_time_minutes(amount_str: str) -> Optional[int]:

"""

Parses Wikidata quantity strings like '+102' into minutes.

"""

if not amount_str:

return None

try:

return int(round(float(str(amount_str).replace("+", "").strip())))

except Exception:

return None

def fetch_wikidata_metadata(entity_id: str, lang="en") -> dict:

"""

Fetch structured metadata from Wikidata.

Useful properties:

P577 = publication date

P136 = genre

P2047 = duration

"""

result = {

"year": None,

"genres": "",

"runtime_minutes": None,

}

if not entity_id:

return result

try:

url = f"https://www.wikidata.org/wiki/Special:EntityData/{entity_id}.json"

r = requests.get(url, timeout=15)

if r.status_code != 200:

return result

data = r.json()

entity = (data.get("entities", {}) or {}).get(entity_id, {}) or {}

claims = entity.get("claims", {}) or {}

# ---- Year (P577: publication date) ----

try:

p577 = claims.get("P577", [])

if p577:

snak = p577[0].get("mainsnak", {}) or {}

dv = snak.get("datavalue", {}) or {}

val = dv.get("value", {}) or {}

time_str = val.get("time")

year = _safe_int_from_time_string(time_str)

if year and 1878 <= year <= 2100:

result["year"] = year

except Exception:

pass

# ---- Genres (P136) ----

genre_ids = []

try:

for item in claims.get("P136", []):

snak = item.get("mainsnak", {}) or {}

dv = snak.get("datavalue", {}) or {}

val = dv.get("value", {}) or {}

qid = val.get("id")

if qid:

genre_ids.append(qid)

except Exception:

pass

if genre_ids:

label_map = _wikidata_label_map(genre_ids, lang=lang)

genres = []

for qid in genre_ids:

lab = label_map.get(qid)

if lab and lab not in genres:

genres.append(lab)

result["genres"] = ", ".join(genres[:6])

# ---- Runtime (P2047: duration) ----

try:

p2047 = claims.get("P2047", [])

if p2047:

snak = p2047[0].get("mainsnak", {}) or {}

dv = snak.get("datavalue", {}) or {}

val = dv.get("value", {}) or {}

amount = val.get("amount")

minutes = _wikidata_extract_time_minutes(amount)

if minutes and 1 <= minutes <= 10000:

result["runtime_minutes"] = minutes

except Exception:

pass

except Exception:

pass

return result

# -------------------- Edit Dialog --------------------

class EditDialog(ctk.CTkToplevel):

def __init__(self, master, values):

super().__init__(master)

self.title("Edit Movie")

self.geometry("600x520")

self.resizable(True, True)

self.values = values.copy()

self.saved = False

self.transient(master); self.grab_set(); self.focus_force()

self.update_idletasks()

px, py = master.winfo_rootx(), master.winfo_rooty()

pw, ph = master.winfo_width(), master.winfo_height()

w, h = self.winfo_width(), self.winfo_height()

self.geometry(f"+{px + (pw - w)//2}+{py + (ph - h)//2}")

grid = ctk.CTkFrame(self); grid.pack(fill="both", expand=True, padx=12, pady=12)

def row(label, widget):

r = row.idx; row.idx += 1

ctk.CTkLabel(grid, text=label, anchor="w").grid(row=r, column=0, sticky="ew", padx=6, pady=6)

widget.grid(row=r, column=1, sticky="ew", padx=6, pady=6)

row.idx = 0

self.e_title = ctk.CTkEntry(grid); self.e_title.insert(0, values.get("title") or "")

self.e_year = ctk.CTkEntry(grid); self.e_year.insert(0, str(values.get("year") or ""))

self.e_genre = ctk.CTkEntry(grid); self.e_genre.insert(0, values.get("genres") or "")

self.e_run = ctk.CTkEntry(grid); self.e_run.insert(0, str(values.get("runtime_minutes") or ""))

self.e_res = ctk.CTkEntry(grid); self.e_res.insert(0, values.get("resolution") or "")

self.file_row = ctk.CTkFrame(grid, fg_color="transparent")

self.file_row.grid_columnconfigure(0, weight=1)

self.e_file = ctk.CTkEntry(self.file_row)

self.e_file.insert(0, values.get("file_path") or "")

self.e_file.grid(row=0, column=0, sticky="ew", padx=(0, 6))

self.file_browse_btn = ctk.CTkButton(

self.file_row,

text="Browse",

width=90,

command=self.browse_video_file

)

self.file_browse_btn.grid(row=0, column=1, sticky="e")

self.e_over = ctk.CTkTextbox(grid, height=120)

self.e_over.insert("1.0", values.get("overview") or "")

self.poster_path = values.get("poster_path")

self.animated_poster_path = values.get("animated_poster_path")

self.poster_btn = ctk.CTkButton(grid, text="Choose Poster", command=self.choose_poster)

self.animated_poster_btn = ctk.CTkButton(

grid,

text="Choose Animated Poster",

command=self.choose_animated_poster

)

self.clear_animated_btn = ctk.CTkButton(

grid,

text="Clear Animated Poster",

command=self.clear_animated_poster

)

self.fetch_btn = ctk.CTkButton(grid, text="Fetch Metadata (Wikipedia)", command=self.fetch_from_wiki)

row("Title", self.e_title)

row("Year", self.e_year)

row("Genres (comma separated)", self.e_genre)

row("Runtime minutes", self.e_run)

row("Resolution", self.e_res)

row("File path", self.file_row)

row("Overview", self.e_over)

row("Poster", self.poster_btn)

row("Animated Poster", self.animated_poster_btn)

row("Clear Animated", self.clear_animated_btn)

row("Fetch (Wiki)", self.fetch_btn)

grid.columnconfigure(1, weight=1)

btns = ctk.CTkFrame(self)

btns.pack(fill="x", padx=12, pady=6)

self.save_btn = ctk.CTkButton(btns, text="Save", command=self.on_save)

self.save_btn.pack(side="right", padx=6)

self.cancel_btn = ctk.CTkButton(btns, text="Cancel", command=self.destroy)

self.cancel_btn.pack(side="right", padx=6)

self.apply_theme()

def apply_theme(self):

theme = None

try:

if hasattr(self.master, "_theme"):

theme = self.master._theme()

except Exception:

theme = None

if not theme:

return

button_widgets = [

getattr(self, "file_browse_btn", None),

getattr(self, "poster_btn", None),

getattr(self, "fetch_btn", None),

getattr(self, "save_btn", None),

getattr(self, "cancel_btn", None),

]

for btn in button_widgets:

if btn is not None:

try:

btn.configure(

fg_color=theme["accent"],

hover_color=theme["accent_hover"]

)

except Exception:

pass

try:

self.cancel_btn.configure(

fg_color="#444444" if str(ctk.get_appearance_mode()).lower() == "dark" else "#d9d9d9",

hover_color="#555555" if str(ctk.get_appearance_mode()).lower() == "dark" else "#cfcfcf"

)

except Exception:

pass

def browse_video_file(self):

filetypes = [

("Video files", "*.mp4 *.mkv *.avi *.mov *.m4v *.wmv"),

("All files", "*.*"),

]

path = filedialog.askopenfilename(

title="Select Video File",

filetypes=filetypes

)

if not path:

return

self.e_file.delete(0, "end")

self.e_file.insert(0, path)

# Optional nice bonus: auto-fill runtime and resolution if available

try:

minutes, res = ffprobe_info(path)

if minutes is not None:

self.e_run.delete(0, "end")

self.e_run.insert(0, str(minutes))

if res:

self.e_res.delete(0, "end")

self.e_res.insert(0, res)

except Exception:

pass

def choose_poster(self):

path = filedialog.askopenfilename(

title="Pick poster image",

filetypes=[("Images", "*.jpg *.jpeg *.png *.webp *.bmp")]

)

if not path:

return

src = Path(path)

# 1) If the user picked a file that is already in the posters folder,

# don't copy it again – just use it as-is.

try:

if src.resolve().parent == POSTERS.resolve():

self.poster_path = str(src.resolve())

return

except Exception:

# if resolve() fails for some reason, just fall back to copy logic

pass

# 2) Otherwise, copy it into posters/ with a stable name based on title

title_for_name = (self.e_title.get() or src.stem or "poster").strip()

safe = re.sub(r"[^A-Za-z0-9_-]+", "_", title_for_name)[:64] # sanitize

dest = POSTERS / f"{safe}.jpg"

try:

img = Image.open(src).convert("RGB")

img.save(dest, "JPEG", quality=92)

self.poster_path = str(dest)

except Exception as e:

messagebox.showerror("Poster error", str(e))

def choose_animated_poster(self):

path = filedialog.askopenfilename(

title="Pick animated poster",

filetypes=[

("Animated media", "*.gif *.webp *.mp4 *.webm *.m4v"),

("GIF files", "*.gif"),

("WebP files", "*.webp"),

("MP4 files", "*.mp4"),

("WebM files", "*.webm"),

("All files", "*.*"),

]

)

if not path:

return

src = Path(path)

try:

if src.resolve().parent == POSTERS.resolve():

self.animated_poster_path = str(src.resolve())

return

except Exception:

pass

title_for_name = (self.e_title.get() or src.stem or "animated_poster").strip()

safe = re.sub(r"[^A-Za-z0-9_-]+", "_", title_for_name)[:64]

ext = src.suffix.lower() or ".mp4"

dest = POSTERS / f"{safe}_animated{ext}"

try:

dest.write_bytes(src.read_bytes())

self.animated_poster_path = str(dest)

except Exception as e:

messagebox.showerror("Animated poster error", str(e))

def clear_animated_poster(self):

self.animated_poster_path = None

messagebox.showinfo("Animated Poster", "Animated poster cleared for this item. Click Save to apply.")

def fetch_from_wiki(self):

title = (self.e_title.get() or "").strip()

year_text = (self.e_year.get() or "").strip()

year = int(year_text) if year_text.isdigit() else None

if not title:

messagebox.showinfo("Wikipedia", "Enter a title first.")

return

self.fetch_btn.configure(state="disabled")

try:

meta = fetch_wikipedia_metadata(title, year, dest_folder=str(POSTERS))

finally:

self.fetch_btn.configure(state="normal")

if not meta:

messagebox.showinfo("Wikipedia", "No Wikipedia summary found for that title.")

return

if meta.get("title"):

self.e_title.delete(0, "end")

self.e_title.insert(0, meta["title"])

if meta.get("year"):

self.e_year.delete(0, "end")

self.e_year.insert(0, str(meta["year"]))

if meta.get("overview"):

short = shorten_overview(meta["overview"], max_sentences=3, max_chars=700)

self.e_over.delete("1.0", "end")

self.e_over.insert("1.0", short)

self.e_genre.delete(0, "end")

if meta.get("genres"):

self.e_genre.insert(0, meta["genres"])

self.e_run.delete(0, "end")

if meta.get("runtime_minutes"):

self.e_run.insert(0, str(meta["runtime_minutes"]))

if meta.get("poster_path"):

self.poster_path = meta["poster_path"] # <- this line ensures the poster is saved

messagebox.showinfo("Wikipedia", "Metadata + poster fetched. Click Save to apply.")

else:

messagebox.showinfo("Wikipedia", "Metadata fetched (no poster found). Click Save to apply.")

def on_save(self):

def safe_int(s):

try:

return int(s)

except:

return None

self.values.update({

"title": (self.e_title.get() or "").strip(),

"year": safe_int((self.e_year.get() or "").strip()),

"genres": (self.e_genre.get() or "").strip(),

"runtime_minutes": safe_int((self.e_run.get() or "").strip()),

"resolution": (self.e_res.get() or "").strip(),

"file_path": (self.e_file.get() or "").strip(),

"overview": (self.e_over.get("1.0","end") or "").strip(),

"poster_path": self.poster_path,

"animated_poster_path": self.animated_poster_path,

})

if not self.values["title"]:

messagebox.showwarning("Missing title", "Title is required")

return

self.saved = True

self.destroy()

# -------------------- App UI --------------------

class MovieApp(ctk.CTk):

def __init__(self):

super().__init__()

self.title("VisionVault")

# --- TV navigation state ---

self.nav_mode = "root" # "root" or "show"

self.nav_show_id: Optional[int] = None

# --- NEW: load settings ---

self.settings = load_settings()

self.current_theme_name = self.settings.get("theme_name", "Blue")

if self.current_theme_name not in THEMES:

self.current_theme_name = "Blue"

# Remember last view mode, but do NOT apply it yet (grid can change layout)

self._saved_view_mode = self.settings.get("view_mode", "list")

if self._saved_view_mode not in ("list", "grid"):

self._saved_view_mode = "list"

geom = self.settings.get("window_geometry")

if geom:

self.geometry(geom)

else:

self.geometry("1200x850")

# load appearance mode from settings

saved_mode = self.settings.get("appearance_mode", "Dark")

if saved_mode not in ("Dark", "Light", "System"):

saved_mode = "Dark"

ctk.set_appearance_mode(saved_mode)

ctk.set_default_color_theme("blue")

# let us run custom cleanup / save on close

self.protocol("WM_DELETE_WINDOW", self.on_close)

self._build_menubar()

# Tabs

self.tabs = ctk.CTkTabview(self)

self.tabs.pack(fill="both", expand=True, padx=10, pady=10)

self.tab_library = self.tabs.add("Library")

self.tab_discover = self.tabs.add("Discover")

self.tab_stats = self.tabs.add("Stats")

# Top bar container

topbar = ctk.CTkFrame(self.tab_library)

topbar.pack(fill="x", padx=10, pady=5)

# ROW 1: theme + view + search + add controls

row1 = ctk.CTkFrame(topbar)

row1.pack(fill="x", pady=(0, 4))

# Back button (hidden until inside a show)

self.back_btn = ctk.CTkButton(

row1, text="Back",

width=70,

command=self.go_back

)

self.back_btn.pack(side="left", padx=(0, 6))

self.back_btn.pack_forget()

# View mode toggle

self.view_mode = tk.StringVar(value="list") # 'list' or 'grid'

# Remember what the user was using in the root library (grid or list)

self.root_view_mode = self.view_mode.get()

# Search (stretches)

self.search_entry = ctk.CTkEntry(row1, placeholder_text="Search title...")

self.search_entry.pack(side="left", fill="x", expand=True, padx=(0, 10))

self.search_entry.bind("<KeyRelease>", lambda e: self.refresh_list())

# Add-by-title entry (shorter, still visible)

self.add_title_entry = ctk.CTkEntry(row1, placeholder_text="Add by Title...")

self.add_title_entry.pack(side="left", padx=(0, 6), ipadx=40)

self.add_title_btn = ctk.CTkButton(

row1, text="Add", width=80,

command=self.add_by_title

)

self.add_title_btn.pack(side="left", padx=(0, 6))

self.add_file_btn = ctk.CTkButton(

row1, text="Add by File", width=110,

command=self.add_by_file

)

self.add_file_btn.pack(side="left")

self.import_movies_btn = ctk.CTkButton(

row1,

text="Import Movie Folder",

width=170,

command=self.import_movie_folder

)

self.import_movies_btn.pack(side="left", padx=(6, 0))