#!/usr/bin/env python3
# -*- coding: utf-8 -*-

from __future__ import annotations

import argparse
import dataclasses
from dataclasses import field
import datetime as dt
import json
import os
import re
import sqlite3
import sys
import time
from pathlib import Path
from typing import Dict, Iterator, List, Optional, Tuple
import urllib.request
import urllib.error

# =================
# Basics / constants
# =================

DEFAULT_GOTIFY_URL = os.getenv("GOTIFY_URL", "")
DEFAULT_GOTIFY_TOKEN = os.getenv("GOTIFY_TOKEN", "")

SONARR_TIMEOUT = int(os.getenv("SONARR_TIMEOUT", "45"))
SONARR_RETRIES = int(os.getenv("SONARR_RETRIES", "3"))
RADARR_TIMEOUT = int(os.getenv("RADARR_TIMEOUT", "45"))
RADARR_RETRIES = int(os.getenv("RADARR_RETRIES", "3"))
TMDB_TIMEOUT = int(os.getenv("TMDB_TIMEOUT", "45"))
TMDB_RETRIES = int(os.getenv("TMDB_RETRIES", "3"))

LOG_TS_FMT = "%Y-%m-%d %H:%M:%S"

VIDEO_EXTS = {".mkv", ".mp4", ".avi", ".m4v", ".mov", ".wmv", ".flv", ".webm"}
SIDECAR_EXTS = {".srt", ".sub", ".idx", ".ass", ".ssa", ".vtt", ".smi", ".rt", ".txt"}
NFO_SIMPLE_PATTERN = re.compile(r"^S\d{2}E\d{2}\.nfo$", re.IGNORECASE)

SE_EP_RX = re.compile(r"[Ss](\d{1,2})[ ._-]*[Ee](\d{1,3})")
IMDB_RX = re.compile(r"\[imdb-(tt\d+)\]", re.IGNORECASE)
TMDB_RX = re.compile(r"\[tmdb-(\d+)\]", re.IGNORECASE)
YEAR_RX = re.compile(r"\((\d{4})\)")

DEBUG_HTTP = False
DEBUG_TRUNCATE = 3000  # chars

def log(msg: str) -> None:
    ts = dt.datetime.now().strftime(LOG_TS_FMT)
    print(f"[{ts}] {msg}", flush=True)

def dlog(msg: str) -> None:
    if DEBUG_HTTP:
        log(f"[DEBUG] {msg}")

def send_gotify_notification(title: str, message: str, priority: int = 5) -> None:
    if not DEFAULT_GOTIFY_URL or not DEFAULT_GOTIFY_TOKEN:
        return
    try:
        url = f"{DEFAULT_GOTIFY_URL.rstrip('/')}/message"
        data = json.dumps({"title": title, "message": message, "priority": priority}).encode("utf-8")
        req = urllib.request.Request(url, data=data, method="POST")
        req.add_header("Content-Type", "application/json")
        req.add_header("X-Gotify-Key", DEFAULT_GOTIFY_TOKEN)
        with urllib.request.urlopen(req, timeout=15):
            pass
    except Exception as e:
        log(f"WARN: Gotify notification failed: {e}")

def load_env_file(env_path: Optional[str]) -> None:
    if not env_path:
        return
    p = Path(env_path)
    if not p.exists():
        log(f"WARN: .env not found: {env_path}")
        return
    for line in p.read_text(encoding="utf-8", errors="ignore").splitlines():
        line = line.strip()
        if not line or line.startswith("#") or "=" not in line:
            continue
        k, v = line.split("=", 1)
        k = k.strip()
        v = v.strip().strip('"').strip("'")
        os.environ[k] = v

# =================
# DB
# =================

def db_init(cx: sqlite3.Connection) -> None:
    cx.execute(
        """
        CREATE TABLE IF NOT EXISTS media_dates(
            path TEXT PRIMARY KEY,
            kind TEXT NOT NULL,
            chosen_ts INTEGER NOT NULL,
            chosen_src TEXT NOT NULL,
            extra TEXT,
            last_updated INTEGER DEFAULT (strftime('%s', 'now'))
        )
        """
    )
    cx.commit()

def db_get_cached(cx: sqlite3.Connection, path: str) -> Optional[Tuple[int, str]]:
    cur = cx.execute("SELECT chosen_ts, chosen_src FROM media_dates WHERE path = ?", (path,))
    row = cur.fetchone()
    return (int(row[0]), row[1]) if row else None

def db_upsert(cx: sqlite3.Connection, path: str, kind: str, chosen_ts: int, chosen_src: str, extra: Dict[str, object] | None) -> None:
    cx.execute(
        """
        INSERT INTO media_dates(path, kind, chosen_ts, chosen_src, extra, last_updated)
        VALUES(?,?,?,?,?,?)
        ON CONFLICT(path) DO UPDATE SET
          kind=excluded.kind,
          chosen_ts=excluded.chosen_ts,
          chosen_src=excluded.chosen_src,
          extra=excluded.extra,
          last_updated=excluded.last_updated
        """,
        (path, kind, int(chosen_ts), chosen_src, json.dumps(extra or {}, ensure_ascii=False), int(time.time())),
    )
    cx.commit()

# =================
# HTTP helper
# =================

def _pretty(obj) -> str:
    try:
        return json.dumps(obj, indent=2, ensure_ascii=False)[:DEBUG_TRUNCATE]
    except Exception:
        return str(obj)[:DEBUG_TRUNCATE]

def _req_json(
    method: str,
    url: str,
    *,
    headers: Optional[Dict[str, str]] = None,
    params: Optional[Dict[str, object]] = None,
    timeout: int = 30,
    retries: int = 2
) -> dict | list:
    from urllib.parse import urlencode
    full_url = f"{url}?{urlencode(params)}" if params else url
    last_err = None
    for attempt in range(max(1, retries)):
        try:
            dlog(f"HTTP {method} {full_url}")
            req = urllib.request.Request(full_url, method=method)
            for k, v in (headers or {}).items():
                req.add_header(k, v)
            with urllib.request.urlopen(req, timeout=timeout) as resp:
                body = resp.read()
                txt = body.decode("utf-8", errors="ignore")
                try:
                    js = json.loads(txt)
                    dlog(f"← {full_url} OK\n{_pretty(js)}")
                    return js
                except Exception as je:
                    dlog(f"← {full_url} NON-JSON ({len(txt)} bytes)\n{txt[:DEBUG_TRUNCATE]}")
                    raise RuntimeError(f"Non-JSON response from {full_url}") from je
        except urllib.error.HTTPError as e:
            last_err = e
            err_body = e.read().decode("utf-8", errors="ignore")
            dlog(f"← {full_url} HTTP {e.code}\n{err_body[:DEBUG_TRUNCATE]}")
            time.sleep(0.35)
        except Exception as e:
            last_err = e
            dlog(f"← {full_url} ERROR: {e}")
            time.sleep(0.35)
    raise last_err or RuntimeError("request failed")

# =================
# API clients + per-series cache
# =================

@dataclasses.dataclass
class SonarrClient:
    url: str
    api_key: str
    timeout: int = SONARR_TIMEOUT
    retries: int = SONARR_RETRIES
    def _h(self) -> Dict[str, str]: return {"X-Api-Key": self.api_key}
    def ping(self) -> bool:
        try:
            _req_json("GET", f"{self.url}/api/v3/system/status", headers=self._h(), timeout=self.timeout, retries=self.retries)
            return True
        except Exception as e:
            log(f"WARN: Sonarr ping failed: {e}"); return False
    def series_index(self) -> List[dict]:
        res = _req_json("GET", f"{self.url}/api/v3/series", headers=self._h(), timeout=self.timeout, retries=self.retries)
        return res if isinstance(res, list) else list(res or [])
    def history_for(self, series_id: int) -> List[dict]:
        res = _req_json(
            "GET", f"{self.url}/api/v3/history/series",
            headers=self._h(), params={"seriesId": series_id, "pageSize": 1000},
            timeout=self.timeout, retries=self.retries
        )
        if isinstance(res, dict):
            recs = res.get("records")
            return recs if isinstance(recs, list) else []
        if isinstance(res, list):
            return res
        return []
    def episodes_for(self, series_id: int) -> List[dict]:
        res = _req_json("GET", f"{self.url}/api/v3/episode", headers=self._h(), params={"seriesId": series_id}, timeout=self.timeout, retries=self.retries)
        return res if isinstance(res, list) else []

@dataclasses.dataclass
class SonarrCache:
    sc: SonarrClient
    episodes_map: Dict[int, List[dict]] = field(default_factory=dict)
    history_map: Dict[int, List[dict]] = field(default_factory=dict)

    def episodes(self, series_id: int) -> List[dict]:
        if series_id not in self.episodes_map:
            eps = self.sc.episodes_for(series_id)
            self.episodes_map[series_id] = eps
            dlog(f"Cached Sonarr episodes for series {series_id}: {len(eps)}")
        return self.episodes_map[series_id]

    def history(self, series_id: int) -> List[dict]:
        if series_id not in self.history_map:
            hist = self.sc.history_for(series_id)
            self.history_map[series_id] = hist
            dlog(f"Cached Sonarr history for series {series_id}: {len(hist)}")
        return self.history_map[series_id]

@dataclasses.dataclass
class RadarrClient:
    url: str
    api_key: str
    timeout: int = RADARR_TIMEOUT
    retries: int = RADARR_RETRIES
    def _h(self) -> Dict[str, str]: return {"X-Api-Key": self.api_key}
    def ping(self) -> bool:
        try:
            _req_json("GET", f"{self.url}/api/v3/system/status", headers=self._h(), timeout=self.timeout, retries=self.retries)
            return True
        except Exception as e:
            log(f"WARN: Radarr ping failed: {e}"); return False
    def movies_index(self) -> List[dict]:
        res = _req_json("GET", f"{self.url}/api/v3/movie", headers=self._h(), timeout=self.timeout, retries=self.retries)
        return res if isinstance(res, list) else []
    def history_for(self, movie_id: int) -> List[dict]:
        res = _req_json(
            "GET", f"{self.url}/api/v3/history/movie",
            headers=self._h(), params={"movieId": movie_id, "pageSize": 1000},
            timeout=self.timeout, retries=self.retries
        )
        if isinstance(res, dict):
            recs = res.get("records")
            return recs if isinstance(recs, list) else []
        if isinstance(res, list):
            return res
        return []

@dataclasses.dataclass
class TMDBClient:
    api_key: str
    primary_country: str = "US"
    base_url: str = "https://api.themoviedb.org/3"
    timeout: int = TMDB_TIMEOUT
    retries: int = TMDB_RETRIES
    def _p(self, **kw) -> Dict[str, object]:
        p = {"api_key": self.api_key, "language": "en-US"}; p.update(kw); return p
    def find_tv_by_imdb(self, imdb_id: str) -> Optional[int]:
        js = _req_json("GET", f"{self.base_url}/find/{imdb_id}", params=self._p(external_source="imdb_id"), timeout=self.timeout, retries=self.retries)
        lst = js.get("tv_results") if isinstance(js, dict) else None
        return lst[0].get("id") if lst else None
    def search_tv(self, name: str, year: Optional[int]) -> Optional[int]:
        js = _req_json("GET", f"{self.base_url}/search/tv", params=self._p(query=name, first_air_date_year=year or ""), timeout=self.timeout, retries=self.retries)
        res = js.get("results") if isinstance(js, dict) else None
        return res[0].get("id") if res else None
    def find_movie_by_imdb(self, imdb_id: str) -> Optional[int]:
        js = _req_json("GET", f"{self.base_url}/find/{imdb_id}", params=self._p(external_source="imdb_id"), timeout=self.timeout, retries=self.retries)
        lst = js.get("movie_results") if isinstance(js, dict) else None
        return lst[0].get("id") if lst else None
    def search_movie(self, name: str, year: Optional[int]) -> Optional[int]:
        js = _req_json("GET", f"{self.base_url}/search/movie", params=self._p(query=name, year=year or "", primary_release_year=year or ""), timeout=self.timeout, retries=self.retries)
        res = js.get("results") if isinstance(js, dict) else None
        return res[0].get("id") if res else None
    def episode_air_date(self, tv_id: int, season: int, episode: int) -> Optional[str]:
        try:
            js = _req_json("GET", f"{self.base_url}/tv/{tv_id}/season/{season}/episode/{episode}", params=self._p(), timeout=self.timeout, retries=self.retries)
            return js.get("air_date") if isinstance(js, dict) else None
        except Exception:
            return None
    def movie_release_date(self, movie_id: int) -> Optional[str]:
        try:
            js = _req_json("GET", f"{self.base_url}/movie/{movie_id}", params=self._p(), timeout=self.timeout, retries=self.retries)
            return js.get("release_date") if isinstance(js, dict) else None
        except Exception:
            return None

# =================
# Parsers
# =================

@dataclasses.dataclass
class EpisodeKey:
    series_title: str
    season: int
    episode: int
    imdb_id: Optional[str]
    tmdb_id: Optional[str]
    year: Optional[int]

def parse_episode_from_path(p: Path) -> Optional[EpisodeKey]:
    parent = p.parent
    show_dir = parent.parent.name if parent.name.lower().startswith("season ") else parent.name
    m = SE_EP_RX.search(p.name)
    if not m: return None
    season = int(m.group(1)); episode = int(m.group(2))
    imdb_id = (IMDB_RX.search(p.name) or IMDB_RX.search(show_dir) or [None, None])[1]
    tmdb_id = (TMDB_RX.search(p.name) or TMDB_RX.search(show_dir) or [None, None])[1]
    year = None
    m3 = YEAR_RX.search(show_dir)
    if m3:
        try: year = int(m3.group(1))
        except: year = None
    series_title = IMDB_RX.sub("", show_dir)
    series_title = TMDB_RX.sub("", series_title)
    series_title = YEAR_RX.sub("", series_title).strip() or show_dir
    return EpisodeKey(series_title, season, episode, imdb_id, tmdb_id, year)

@dataclasses.dataclass
class MovieKey:
    title: str
    year: Optional[int]
    imdb_id: Optional[str]
    tmdb_id: Optional[str]

def parse_movie_from_path(p: Path) -> Optional[MovieKey]:
    movie_dir = p.parent.name
    imdb_id = (IMDB_RX.search(movie_dir) or [None, None])[1]
    tmdb_id = (TMDB_RX.search(movie_dir) or [None, None])[1]
    year = None
    m3 = YEAR_RX.search(movie_dir)
    if m3:
        try: year = int(m3.group(1))
        except: year = None
    clean = IMDB_RX.sub("", movie_dir); clean = TMDB_RX.sub("", clean); clean = YEAR_RX.sub("", clean).strip() or movie_dir
    return MovieKey(clean, year, imdb_id, tmdb_id)

# =================
# Picking dates (cached lists)
# =================

def parse_date_yyyy_mm_dd(s: str) -> Optional[int]:
    try:
        y, m, d = map(int, s.split("-"))
        return int(dt.datetime(y, m, d, 0, 0, 0, tzinfo=dt.timezone.utc).timestamp())
    except Exception:
        return None

def pick_from_sonarr_import_for_episode_from_history(history: List[dict], episode_id: int) -> Optional[Tuple[int, str, Dict[str, object]]]:
    import_types = {"episodeFileImported", "downloadFolderImported", "manualImport"}
    grabbed_types = {"grabbed"}

    imports: List[Tuple[int, dict]] = []
    grabs: List[Tuple[int, dict]] = []

    for rec in history or []:
        if not isinstance(rec, dict): continue
        if int(rec.get("episodeId", -1)) != int(episode_id): continue
        et = rec.get("eventType") or ""
        date_s = rec.get("date")
        if not date_s: continue
        try:
            t = dt.datetime.fromisoformat(date_s.replace("Z", "+00:00"))
            ts = int(t.timestamp())
        except Exception:
            continue
        if et in import_types:
            imports.append((ts, rec))
        elif et in grabbed_types:
            grabs.append((ts, rec))

    if imports:
        ts, rec = sorted(imports, key=lambda x: x[0])[0]
        return ts, "sonarr_import", {"episodeId": episode_id, "eventType": rec.get("eventType")}
    if grabs:
        ts, rec = sorted(grabs, key=lambda x: x[0])[0]
        return ts, "sonarr_grabbed", {"episodeId": episode_id, "eventType": rec.get("eventType")}
    return None

def pick_from_sonarr_episode_from_list(episodes: List[dict], season: int, episode: int) -> Optional[Tuple[int, str, Dict[str, object]]]:
    for ep in episodes or []:
        if not isinstance(ep, dict): continue
        if ep.get("seasonNumber") == season and ep.get("episodeNumber") == episode:
            air = ep.get("airDateUtc") or ep.get("airDate")
            if not air: return None
            if "T" in air:
                try:
                    t = dt.datetime.fromisoformat(air.replace("Z", "+00:00"))
                    return int(t.timestamp()), "sonarr_airdate", {"episodeId": ep.get("id")}
                except Exception:
                    return None
            ts = parse_date_yyyy_mm_dd(air)
            if ts is not None:
                return ts, "sonarr_airdate", {"episodeId": ep.get("id")}
            return None
    return None

def pick_from_radarr_history(rc: RadarrClient, movie_id: int) -> Optional[Tuple[int, str, Dict[str, object]]]:
    try:
        hist = rc.history_for(movie_id)
    except Exception as e:
        log(f"WARN: Radarr history timeout/err movie={movie_id}: {e}"); return None
    best_ts = None; best = None
    for rec in hist or []:
        if not isinstance(rec, dict): continue
        date_s = rec.get("date") or ""
        if not date_s: continue
        try:
            t = dt.datetime.fromisoformat(date_s.replace("Z", "+00:00"))
            ts = int(t.timestamp())
        except Exception:
            continue
        if best_ts is None or ts < best_ts:
            best_ts = ts; best = rec
    if best_ts is not None:
        return best_ts, "radarr_history", {"history_id": (best or {}).get("id")}
    return None

# TMDB fallback (unchanged)
@dataclasses.dataclass
class TMDBMovieLike:
    title: str; year: Optional[int]; imdb_id: Optional[str]; tmdb_id: Optional[str]

def pick_from_tmdb_movie(tmdb: TMDBClient, mk: TMDBMovieLike) -> Optional[Tuple[int, str, Dict[str, object]]]:
    if not tmdb.api_key: return None
    movie_id = None
    if mk.tmdb_id:
        try: movie_id = int(mk.tmdb_id)
        except: movie_id = None
    if movie_id is None and mk.imdb_id:
        try: movie_id = tmdb.find_movie_by_imdb(mk.imdb_id)
        except Exception as e: log(f"WARN: TMDB find movie by IMDb failed {mk.imdb_id}: {e}")
    if movie_id is None:
        try: movie_id = tmdb.search_movie(mk.title, mk.year)
        except Exception as e: log(f"WARN: TMDB movie search failed title={mk.title}: {e}")
    if movie_id is None: return None
    rel = tmdb.movie_release_date(movie_id)
    if rel:
        ts = parse_date_yyyy_mm_dd(rel)
        if ts is not None:
            return ts, "tmdb_movie_release", {"tmdb_movie_id": movie_id, "release_date": rel}
    return None

def pick_from_tmdb_tv(tmdb: TMDBClient, series_title: str, season: int, episode: int, imdb_id: Optional[str], tmdb_id: Optional[str], year: Optional[int]) -> Optional[Tuple[int, str, Dict[str, object]]]:
    if not tmdb.api_key: return None
    tv_id = None
    if tmdb_id:
        try: tv_id = int(tmdb_id)
        except: tv_id = None
    if tv_id is None and imdb_id:
        try: tv_id = tmdb.find_tv_by_imdb(imdb_id)
        except Exception as e: log(f"WARN: TMDB find by IMDb failed {imdb_id}: {e}")
    if tv_id is None:
        try: tv_id = tmdb.search_tv(series_title, year)
        except Exception as e: log(f"WARN: TMDB search failed title={series_title}: {e}")
    if tv_id is None: return None
    air = tmdb.episode_air_date(tv_id, season, episode)
    if air:
        ts = parse_date_yyyy_mm_dd(air)
        if ts is not None:
            return ts, "tmdb_episode_airdate", {"tmdb_tv_id": tv_id, "air_date": air}
    return None

# =================
# NFO helpers
# =================

def create_simple_nfo(season: int, episode: int, air_date: Optional[str], date_added: Optional[str]) -> str:
    aired_tag = f"    <aired>{air_date}</aired>\n" if air_date else ""
    dateadded_tag = f"    <dateadded>{date_added}</dateadded>\n" if date_added else ""
    return f"""<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<episodedetails>
{aired_tag}{dateadded_tag}</episodedetails>"""

def create_movie_nfo(title: str, year: Optional[int] = None, release_date: Optional[str] = None, date_added: Optional[str] = None) -> str:
    premiered_tag = f"    <premiered>{release_date}</premiered>\n" if release_date else ""
    dateadded_tag = f"    <dateadded>{date_added}</dateadded>\n" if date_added else ""
    year_tag = f"    <year>{year}</year>\n" if year else ""
    title_tag = f"    <title>{title}</title>\n" if title else ""
    return f"""<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<movie>
{title_tag}{year_tag}{premiered_tag}{dateadded_tag}</movie>"""

def _set_file_ts(path: Path, ts: int, dry_run: bool) -> bool:
    if dry_run: return True
    try:
        os.utime(str(path), (ts, ts)); return True
    except Exception as e:
        log(f"WARN: Failed to set timestamp on {path}: {e}"); return False

def manage_nfo_files(
    media_dir: Path,
    kind: str,
    season: int = 0,
    episode: int = 0,
    air_date: Optional[str] = None,
    date_added: Optional[str] = None,
    title: Optional[str] = None,
    year: Optional[int] = None,
    release_date: Optional[str] = None,
    nfo_timestamp: Optional[int] = None,
    dry_run: bool = False
) -> Tuple[int, int, int]:
    created = 0; removed = 0; synced = 0

    if kind == "tv":
        simple_nfo_name = f"S{season:02d}E{episode:02d}.nfo"
        simple_nfo_path = media_dir / simple_nfo_name
        nfo_content = create_simple_nfo(season, episode, air_date, date_added)

        try:
            should_write = True
            if simple_nfo_path.exists():
                existing_content = simple_nfo_path.read_text(encoding='utf-8', errors='ignore')
                should_write = existing_content.strip() != nfo_content.strip()
            if should_write and not dry_run:
                simple_nfo_path.write_text(nfo_content, encoding='utf-8'); created = 1
            elif should_write and dry_run:
                created = 1
        except Exception as e:
            log(f"WARN: Failed to create/update {simple_nfo_path}: {e}")

        if nfo_timestamp is not None:
            if _set_file_ts(simple_nfo_path, nfo_timestamp, dry_run):
                synced += 1

        for nfo_file in media_dir.glob("*.nfo"):
            n = nfo_file.name.lower()
            if NFO_SIMPLE_PATTERN.match(nfo_file.name): continue
            if n in ("season.nfo", "tvshow.nfo"): continue
            if not dry_run:
                try: nfo_file.unlink(); removed += 1; log(f"Removed complex NFO: {nfo_file.name}")
                except Exception as e: log(f"WARN: Failed to remove {nfo_file}: {e}")
            else:
                removed += 1; log(f"Would remove complex NFO: {nfo_file.name}")

    else:
        movie_nfo_path = media_dir / "movie.nfo"
        nfo_content = create_movie_nfo(title or "", year=year, release_date=release_date, date_added=date_added)

        try:
            should_write = True
            if movie_nfo_path.exists():
                existing_content = movie_nfo_path.read_text(encoding='utf-8', errors='ignore')
                should_write = existing_content.strip() != nfo_content.strip()
            if should_write and not dry_run:
                movie_nfo_path.write_text(nfo_content, encoding='utf-8'); created = 1
            elif should_write and dry_run:
                created = 1
        except Exception as e:
            log(f"WARN: Failed to create/update {movie_nfo_path}: {e}")

        if nfo_timestamp is not None:
            if _set_file_ts(movie_nfo_path, nfo_timestamp, dry_run):
                synced += 1

    return created, removed, synced

# =================
# Sidecars
# =================

def _season_episode_token(name: str) -> Optional[Tuple[int,int]]:
    m = SE_EP_RX.search(name)
    if not m: return None
    return int(m.group(1)), int(m.group(2))

def find_sidecar_files(media_file: Path) -> List[Path]:
    sidecars: List[Path] = []
    parent_dir = media_file.parent
    base_stem = media_file.stem
    token = _season_episode_token(media_file.name)

    for f in parent_dir.iterdir():
        if not f.is_file(): continue
        if f == media_file: continue
        suf = f.suffix.lower()
        if suf not in SIDECAR_EXTS:
            continue
        if f.stem == base_stem or f.name.startswith(base_stem + "."):
            sidecars.append(f); continue
        if token:
            other = _season_episode_token(f.name)
            if other and other == token:
                sidecars.append(f); continue

    uniq: Dict[str, Path] = {}
    for s in sidecars: uniq[s.name] = s
    return list(uniq.values())

def apply_timestamp_to_file(file_path: Path, timestamp: int, dry_run: bool = False) -> bool:
    if dry_run: return True
    try:
        os.utime(str(file_path), (timestamp, timestamp)); return True
    except Exception as e:
        log(f"WARN: Failed to set timestamp on {file_path}: {e}"); return False

def iter_media_files(roots: List[str]) -> Iterator[Path]:
    for root in roots:
        base = Path(root)
        if not base.exists(): continue
        for p in base.rglob("*"):
            if p.is_file() and p.suffix.lower() in VIDEO_EXTS:
                yield p

# =================
# Sonarr series match
# =================

def choose_series_id_for_path(series_index: List[dict], fp: Path) -> Optional[int]:
    if not series_index: return None
    try:
        series_dir = fp.parent.parent.name if fp.parent.name.lower().startswith("season ") else fp.parent.name
    except Exception:
        series_dir = fp.parent.name
    base = series_dir.lower().strip()
    base = YEAR_RX.sub("", base); base = IMDB_RX.sub("", base); base = TMDB_RX.sub("", base); base = base.strip()
    for s in series_index:
        title = (s.get("title") or "").lower().strip()
        if base == title: return s.get("id")
    return None

# =================
# Main apply
# =================

def apply_command(args: argparse.Namespace) -> None:
    global DEBUG_HTTP
    DEBUG_HTTP = bool(args.debug_http)

    log("=== Media Date Sync Starting ===")
    load_env_file(args.env)

    sonarr_url = os.getenv("SONARR_URL", "http://sonarr:8989")
    sonarr_key = os.getenv("SONARR_API_KEY", "")
    radarr_url = os.getenv("RADARR_URL", "http://radarr:7878")
    radarr_key = os.getenv("RADARR_API_KEY", "")
    tmdb_key = os.getenv("TMDB_API_KEY", "")
    tmdb_country = os.getenv("TMDB_PRIMARY_COUNTRY", "US")

    log(f"SONARR_URL: {sonarr_url}")
    log(f"SONARR_API_KEY: {'SET' if sonarr_key else 'MISSING'}")
    log(f"TMDB_API_KEY: {'SET' if tmdb_key else 'MISSING'}")

    sc = None
    scache = None
    if sonarr_key and sonarr_url:
        sc = SonarrClient(sonarr_url, sonarr_key)
        if not sc.ping():
            log("WARN: Sonarr not reachable"); sc = None
        else:
            log("Sonarr connection successful")
            scache = SonarrCache(sc)
    else:
        log("WARN: Sonarr not configured")

    tmdb = TMDBClient(tmdb_key, tmdb_country)
    if not tmdb_key:
        log("WARN: TMDB not configured - limited functionality")

    cx = sqlite3.connect(args.db)
    db_init(cx)
    log(f"Database initialized: {args.db}")

    series_index: List[dict] = []
    if args.kind == "tv" and sc:
        try:
            log("Loading Sonarr series index...")
            series_index = sc.series_index()
            log(f"Loaded {len(series_index)} series from Sonarr")
        except Exception as e:
            log(f"WARN: Failed to load Sonarr series: {e}")

    roots = args.root or []
    only_file = None
    if args.path:
        p = Path(args.path)
        if p.is_file():
            roots = [str(p.parent)]
            only_file = p
        else:
            roots = [str(p)]
    if not roots:
        env_roots = os.getenv("TV_ROOTS" if args.kind == "tv" else "MOVIE_ROOTS", "")
        if env_roots:
            roots = [r for r in env_roots.split(":") if r.strip()]
            log(f"Using {'TV' if args.kind=='tv' else 'MOVIE'}_ROOTS from env: {', '.join(roots)}")
    if not roots:
        log("ERROR: No root paths specified. Use --root or set TV_ROOTS/MOVIE_ROOTS in .env"); return

    log(f"Scanning for media files in: {', '.join(roots)}")
    files = [only_file] if (only_file is not None) else list(iter_media_files(roots))
    log(f"Found {len(files)} media file(s)")
    if not files:
        log("No media files found."); return

    checked = updated = misses = cached = 0
    nfo_created = nfo_removed = sidecars_updated = nfo_ts_synced = 0
    source_counts: Dict[str, int] = {}

    log(f"Starting processing: refresh={args.refresh}, dry_run={args.dry_run}, manage_nfo={args.manage_nfo}")

    for i, fp in enumerate(files, 1):
        path = str(fp)
        if i % 25 == 1 or i <= 5:
            log(f"Processing file {i}/{len(files)}: {fp.name}")
        checked += 1

        # Cached branch
        if not args.refresh:
            cached_result = db_get_cached(cx, path)
            if cached_result:
                cached += 1
                cached_ts, cached_src = cached_result
                if i <= 5:
                    human = dt.datetime.utcfromtimestamp(cached_ts).strftime("%Y-%m-%d %H:%M:%S UTC")
                    log(f"  Using cached result: {cached_src} @ {human}")
                if apply_timestamp_to_file(fp, cached_ts, args.dry_run):
                    updated += 1
                for s in find_sidecar_files(fp):
                    if apply_timestamp_to_file(s, cached_ts, args.dry_run):
                        sidecars_updated += 1
                if args.manage_nfo:
                    date_added_str = dt.datetime.fromtimestamp(cached_ts, tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
                    if args.kind == "tv":
                        epk = parse_episode_from_path(fp)
                        if epk:
                            air = dt.datetime.fromtimestamp(cached_ts, tz=dt.timezone.utc).strftime("%Y-%m-%d") if "airdate" in cached_src else None
                            c, r, s = manage_nfo_files(fp.parent, "tv", epk.season, epk.episode, air, date_added_str, nfo_timestamp=cached_ts, dry_run=args.dry_run)
                            nfo_created += c; nfo_removed += r; nfo_ts_synced += s
                    else:
                        mk = parse_movie_from_path(fp)
                        c, r, s = manage_nfo_files(fp.parent, "movie", 0, 0, None, date_added_str, title=(mk.title if mk else None), year=(mk.year if mk else None), release_date=None, nfo_timestamp=cached_ts, dry_run=args.dry_run)
                        nfo_created += c; nfo_removed += r; nfo_ts_synced += s
                continue

        # Fresh resolution
        ts_src_extra: Optional[Tuple[int, str, Dict[str, object]]] = None
        air_date_str = date_added_str = release_date_str = None

        if args.kind == "tv":
            epk = parse_episode_from_path(fp)
            if not epk:
                if i <= 10: log(f"WARN: Could not parse episode info from: {fp.name}")
                misses += 1; continue

            series_id = choose_series_id_for_path(series_index, fp) if series_index else None

            # Prefer Sonarr episode airdate (from cached per-series episodes)
            episode_result = None
            if scache and series_id:
                eps = scache.episodes(series_id)
                episode_result = pick_from_sonarr_episode_from_list(eps, epk.season, epk.episode)
                if episode_result:
                    ts_src_extra = episode_result
                    air_date_str = dt.datetime.fromtimestamp(episode_result[0], tz=dt.timezone.utc).strftime("%Y-%m-%d")
                    date_added_str = dt.datetime.fromtimestamp(episode_result[0], tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")

                    # If we can find a *true import* for THIS episode, prefer that (original import date)
                    ep_id = episode_result[2].get("episodeId")
                    if ep_id:
                        hist = scache.history(series_id)
                        import_res = pick_from_sonarr_import_for_episode_from_history(hist, ep_id)
                        if import_res:
                            ts_src_extra = import_res  # override with import/grabbed
                            date_added_str = dt.datetime.fromtimestamp(import_res[0], tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")

            # If Sonarr missing, try TMDB (airdate fallback)
            if not ts_src_extra and tmdb_key:
                tm = pick_from_tmdb_tv(TMDBClient(tmdb_key), epk.series_title, epk.season, epk.episode, epk.imdb_id, epk.tmdb_id, epk.year)
                if tm:
                    ts_src_extra = tm
                    air_date_str = dt.datetime.fromtimestamp(tm[0], tz=dt.timezone.utc).strftime("%Y-%m-%d")
                    date_added_str = dt.datetime.fromtimestamp(tm[0], tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")

        else:
            mk = parse_movie_from_path(fp)
            if not mk:
                if i <= 10: log(f"WARN: Could not parse movie info from: {fp.name}")
                misses += 1; continue
            # (movie handling would mirror TV, omitted here for brevity)

        if not ts_src_extra and args.live_on_miss:
            try:
                mtime = int(fp.stat().st_mtime)
                ts_src_extra = (mtime, "existing_mtime", {})
                if i <= 5: log("  Using existing mtime as fallback")
            except Exception:
                ts_src_extra = None

        if not ts_src_extra:
            if i <= 10: log(f"WARN: No date found for: {fp.name}")
            misses += 1; continue

        ts, src, extra = ts_src_extra
        source_counts[src] = source_counts.get(src, 0) + 1

        skip_apply = False
        if args.only_older:
            try:
                cur_mtime = int(fp.stat().st_mtime)
                if ts >= cur_mtime:
                    skip_apply = True
                    if i <= 5: log(f"  Skipping (only-older): chosen >= current")
            except Exception:
                pass

        if not skip_apply and apply_timestamp_to_file(fp, ts, args.dry_run):
            updated += 1
        for s in find_sidecar_files(fp):
            if not skip_apply and apply_timestamp_to_file(s, ts, args.dry_run):
                sidecars_updated += 1

        if args.manage_nfo:
            if args.kind == "tv":
                epk2 = parse_episode_from_path(fp)
                c, r, s = manage_nfo_files(
                    fp.parent, "tv",
                    epk2.season if epk2 else 0,
                    epk2.episode if epk2 else 0,
                    air_date_str,
                    dt.datetime.fromtimestamp(ts, tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
                    nfo_timestamp=ts,
                    dry_run=args.dry_run
                )
            else:
                mk2 = parse_movie_from_path(fp)
                c, r, s = manage_nfo_files(
                    fp.parent, "movie", 0, 0,
                    None,
                    dt.datetime.fromtimestamp(ts, tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
                    title=(mk2.title if mk2 else None),
                    year=(mk2.year if mk2 else None),
                    release_date=release_date_str,
                    nfo_timestamp=ts,
                    dry_run=args.dry_run
                )
            nfo_created += c; nfo_removed += r; nfo_ts_synced += s

        if not args.dry_run:
            try:
                existing = db_get_cached(cx, path)
                if args.only_older and existing and ts >= existing[0]:
                    pass
                else:
                    db_upsert(cx, path, args.kind, ts, src, (extra or {}))
            except Exception as e:
                log(f"WARN: DB error: {e}")

        if i % 50 == 0:  # more frequent progress for big shows
            log(f"Progress: {i}/{len(files)} (updated: {updated}, cached: {cached}, misses: {misses})")

    completion_msg = (
        "Media date sync completed:\n"
        f"Kind: {args.kind}\n"
        f"Checked: {checked}\n"
        f"Updated: {updated}\n"
        f"Cached: {cached}\n"
        f"Misses: {misses}\n"
        f"NFO created: {nfo_created}, removed: {nfo_removed}\n"
        f"NFO timestamps synced: {nfo_ts_synced}\n"
        f"Sidecars updated: {sidecars_updated}"
    )
    if source_counts:
        src_lines = "\n".join([f"  - {k}: {v}" for k, v in sorted(source_counts.items(), key=lambda x: (-x[1], x[0]))])
        completion_msg += f"\nSources Used:\n{src_lines}"
    log(completion_msg)
    send_gotify_notification("Media Date Sync Complete", completion_msg)

# =================
# CLI
# =================

def build_arg_parser() -> argparse.ArgumentParser:
    p = argparse.ArgumentParser(description="Apply canonical mtimes to media files using Sonarr/Radarr/TMDB fallbacks.")
    sub = p.add_subparsers(dest="cmd", required=True)
    ap = sub.add_parser("apply", help="Scan, resolve dates, apply mtimes, and record to DB.")
    ap.add_argument("--env", help="Optional .env file with API keys and URLs")
    ap.add_argument("--kind", choices=["tv", "movie"], required=True, help="Media kind")
    ap.add_argument("--db", required=True, help="SQLite DB file path")
    ap.add_argument("--root", action="append", help="Root folder(s) to scan; repeatable")
    ap.add_argument("--path", help="Process a single file or a single folder (overrides --root)")
    ap.add_argument("--only-older", action="store_true", help="Backfill only: only set earlier dates; never move to a later timestamp")
    ap.add_argument("--refresh", action="store_true", help="Ignore cached results and re-fetch all dates")
    ap.add_argument("--dry-run", action="store_true", help="Do not write mtime/DB; just log what would happen")
    ap.add_argument("--live-on-miss", action="store_true", help="If no date found, keep file's current mtime as chosen date")
    ap.add_argument("--manage-nfo", action="store_true", help="Create/refresh simple NFOs (TV: SxxEyy.nfo; Movies: movie.nfo).")
    ap.add_argument("--debug-http", action="store_true", help="Verbose log of all HTTP requests/responses (Sonarr/Radarr/TMDB)")
    return p

def main() -> None:
    parser = build_arg_parser()
    args = parser.parse_args()
    try:
        if args.cmd == "apply":
            apply_command(args)
        else:
            parser.error("unknown command")
    except KeyboardInterrupt:
        log("Interrupted."); sys.exit(1)
    except Exception as e:
        log(f"FATAL ERROR: {e}")
        import traceback; traceback.print_exc(); sys.exit(1)

if __name__ == "__main__":
    main()