@serifpersia/dango 3.0.3

package/server/dist/controllers/watchlist.controller.js

@@ -0,0 +1,967 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchlistController = void 0;
+const logger_1 = __importDefault(require("../logger"));
+const sync_1 = require("../sync");
+const watchlist_repository_1 = require("../repositories/watchlist.repository");
+const watched_episodes_repository_1 = require("../repositories/watched-episodes.repository");
+const shows_meta_repository_1 = require("../repositories/shows-meta.repository");
+const notifications_repository_1 = require("../repositories/notifications.repository");
+const queue_repository_1 = require("../repositories/queue.repository");
+const settings_repository_1 = require("../repositories/settings.repository");
+const discord_rpc_1 = require("../discord-rpc");
+const db_utils_1 = require("../utils/db-utils");
+const anilist_1 = require("../lib/anilist");
+const kitsu_1 = require("../lib/kitsu");
+const migration_1 = require("../lib/migration");
+const BACKGROUND_DISCOVERY_INTERVAL_MS = 5 * 60 * 1000;
+const NUDGE_THROTTLE_MS = 120 * 1000;
+const SLOW_MAX_RUN_MS = 5 * 60 * 1000;
+class WatchlistController {
+    triggerDiscovery;
+    discoveryIntervalId = null;
+    lastExternalDiscoveryAt = 0;
+    discoveryBusy = false;
+    lastDiscoveryRunAt = 0;
+    discoveryState = 'idle';
+    discoveryTotal = 0;
+    discoveryDone = 0;
+    stopped = false;
+    stopNotificationDiscovery() {
+        this.stopped = true;
+        if (this.discoveryIntervalId !== null) {
+            clearInterval(this.discoveryIntervalId);
+            this.discoveryIntervalId = null;
+        }
+    }
+    getDiscoveryStatus = () => ({
+        running: this.discoveryBusy,
+        state: this.discoveryState,
+        total: this.discoveryTotal,
+        done: Math.min(this.discoveryDone, this.discoveryTotal),
+        lastRunAt: this.lastDiscoveryRunAt,
+    });
+    startNotificationDiscovery(getDb) {
+        const anilistIdCache = new Map();
+        const getAnilistId = async (showId, showName) => {
+            if (anilistIdCache.has(showId)) {
+                return anilistIdCache.get(showId) || null;
+            }
+            const db = getDb();
+            const meta = (await shows_meta_repository_1.ShowsMetaRepository.getById(db, showId));
+            if (meta?.anilistId) {
+                anilistIdCache.set(showId, meta.anilistId);
+                return meta.anilistId;
+            }
+            if (/^\d+$/.test(showId)) {
+                const numericId = parseInt(showId);
+                anilistIdCache.set(showId, numericId);
+                return numericId;
+            }
+            anilistIdCache.set(showId, null);
+            return null;
+        };
+        const runDiscovery = async (fast = false) => {
+            if (this.discoveryBusy || this.stopped)
+                return;
+            this.discoveryBusy = true;
+            this.discoveryState = 'running';
+            this.discoveryTotal = 0;
+            this.discoveryDone = 0;
+            const db = getDb();
+            if (!db || db.isClosedCheck()) {
+                this.discoveryBusy = false;
+                return;
+            }
+            const startedAt = Date.now();
+            const MAX_RUN_MS = fast ? 90000 : SLOW_MAX_RUN_MS;
+            try {
+                const watchingShows = await watchlist_repository_1.WatchlistRepository.getWatchingShows(db);
+                this.discoveryTotal = watchingShows.length;
+                if (watchingShows.length === 0) {
+                    this.discoveryBusy = false;
+                    return;
+                }
+                const showIdMap = new Map();
+                const MAP_CONCURRENCY = fast ? 4 : 2;
+                const anilistResults = [];
+                let nextIndex = 0;
+                const worker = async () => {
+                    while (nextIndex < watchingShows.length) {
+                        if (Date.now() - startedAt > MAX_RUN_MS)
+                            return;
+                        const show = watchingShows[nextIndex];
+                        nextIndex += 1;
+                        const id = await getAnilistId(show.id, show.name);
+                        this.discoveryDone += 1;
+                        anilistResults.push({ show, id });
+                    }
+                };
+                await Promise.all(Array.from({ length: Math.min(MAP_CONCURRENCY, watchingShows.length) }, () => worker()));
+                for (const { show, id } of anilistResults) {
+                    if (id) {
+                        showIdMap.set(show.id, id);
+                    }
+                }
+                if (Date.now() - startedAt > MAX_RUN_MS || showIdMap.size === 0) {
+                    this.discoveryBusy = false;
+                    return;
+                }
+                const now = new Date();
+                const weekStart = new Date(now);
+                weekStart.setDate(now.getDate() - 7);
+                weekStart.setHours(0, 0, 0, 0);
+                const weekEnd = new Date(now);
+                weekEnd.setHours(23, 59, 59, 999);
+                const schedules = await (0, anilist_1.getAiredEpisodesForShows)(Array.from(showIdMap.values()), weekStart, weekEnd);
+                const nowUnix = Math.floor(Date.now() / 1000);
+                const reverseMap = new Map();
+                for (const [watchlistId, anilistId] of showIdMap.entries()) {
+                    reverseMap.set(anilistId, watchlistId);
+                }
+                const finishedShowIds = new Set();
+                const unresolvedStatus = [];
+                for (const [watchlistId, anilistId] of showIdMap.entries()) {
+                    const localMeta = (await shows_meta_repository_1.ShowsMetaRepository.getById(db, watchlistId));
+                    if (localMeta?.status === 'FINISHED') {
+                        finishedShowIds.add(anilistId);
+                    }
+                    else if (!localMeta?.status) {
+                        unresolvedStatus.push({ watchlistId, anilistId });
+                    }
+                }
+                if (unresolvedStatus.length > 0 && !(0, anilist_1.isAnilistRateLimited)()) {
+                    const statuses = await (0, anilist_1.batchGetShowStatuses)(unresolvedStatus.map((s) => s.anilistId));
+                    let persisted = 0;
+                    for (const { watchlistId, anilistId } of unresolvedStatus) {
+                        const status = statuses.get(anilistId);
+                        if (status === 'FINISHED') {
+                            finishedShowIds.add(anilistId);
+                            await shows_meta_repository_1.ShowsMetaRepository.upsert(db, { id: watchlistId, status: 'FINISHED' });
+                            persisted++;
+                        }
+                        else if (status) {
+                            await shows_meta_repository_1.ShowsMetaRepository.upsert(db, { id: watchlistId, status });
+                            persisted++;
+                        }
+                    }
+                    if (persisted > 0)
+                        db.scheduleSave();
+                }
+                if (finishedShowIds.size > 0) {
+                    const monthStart = new Date(now);
+                    monthStart.setDate(now.getDate() - 30);
+                    monthStart.setHours(0, 0, 0, 0);
+                    const monthEnd = new Date(now);
+                    monthEnd.setHours(23, 59, 59, 999);
+                    const finishedSchedules = await (0, anilist_1.getAiredEpisodesForShows)(Array.from(finishedShowIds), monthStart, monthEnd);
+                    const latestFinishedByShow = new Map();
+                    for (const entry of finishedSchedules) {
+                        if (entry.airingAt > nowUnix)
+                            continue;
+                        const watchlistId = reverseMap.get(entry.mediaId);
+                        if (!watchlistId)
+                            continue;
+                        const current = latestFinishedByShow.get(watchlistId);
+                        if (!current || entry.airingAt > current.airingAt) {
+                            latestFinishedByShow.set(watchlistId, {
+                                episodeKey: String(Math.round(entry.episode)),
+                                airingAt: entry.airingAt,
+                            });
+                        }
+                    }
+                    for (const [watchlistId, { episodeKey, airingAt }] of latestFinishedByShow) {
+                        if (nowUnix - airingAt > 30 * 24 * 60 * 60)
+                            continue;
+                        const [watchedEps, dismissedEps] = await Promise.all([
+                            watched_episodes_repository_1.WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, watchlistId),
+                            notifications_repository_1.NotificationsRepository.getDismissedByShow(db, watchlistId),
+                        ]);
+                        const watchedSet = new Set(watchedEps.map((e) => e.toString()));
+                        const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
+                        if (!watchedSet.has(episodeKey) && !dismissedSet.has(episodeKey)) {
+                            await notifications_repository_1.NotificationsRepository.addDiscovered(db, watchlistId, episodeKey);
+                            db.scheduleSave();
+                        }
+                    }
+                }
+                const latestByShow = new Map();
+                for (const entry of schedules) {
+                    if (entry.airingAt > nowUnix)
+                        continue;
+                    const watchlistId = reverseMap.get(entry.mediaId);
+                    if (!watchlistId)
+                        continue;
+                    const current = latestByShow.get(watchlistId);
+                    if (!current || entry.airingAt > current.airingAt) {
+                        latestByShow.set(watchlistId, {
+                            episodeKey: String(Math.round(entry.episode)),
+                            airingAt: entry.airingAt,
+                        });
+                    }
+                }
+                for (const [watchlistId, { episodeKey, airingAt }] of latestByShow) {
+                    const [watchedEps, dismissedEps] = await Promise.all([
+                        watched_episodes_repository_1.WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, watchlistId),
+                        notifications_repository_1.NotificationsRepository.getDismissedByShow(db, watchlistId),
+                    ]);
+                    const watchedSet = new Set(watchedEps.map((e) => e.toString()));
+                    const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
+                    if (!watchedSet.has(episodeKey) && !dismissedSet.has(episodeKey)) {
+                        await notifications_repository_1.NotificationsRepository.addDiscovered(db, watchlistId, episodeKey);
+                        db.scheduleSave();
+                    }
+                }
+                await notifications_repository_1.NotificationsRepository.cleanupWatchedNotifications(db);
+            }
+            catch (e) {
+                this.discoveryState = 'error';
+                if (e?.message === 'Database is closed') {
+                    logger_1.default.info('Notification discovery stopped: database is closed');
+                }
+                else {
+                    logger_1.default.error({ err: e }, 'AniList notification discovery failed');
+                }
+            }
+            finally {
+                this.discoveryBusy = false;
+                this.lastDiscoveryRunAt = Date.now();
+                if (this.discoveryState === 'running') {
+                    this.discoveryState = this.discoveryTotal === 0 ? 'empty' : 'complete';
+                }
+            }
+        };
+        this.triggerDiscovery = (force = false) => {
+            if (this.stopped || this.discoveryBusy)
+                return false;
+            const now = Date.now();
+            if (!force && now - this.lastExternalDiscoveryAt < NUDGE_THROTTLE_MS)
+                return false;
+            this.lastExternalDiscoveryAt = now;
+            runDiscovery(force);
+            return true;
+        };
+        this.discoveryIntervalId = setInterval(() => {
+            if (!this.stopped)
+                runDiscovery(false);
+        }, BACKGROUND_DISCOVERY_INTERVAL_MS);
+    }
+    showsMetaChanged(db, showId, candidate) {
+        const existing = shows_meta_repository_1.ShowsMetaRepository.getById(db, showId);
+        if (!existing)
+            return true;
+        const differs = (incoming, stored) => {
+            if (incoming === undefined || incoming === null || incoming === '')
+                return false;
+            return String(incoming) !== String(stored ?? '');
+        };
+        return (differs(candidate.name, existing.name) ||
+            differs(candidate.thumbnail, existing.thumbnail) ||
+            differs(candidate.nativeName, existing.nativeName) ||
+            differs(candidate.englishName, existing.englishName) ||
+            differs(candidate.genres, existing.genres) ||
+            differs(candidate.popularityScore, existing.popularityScore) ||
+            differs(candidate.status, existing.status) ||
+            differs(candidate.episodeCount, existing.episodeCount) ||
+            differs(candidate.type, existing.type) ||
+            differs(candidate.anilistId, existing.anilistId) ||
+            differs(candidate.isAdult, existing.isAdult));
+    }
+    normalizeFilterValue(value) {
+        if (typeof value !== 'string')
+            return undefined;
+        const trimmed = value.trim();
+        return trimmed && trimmed !== 'ALL' ? trimmed : undefined;
+    }
+    getWatchlistFilters(query) {
+        return {
+            query: this.normalizeFilterValue(query.query),
+            type: this.normalizeFilterValue(query.type),
+            season: this.normalizeFilterValue(query.season),
+            year: this.normalizeFilterValue(query.year),
+            genres: this.normalizeFilterValue(query.genres),
+            excludeGenres: this.normalizeFilterValue(query.excludeGenres),
+            sortBy: this.normalizeFilterValue(query.sortBy),
+            titlePreference: ['name', 'nativeName', 'englishName'].includes(String(query.titlePreference))
+                ? query.titlePreference
+                : 'name',
+        };
+    }
+    matchesLocalFilters(row, filters) {
+        if (filters.query) {
+            const queryWords = new Set(filters.query
+                .toLowerCase()
+                .split(/\s+/)
+                .filter((w) => w.length >= 2));
+            const rowTitle = (row.englishName || row.name || row.nativeName || '').toLowerCase();
+            const titleWords = rowTitle.split(/\s+/);
+            const overlap = titleWords.filter((w) => queryWords.has(w)).length;
+            if (overlap < queryWords.size)
+                return false;
+        }
+        if (filters.type && row.type !== filters.type)
+            return false;
+        return true;
+    }
+    sortFilteredRows(rows, filters) {
+        const getSortTitle = (row) => {
+            const preferredTitle = filters.titlePreference ? row[filters.titlePreference] : undefined;
+            return preferredTitle || row.name || '';
+        };
+        if (filters.sortBy === 'name_asc') {
+            return [...rows].sort((a, b) => getSortTitle(a).localeCompare(getSortTitle(b)));
+        }
+        if (filters.sortBy === 'name_desc') {
+            return [...rows].sort((a, b) => getSortTitle(b).localeCompare(getSortTitle(a)));
+        }
+        return rows;
+    }
+    async getAnilistSeasonYearMatches(season, year) {
+        const matched = new Map();
+        if (!year || year === 'ALL') {
+            return matched;
+        }
+        const seasonYear = parseInt(year);
+        if (Number.isNaN(seasonYear))
+            return matched;
+        const perPage = 50;
+        let page = 1;
+        while (true) {
+            const searchVars = {
+                seasonYear,
+                page,
+                perPage,
+            };
+            if (season && season !== 'ALL') {
+                searchVars.season = season.toUpperCase();
+            }
+            const results = await (0, anilist_1.searchAnilist)(searchVars);
+            for (const show of results) {
+                if (show.anilistId) {
+                    matched.set(show.anilistId, { title: show.names || {} });
+                }
+            }
+            if (results.length < perPage)
+                break;
+            page++;
+            if (page > 10)
+                break;
+        }
+        return matched;
+    }
+    rowMatchesAnilistSeasonYear(row, anilistMatches) {
+        if (anilistMatches.size === 0)
+            return true;
+        if (/^\d+$/.test(row.id) && anilistMatches.has(parseInt(row.id))) {
+            return true;
+        }
+        const rowTitle = (row.englishName || row.name || row.nativeName || '').toLowerCase();
+        if (!rowTitle)
+            return false;
+        const rowWords = new Set(rowTitle.split(/\s+/).filter((w) => w.length >= 2));
+        if (rowWords.size === 0)
+            return false;
+        for (const [, media] of anilistMatches) {
+            const titles = [media.title?.romaji, media.title?.english, media.title?.native].filter(Boolean);
+            for (const title of titles) {
+                const titleWords = new Set(title
+                    .toLowerCase()
+                    .split(/\s+/)
+                    .filter((w) => w.length >= 2));
+                const overlap = [...rowWords].filter((w) => titleWords.has(w)).length;
+                const minLen = Math.min(rowWords.size, titleWords.size);
+                if (minLen >= 2 && overlap / minLen >= 0.7)
+                    return true;
+            }
+        }
+        return false;
+    }
+    async filterWatchlistRows(rows, filters, db) {
+        let filtered = rows.filter((row) => this.matchesLocalFilters(row, filters));
+        if ((filters.genres || filters.excludeGenres) && db) {
+            const ids = filtered.map((r) => r.id);
+            const placeholders = ids.map(() => '?').join(',');
+            const genreRows = await (0, db_utils_1.dbAll)(db, `SELECT id, genres FROM shows_meta WHERE id IN (${placeholders})`, ids);
+            const idToGenres = new Map(genreRows.map((r) => [r.id, r.genres ? JSON.parse(r.genres) : []]));
+            const includeList = filters.genres?.split(',') || [];
+            const excludeList = filters.excludeGenres?.split(',') || [];
+            filtered = filtered.filter((row) => {
+                const rowGenres = idToGenres.get(row.id) || [];
+                if (includeList.length && !includeList.every((g) => rowGenres.includes(g)))
+                    return false;
+                if (excludeList.length && excludeList.some((g) => rowGenres.includes(g)))
+                    return false;
+                return true;
+            });
+        }
+        if (((filters.season && filters.season !== 'ALL') || (filters.year && filters.year !== 'ALL')) &&
+            filtered.length > 0) {
+            const anilistMatches = await this.getAnilistSeasonYearMatches(filters.season, filters.year);
+            if (anilistMatches.size > 0) {
+                filtered = filtered.filter((row) => this.rowMatchesAnilistSeasonYear(row, anilistMatches));
+            }
+        }
+        return this.sortFilteredRows(filtered, filters);
+    }
+    async backfillMissingPosters(db, rows) {
+        const missing = rows.filter((r) => !r.thumbnail || r.thumbnail.trim() === '');
+        if (missing.length === 0)
+            return;
+        const slice = missing.slice(0, 10);
+        await Promise.allSettled(slice.map(async (row) => {
+            try {
+                const meta = await (0, anilist_1.getShowMetaById)(row.id);
+                const poster = meta?.thumbnail?.trim();
+                if (!poster)
+                    return;
+                row.thumbnail = poster;
+                const dual = row;
+                if (dual._id !== undefined)
+                    dual._id = row.id;
+                try {
+                    shows_meta_repository_1.ShowsMetaRepository.upsert(db, { id: row.id, thumbnail: poster });
+                }
+                catch {
+                    // ignore
+                }
+                try {
+                    await watchlist_repository_1.WatchlistRepository.updateThumbnail(db, row.id, poster);
+                }
+                catch {
+                    // ignore
+                }
+            }
+            catch {
+                // ignore
+            }
+        }));
+        db.scheduleSave();
+    }
+    async getContinueWatchingData(req, limit) {
+        const rows = await watched_episodes_repository_1.WatchedEpisodesRepository.getContinueWatching(req.db, limit);
+        const ignoreAdultRow = await settings_repository_1.SettingsRepository.getByKey(req.db, 'ignoreAdultContent');
+        const ignoreAdult = ignoreAdultRow ? ignoreAdultRow.value !== 'false' : true;
+        const watchlistOnlyRow = await settings_repository_1.SettingsRepository.getByKey(req.db, 'cwWatchlistOnly');
+        const watchlistOnly = watchlistOnlyRow
+            ? watchlistOnlyRow.value === 'true' || watchlistOnlyRow.value === '1'
+            : false;
+        const enrichedRows = rows
+            .filter((show) => {
+            if (ignoreAdult && show.isAdult)
+                return false;
+            if (watchlistOnly && show.watchlistStatus !== 'Watching')
+                return false;
+            return true;
+        })
+            .map((show) => ({
+            ...show,
+            episodeCount: show.episodeCount,
+            type: show.type || show.smType,
+            thumbnail: show.thumbnail ?? '',
+        }));
+        await this.backfillMissingPosters(req.db, enrichedRows);
+        return enrichedRows;
+    }
+    getAllContinueWatching = async (req, res) => {
+        const page = parseInt(req.query.page) || 1;
+        const limit = parseInt(req.query.limit) || 10;
+        const offset = (page - 1) * limit;
+        const filters = this.getWatchlistFilters(req.query);
+        const data = await this.filterWatchlistRows(await this.getContinueWatchingData(req), filters, req.db);
+        res.json({
+            data: data.slice(offset, offset + limit),
+            total: data.length,
+            page,
+            limit,
+        });
+    };
+    updateProgress = async (req, res) => {
+        const { showId: showIdRaw, episodeNumber, currentTime, duration, showName, showThumbnail, nativeName, englishName, genres, popularityScore, type, status, episodeCount, isPlaying, sessionId, isAdult, } = req.body;
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        const titlePreferenceRow = await settings_repository_1.SettingsRepository.getByKey(req.db, 'titlePreference');
+        const titlePreference = titlePreferenceRow ? titlePreferenceRow.value : 'englishName';
+        let displayName = showName;
+        if (titlePreference === 'englishName' && englishName) {
+            displayName = englishName;
+        }
+        else if (titlePreference === 'nativeName' && nativeName) {
+            displayName = nativeName;
+        }
+        discord_rpc_1.discordRPCService.updatePresence({
+            title: displayName,
+            episode: String(episodeNumber),
+            totalEpisodes: episodeCount ? String(episodeCount) : undefined,
+            currentTime: currentTime || 0,
+            duration: duration || 0,
+            thumbnail: showThumbnail || '',
+            isPlaying: isPlaying !== false,
+            sessionId,
+            isAdult,
+        });
+        const genresStr = Array.isArray(genres) ? JSON.stringify(genres) : genres;
+        const anilistId = /^\d+$/.test(showId)
+            ? ((0, db_utils_1.dbGet)(req.db, 'SELECT anilistId FROM shows_meta WHERE id = ? AND anilistId IS NOT NULL', [showId])?.anilistId ?? parseInt(showId))
+            : undefined;
+        const metaCandidate = {
+            name: showName,
+            thumbnail: showThumbnail,
+            nativeName,
+            englishName,
+            genres: genresStr,
+            popularityScore,
+            status,
+            episodeCount,
+            type,
+            anilistId,
+            isAdult: typeof isAdult === 'boolean' ? (isAdult ? 1 : 0) : null,
+        };
+        const metaChanged = this.showsMetaChanged(req.db, showId, metaCandidate);
+        if (metaChanged) {
+            await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+                shows_meta_repository_1.ShowsMetaRepository.upsert(tx, {
+                    id: showId,
+                    ...metaCandidate,
+                });
+            });
+        }
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            watched_episodes_repository_1.WatchedEpisodesRepository.upsert(tx, {
+                showId,
+                episodeNumber,
+                currentTime,
+                duration,
+            });
+            notifications_repository_1.NotificationsRepository.deleteSpecificDismissed(tx, showId, episodeNumber);
+        });
+        req.db.scheduleSave();
+        res.json({ success: true });
+    };
+    removeContinueWatching = async (req, res) => {
+        const { showId: showIdRaw } = req.body;
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            watched_episodes_repository_1.WatchedEpisodesRepository.deleteByShow(tx, showId);
+            notifications_repository_1.NotificationsRepository.deleteByShow(tx, showId);
+        });
+        res.json({ success: true });
+    };
+    async getAdultNonWatchlistShowIds(db) {
+        const rows = await (0, db_utils_1.dbAll)(db, `SELECT DISTINCT we.showId as showId
+       FROM watched_episodes we
+       JOIN shows_meta sm ON sm.id = we.showId AND sm.isAdult = 1
+       LEFT JOIN watchlist w ON w.id = we.showId
+       WHERE w.id IS NULL`);
+        return rows.map((r) => r.showId);
+    }
+    getAdultContinueWatchingCount = async (req, res) => {
+        const ids = await this.getAdultNonWatchlistShowIds(req.db);
+        res.json({ count: ids.length });
+    };
+    purgeAdultContinueWatching = async (req, res) => {
+        const ids = await this.getAdultNonWatchlistShowIds(req.db);
+        if (ids.length > 0) {
+            await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+                for (const id of ids) {
+                    watched_episodes_repository_1.WatchedEpisodesRepository.deleteByShow(tx, id);
+                    notifications_repository_1.NotificationsRepository.deleteByShow(tx, id);
+                }
+            });
+            req.db.scheduleSave();
+        }
+        res.json({ success: true, removed: ids.length });
+    };
+    batchRemoveContinueWatching = async (req, res) => {
+        const { ids: idsRaw } = req.body;
+        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
+            return res.status(400).json({ error: 'ids must be a non-empty array' });
+        }
+        const ids = await Promise.all(idsRaw.map((id) => (0, migration_1.getMigratedId)(req.db, id)));
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            for (const id of ids) {
+                watched_episodes_repository_1.WatchedEpisodesRepository.deleteByShow(tx, id);
+                notifications_repository_1.NotificationsRepository.deleteByShow(tx, id);
+            }
+        });
+        req.db.scheduleSave();
+        res.json({ success: true, removed: ids.length });
+    };
+    getWatchlist = async (req, res) => {
+        const { status, page: pageStr, limit: limitStr } = req.query;
+        const page = parseInt(pageStr) || 1;
+        const limit = parseInt(limitStr) || 10;
+        const offset = (page - 1) * limit;
+        const filters = this.getWatchlistFilters(req.query);
+        const allRows = await watchlist_repository_1.WatchlistRepository.getAll(req.db, status);
+        const filteredRows = await this.filterWatchlistRows(allRows, filters, req.db);
+        const rows = filteredRows.slice(offset, offset + limit);
+        for (const row of rows) {
+            if (!row.thumbnail || row.thumbnail.trim() === '') {
+                try {
+                    const meta = shows_meta_repository_1.ShowsMetaRepository.getById(req.db, row.id);
+                    if (meta?.thumbnail && meta.thumbnail.trim() !== '') {
+                        row.thumbnail = meta.thumbnail;
+                    }
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        await this.backfillMissingPosters(req.db, rows);
+        res.json({
+            data: rows.map((row) => ({
+                ...row,
+                _id: row.id,
+                thumbnail: row.thumbnail || '',
+            })),
+            total: filteredRows.length,
+            page,
+            limit,
+        });
+    };
+    checkWatchlist = async (req, res) => {
+        const showId = await (0, migration_1.getMigratedId)(req.db, req.params.showId);
+        const item = await watchlist_repository_1.WatchlistRepository.getById(req.db, showId);
+        res.json({ inWatchlist: !!item, status: item?.status ?? null });
+    };
+    getQueue = async (req, res) => {
+        const rows = await queue_repository_1.QueueRepository.getAll(req.db);
+        res.json(rows.map((row) => ({
+            ...row,
+            _id: row.showId,
+            id: row.id,
+            thumbnail: row.thumbnail || '',
+        })));
+    };
+    addToQueue = async (req, res) => {
+        const { showId: showIdRaw, episodeNumber, showName, showThumbnail, nativeName, englishName, type, } = req.body;
+        if (!showIdRaw || !episodeNumber) {
+            return res.status(400).json({ error: 'showId and episodeNumber are required' });
+        }
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        const existing = await queue_repository_1.QueueRepository.getByEpisode(req.db, showId, String(episodeNumber));
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            if (showName || showThumbnail || nativeName || englishName || type) {
+                shows_meta_repository_1.ShowsMetaRepository.upsert(tx, {
+                    id: showId,
+                    name: showName || '',
+                    thumbnail: showThumbnail || '',
+                    nativeName,
+                    englishName,
+                    type,
+                });
+            }
+            if (existing) {
+                queue_repository_1.QueueRepository.removeEpisode(tx, showId, String(episodeNumber));
+            }
+            else {
+                queue_repository_1.QueueRepository.addToEnd(tx, showId, String(episodeNumber));
+            }
+        });
+        req.db.scheduleSave();
+        res.json({ success: true, queued: !existing });
+    };
+    removeFromQueue = async (req, res) => {
+        const { showId: showIdRaw, episodeNumber } = req.body;
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            queue_repository_1.QueueRepository.removeEpisode(tx, showId, String(episodeNumber));
+        });
+        res.json({ success: true });
+    };
+    clearQueue = async (req, res) => {
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            queue_repository_1.QueueRepository.clear(tx);
+        });
+        res.json({ success: true });
+    };
+    reorderQueue = async (req, res) => {
+        const { items } = req.body;
+        if (!Array.isArray(items)) {
+            return res.status(400).json({ error: 'items must be an array' });
+        }
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            queue_repository_1.QueueRepository.reorder(tx, items);
+        });
+        res.json({ success: true });
+    };
+    async resolveAvailableEpisodes(db, showId) {
+        const episodeData = await (0, anilist_1.getAnilistEpisodes)(showId);
+        const episodes = Array.isArray(episodeData) && episodeData.length
+            ? [...episodeData].sort((a, b) => parseFloat(a) - parseFloat(b))
+            : [];
+        return episodes;
+    }
+    getQueueRemainingEpisodes = async (req, res) => {
+        const showIdRaw = req.params.showId;
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        const [watchedEpisodes, queuedEpisodes, episodes] = await Promise.all([
+            watched_episodes_repository_1.WatchedEpisodesRepository.getByShow(req.db, showId),
+            queue_repository_1.QueueRepository.getByShow(req.db, showId),
+            this.resolveAvailableEpisodes(req.db, showId),
+        ]);
+        const watchedSet = new Set(watchedEpisodes.map((ep) => ep.episodeNumber.toString()));
+        const queuedSet = new Set(queuedEpisodes.map((ep) => ep.episodeNumber.toString()));
+        const remaining = episodes.filter((ep) => !watchedSet.has(ep) && !queuedSet.has(ep));
+        res.json({ showId, episodes: remaining });
+    };
+    addToQueueBatch = async (req, res) => {
+        const { showId: showIdRaw, episodeNumbers, showName, showThumbnail, nativeName, englishName, type, } = req.body;
+        if (!showIdRaw || !Array.isArray(episodeNumbers) || episodeNumbers.length === 0) {
+            return res.status(400).json({ error: 'showId and episodeNumbers are required' });
+        }
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        const normalized = [...new Set(episodeNumbers.map((ep) => String(ep)))];
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            if (showName || showThumbnail || nativeName || englishName || type) {
+                shows_meta_repository_1.ShowsMetaRepository.upsert(tx, {
+                    id: showId,
+                    name: showName || '',
+                    thumbnail: showThumbnail || '',
+                    nativeName,
+                    englishName,
+                    type,
+                });
+            }
+            return queue_repository_1.QueueRepository.addManyToEnd(tx, normalized.map((episodeNumber) => ({ showId, episodeNumber })));
+        });
+        req.db.scheduleSave();
+        res.json({ success: true, added: normalized.length });
+    };
+    removeFromQueueBatch = async (req, res) => {
+        const { showId: showIdRaw, episodeNumbers } = req.body;
+        if (!showIdRaw) {
+            return res.status(400).json({ error: 'showId is required' });
+        }
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        let removed;
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            removed = (queue_repository_1.QueueRepository.getByShow(tx, showId) || []).map((ep) => ep.episodeNumber);
+            const toRemove = Array.isArray(episodeNumbers) && episodeNumbers.length
+                ? [...new Set(episodeNumbers.map((ep) => String(ep)))]
+                : removed;
+            return queue_repository_1.QueueRepository.removeMany(tx, showId, toRemove);
+        });
+        res.json({ success: true, removed: removed.length });
+    };
+    getSuggestedQueueEpisode = async (req, res) => {
+        const showIdRaw = req.params.showId;
+        const showId = await (0, migration_1.getMigratedId)(req.db, showIdRaw);
+        const resumeProgress = await watched_episodes_repository_1.WatchedEpisodesRepository.getLatestResumeProgress(req.db, showId);
+        if (resumeProgress) {
+            return res.json({
+                showId,
+                episodeNumber: resumeProgress.episodeNumber,
+                resumeTime: resumeProgress.currentTime || 0,
+            });
+        }
+        const [watchedEpisodes, episodes] = await Promise.all([
+            watched_episodes_repository_1.WatchedEpisodesRepository.getByShow(req.db, showId),
+            this.resolveAvailableEpisodes(req.db, showId),
+        ]);
+        const watchedSet = new Set(watchedEpisodes.map((ep) => ep.episodeNumber.toString()));
+        const finishedEpisodes = watchedEpisodes
+            .filter((ep) => ep.duration > 0 && ep.currentTime >= ep.duration * 0.8)
+            .map((ep) => parseFloat(ep.episodeNumber))
+            .filter((ep) => !Number.isNaN(ep));
+        const nextAfterFinished = finishedEpisodes.length > 0 ? String(Math.max(...finishedEpisodes) + 1) : undefined;
+        const episodeNumber = (nextAfterFinished &&
+            episodes.includes(nextAfterFinished) &&
+            !watchedSet.has(nextAfterFinished)
+            ? nextAfterFinished
+            : episodes.find((ep) => !watchedSet.has(ep))) ||
+            episodes[0] ||
+            '1';
+        res.json({ showId, episodeNumber, resumeTime: 0 });
+    };
+    getEpisodeProgress = async (req, res) => {
+        const showId = await (0, migration_1.getMigratedId)(req.db, req.params.showId);
+        const progress = await watched_episodes_repository_1.WatchedEpisodesRepository.getByShowAndEpisode(req.db, showId, req.params.episodeNumber);
+        res.json(progress || { currentTime: 0, duration: 0 });
+    };
+    getWatchedEpisodes = async (req, res) => {
+        const showId = await (0, migration_1.getMigratedId)(req.db, req.params.showId);
+        const episodes = await watched_episodes_repository_1.WatchedEpisodesRepository.getWatchedEpisodeNumbers(req.db, showId);
+        res.json(episodes);
+    };
+    addToWatchlist = async (req, res) => {
+        const { id: idRaw, status, nativeName, englishName } = req.body;
+        const { name, thumbnail, type, isAdult: isAdultRaw } = req.body;
+        const id = await (0, migration_1.getMigratedId)(req.db, idRaw);
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            watchlist_repository_1.WatchlistRepository.upsert(tx, {
+                id,
+                name,
+                thumbnail: thumbnail,
+                status: status || 'Watching',
+                nativeName: nativeName || '',
+                englishName: englishName || '',
+                type: type || 'TV',
+            });
+            if (typeof isAdultRaw === 'boolean') {
+                shows_meta_repository_1.ShowsMetaRepository.upsert(tx, { id, isAdult: isAdultRaw ? 1 : 0 });
+            }
+        });
+        await req.db.saveNow();
+        if (name && !/^\d+$/.test(id)) {
+            const resolveAndSave = async () => {
+                if (!(0, anilist_1.isAnilistRateLimited)()) {
+                    const result = await (0, anilist_1.searchAnilistByTitle)(name);
+                    if (result?.id) {
+                        shows_meta_repository_1.ShowsMetaRepository.upsert(req.db, { id, anilistId: result.id });
+                        req.db.scheduleSave();
+                        return;
+                    }
+                }
+                try {
+                    const kitsuResults = await (0, kitsu_1.kitsuSearchAnime)({ query: name, page: 1, perPage: 3 });
+                    if (kitsuResults.length > 0) {
+                        const anilistId = Math.abs(kitsuResults[0].id);
+                        shows_meta_repository_1.ShowsMetaRepository.upsert(req.db, { id, anilistId });
+                        req.db.scheduleSave();
+                    }
+                }
+                catch {
+                    // Kitsu failed, show will be skipped in discovery
+                }
+            };
+            resolveAndSave().catch(() => { });
+        }
+        res.json({ success: true });
+    };
+    removeFromWatchlist = async (req, res) => {
+        const { id: idRaw } = req.body;
+        const id = await (0, migration_1.getMigratedId)(req.db, idRaw);
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            watchlist_repository_1.WatchlistRepository.delete(tx, id);
+            watched_episodes_repository_1.WatchedEpisodesRepository.deleteByShow(tx, id);
+            notifications_repository_1.NotificationsRepository.deleteByShow(tx, id);
+        });
+        res.json({ success: true });
+    };
+    updateWatchlistStatus = async (req, res) => {
+        const { id: idRaw, status } = req.body;
+        const id = await (0, migration_1.getMigratedId)(req.db, idRaw);
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            watchlist_repository_1.WatchlistRepository.updateStatus(tx, id, status);
+        });
+        res.json({ success: true });
+    };
+    batchUpdateWatchlistStatus = async (req, res) => {
+        const { ids: idsRaw, status } = req.body;
+        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
+            return res.status(400).json({ error: 'ids must be a non-empty array' });
+        }
+        if (!status) {
+            return res.status(400).json({ error: 'status is required' });
+        }
+        const ids = await Promise.all(idsRaw.map((id) => (0, migration_1.getMigratedId)(req.db, id)));
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            watchlist_repository_1.WatchlistRepository.updateStatusMany(tx, ids, status);
+        });
+        req.db.scheduleSave();
+        res.json({ success: true, updated: ids.length });
+    };
+    batchRemoveFromWatchlist = async (req, res) => {
+        const { ids: idsRaw } = req.body;
+        if (!Array.isArray(idsRaw) || idsRaw.length === 0) {
+            return res.status(400).json({ error: 'ids must be a non-empty array' });
+        }
+        const ids = await Promise.all(idsRaw.map((id) => (0, migration_1.getMigratedId)(req.db, id)));
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            watchlist_repository_1.WatchlistRepository.deleteMany(tx, ids);
+            for (const id of ids) {
+                watched_episodes_repository_1.WatchedEpisodesRepository.deleteByShow(tx, id);
+                notifications_repository_1.NotificationsRepository.deleteByShow(tx, id);
+            }
+        });
+        req.db.scheduleSave();
+        res.json({ success: true, removed: ids.length });
+    };
+    getNotifications = async (req, res) => {
+        const db = req.db;
+        const watchingShows = await watchlist_repository_1.WatchlistRepository.getWatchingShows(db);
+        const notifications = [];
+        for (const show of watchingShows) {
+            try {
+                const [watchedEps, dismissedEps, discoveredEps] = await Promise.all([
+                    watched_episodes_repository_1.WatchedEpisodesRepository.getWatchedEpisodeNumbers(db, show.id),
+                    notifications_repository_1.NotificationsRepository.getDismissedByShow(db, show.id),
+                    notifications_repository_1.NotificationsRepository.getDiscoveredByShow(db, show.id),
+                ]);
+                const watchedSet = new Set(watchedEps.map((e) => e.toString()));
+                const dismissedSet = new Set(dismissedEps.map((e) => e.episodeNumber.toString()));
+                for (const discovered of discoveredEps) {
+                    if (!watchedSet.has(discovered.episodeNumber) &&
+                        !dismissedSet.has(discovered.episodeNumber)) {
+                        notifications.push({
+                            showId: show.id,
+                            name: show.name,
+                            nativeName: show.nativeName,
+                            englishName: show.englishName,
+                            thumbnail: show.thumbnail,
+                            episodeNumber: discovered.episodeNumber,
+                            id: `${show.id}-${discovered.episodeNumber}`,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                logger_1.default.error({ err: e, showId: show.id }, 'Failed to get notifications for show');
+            }
+        }
+        res.json(notifications.sort((a, b) => parseFloat(b.episodeNumber) - parseFloat(a.episodeNumber)));
+    };
+    dismissNotification = async (req, res) => {
+        const { showId, episodeNumber } = req.body;
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            notifications_repository_1.NotificationsRepository.addDismissed(tx, showId, episodeNumber);
+        });
+        res.json({ success: true });
+    };
+    clearAllNotifications = async (req, res) => {
+        const { showId } = req.body;
+        await (0, sync_1.performWriteTransaction)(req.db, (tx) => {
+            notifications_repository_1.NotificationsRepository.dismissFromDiscovered(tx, showId);
+        });
+        res.json({ success: true });
+    };
+    getThisWeekSchedule = async (req, res) => {
+        const rows = await (0, db_utils_1.dbAll)(req.db, `SELECT
+        w.id, w.name, w.thumbnail, w.nativeName, w.englishName, w.type,
+        dn.episodeNumber, dn.discoveredAt
+      FROM discovered_notifications dn
+      JOIN watchlist w ON dn.showId = w.id
+      WHERE w.status = 'Watching'
+        AND dn.episodeNumber = (
+          SELECT MAX(CAST(dn2.episodeNumber AS INTEGER))
+          FROM discovered_notifications dn2
+          WHERE dn2.showId = dn.showId
+            AND dn2.discoveredAt >= datetime('now', '-7 days')
+            AND NOT EXISTS (
+              SELECT 1 FROM watched_episodes we2
+              WHERE we2.showId = dn2.showId AND we2.episodeNumber = dn2.episodeNumber
+            )
+        )
+        AND dn.discoveredAt >= datetime('now', '-7 days')
+        AND NOT EXISTS (
+          SELECT 1 FROM watched_episodes we
+          WHERE we.showId = dn.showId AND we.episodeNumber = dn.episodeNumber
+        )
+      ORDER BY CAST(dn.episodeNumber AS INTEGER) DESC`);
+        res.json(rows.map((row) => ({
+            _id: row.id,
+            id: row.id,
+            name: row.name,
+            thumbnail: row.thumbnail || '',
+            nativeName: row.nativeName,
+            englishName: row.englishName,
+            type: row.type,
+            episodeNumber: parseInt(row.episodeNumber) || row.episodeNumber,
+        })));
+    };
+}
+exports.WatchlistController = WatchlistController;