server.js

#!/usr/bin/env node

import 'dotenv/config';
import express from 'express';
import cors from 'cors';
import { overrideConsole } from './lib/util/logger.js';
import { memoryMonitor } from './lib/util/memory-monitor.js';
import serverless from './serverless.js';
import requestIp from 'request-ip';
import rateLimit from 'express-rate-limit';
import swStats from 'swagger-stats';
import cluster from 'cluster';
import addonInterface from "./addon.js";
import streamProvider from './lib/stream-provider.js';
import * as sqliteCache from './lib/util/cache-store.js';
import * as sqliteHashCache from './lib/util/hash-cache-store.js';
import http from 'http';
import https from 'https';
import path from 'path';
import { fileURLToPath } from 'url';
import fs from 'fs';
import { execFile } from 'child_process';
import { promisify } from 'util';
import Usenet from './lib/usenet.js';
import { resolveHttpStreamUrl } from './lib/http-streams.js';
import { resolveUHDMoviesUrl } from './lib/uhdmovies.js';
import { encodeUrlForStreaming } from './lib/http-streams/utils/encoding.js';
import searchCoordinator from './lib/util/search-coordinator.js';
import * as scraperPerformance from './lib/util/scraper-performance.js';
import personalFilesCache from './lib/util/personal-files-cache.js';
import Newznab from './lib/newznab.js';
import SABnzbd from './lib/sabnzbd.js';
import crypto from 'crypto';
import { obfuscateSensitive } from './lib/common/torrent-utils.js';
import { getManifest } from './lib/util/manifest.js';
import landingTemplate from './lib/util/landingTemplate.js';
import fetch from 'node-fetch';
import debridProxyManager from './lib/util/debrid-proxy.js';
import { spawn } from 'child_process';

const execFileAsync = promisify(execFile);

async function resolveHttpStreamUrlInSubprocess(url) {
    if (!url) return null;

    for (let attempt = 1; attempt <= 2; attempt += 1) {
        try {
            const { stdout, stderr } = await execFileAsync(
                process.execPath,
                [
                    '--input-type=module',
                    '-e',
                    "globalThis.File = class File {}; const mod = await import('./lib/http-streams/resolvers/http-resolver.js'); const resolved = await mod.resolveHttpStreamUrl(process.argv[1]); console.log(JSON.stringify({ resolved })); process.exit(0);",
                    url
                ],
                {
                    cwd: process.cwd(),
                    env: {
                        ...process.env,
                        HTTP_RESOLVE_SUBPROCESS: '1',
                        DEBRID_HTTP_PROXY: '',
                        DEBRID_PER_SERVICE_PROXIES: '',
                        DEBRID_PROXY_SERVICES: '*:false'
                    },
                    timeout: parseInt(process.env.SHORTLINK_SUBPROCESS_TIMEOUT_MS || '180000', 10),
                    maxBuffer: 10 * 1024 * 1024
                }
            );

            const jsonLine = String(stdout || '')
                .split(/\r?\n/)
                .map(line => line.trim())
                .filter(Boolean)
                .reverse()
                .find(line => line.startsWith('{') && line.endsWith('}'));
            const parsed = JSON.parse(jsonLine || '{}');
            const resolved = typeof parsed?.resolved === 'string' && parsed.resolved ? parsed.resolved : null;
            if (resolved) {
                console.log(`[HTTP-RESOLVER] Subprocess shortlink resolve succeeded on attempt ${attempt}`);
                return resolved;
            }
            const stdoutTail = String(stdout || '').split(/\r?\n/).slice(-10).join('\n');
            const stderrTail = String(stderr || '').split(/\r?\n/).slice(-10).join('\n');
            console.log(`[HTTP-RESOLVER] Subprocess shortlink resolve returned no URL on attempt ${attempt}. Stdout tail:\n${stdoutTail}`);
            if (stderrTail) {
                console.log(`[HTTP-RESOLVER] Subprocess shortlink stderr tail:\n${stderrTail}`);
            }
        } catch (error) {
            console.error(`[HTTP-RESOLVER] Subprocess shortlink resolve failed on attempt ${attempt}: ${error.message}`);
        }

        if (attempt < 2) {
            await new Promise(resolve => setTimeout(resolve, 500));
        }
    }

    return null;
}

// Bot detection and anti-scraping utilities
const BOT_USER_AGENTS = [
    /bot/i,
    /crawler/i,
    /spider/i,
    /slurp/i,
    /teoma/i,
    /heritrix/i,
    /setoozbot/i,
    /discobot/i,
    /purebot/i,
    /yacybot/i,
    /acoonbot/i,
    /findlink/i,
    /linkedinbot/i,
    /embedly/i,
    /quora link preview/i,
    /ahrefsbot/i,
    /siteexplorer/i,
    /majestic12/i,
    /oozbot/i,
    /netcraft/i,
    /trendiction/i,
    /dbot/i,
    /seznambot/i,
    /ec2linkfinder/i,
    /gslfbot/i,
    /aihitbot/i,
    /intelium_bot/i,
    /facebookexternalhit/i,
    /yeti/i,
    /retrevo/i,
    /silk/i,
    /ltbot/i,
    /pinterest/i,
    /telegrambot/i,
    /tumblr/i,
    /redditbot/i,
    /slackbot/i,
    /whatsapp/i,
    /discordbot/i,
    /go-http-client/i,
    /python-requests/i,
    /axios/i,
    /node-fetch/i,
    /php-curl/i,
    /java/i,
    /okhttp/i,
    /curl/i,
    /wget/i
];

// Track suspicious IPs with detailed pattern analysis (in-memory for now, could be extended to Redis/DB)
const suspiciousIPs = new Map(); // ip -> { count, firstSeen, isBlocked, requestHistory, lastRequestTime }
const BLOCK_THRESHOLD = 20; // Increased threshold to reduce false positives (was 15)
const UNBLOCK_AFTER = 5 * 60 * 1000; // Reduced to 5 minutes (was 10 minutes) to reduce IP blocking duration
const REQUEST_WINDOW = 5 * 60 * 1000; // 5 minutes for pattern analysis
const FAST_REQUEST_THRESHOLD = 1000; // 1 second - for detecting rapid requests
const SUSPICIOUS_IPS_MAX_SIZE = 10000; // Prevent unbounded growth of IP tracking map

// Periodic cleanup of stale IP tracking entries to prevent memory leak / CPU waste
setInterval(() => {
    const now = Date.now();
    let cleaned = 0;
    for (const [ip, record] of suspiciousIPs.entries()) {
        // Remove entries that haven't been seen in the request window and aren't blocked
        if (!record.isBlocked && (now - record.lastRequestTime > REQUEST_WINDOW)) {
            suspiciousIPs.delete(ip);
            cleaned++;
        }
    }
    // Emergency eviction if still too large
    if (suspiciousIPs.size > SUSPICIOUS_IPS_MAX_SIZE) {
        const excess = suspiciousIPs.size - SUSPICIOUS_IPS_MAX_SIZE;
        const keys = suspiciousIPs.keys();
        for (let i = 0; i < excess; i++) {
            const key = keys.next().value;
            if (key) suspiciousIPs.delete(key);
        }
        cleaned += excess;
    }
    if (cleaned > 0) {
        console.log(`[BOT-DETECTION] Cleaned ${cleaned} stale IP entries (remaining: ${suspiciousIPs.size})`);
    }
}, 60000); // Every 60 seconds

// Bot detection middleware with pattern analysis
function botDetectionMiddleware(req, res, next) {
    // Allow resolver endpoints to bypass bot detection (needed for HLS segment spam)
    if (req.path.startsWith('/resolve/httpstreaming')) {
        return next();
    }
    const clientIp = req.clientIp || requestIp.getClientIp(req);
    req.clientIp = clientIp;
    const userAgent = req.get('User-Agent') || '';
    const acceptHeader = req.get('Accept') || '';
    const acceptEncoding = req.get('Accept-Encoding') || '';
    const currentTime = Date.now();

    let suspiciousScore = 0;
    const reasons = [];

    // Removed User-Agent bot pattern check as it was blocking too many legitimate requests
    // Some legitimate clients have User-Agent strings that match bot patterns

    // Removed missing User-Agent check as it was blocking too many legitimate requests
    // Many browsers and clients don't always send User-Agent or send empty values

    // Removed Accept header check as it was flagging legitimate browser requests
    // Many browsers and clients send generic Accept headers on resolver endpoints

    // Removed Accept-Language check as it was blocking too many legitimate requests
    // Many browsers and clients don't always send Accept-Language header

    // Make Stremio User-Agent check less strict - allow other valid clients
    // Removed the strict check for Stremio in resolver endpoints to be less restrictive

    // Request pattern analysis - made more lenient
    let ipRecord = suspiciousIPs.get(clientIp) || {
        count: 0,
        firstSeen: currentTime,
        isBlocked: false,
        requestHistory: [],
        lastRequestTime: 0  // Set to 0 so first request isn't flagged as rapid
    };

    // Add current request to history
    ipRecord.requestHistory.push({
        time: currentTime,
        path: req.path,
        method: req.method
    });

    // Clean old requests from history (older than 5 minutes) and cap array size
    ipRecord.requestHistory = ipRecord.requestHistory.filter(
        req => currentTime - req.time < REQUEST_WINDOW
    );
    // Hard cap to prevent runaway memory/CPU in request history scanning
    if (ipRecord.requestHistory.length > 200) {
        ipRecord.requestHistory = ipRecord.requestHistory.slice(-200);
    }

    // Check for high frequency requests - made more lenient
    const recentRequests = ipRecord.requestHistory.filter(
        r => currentTime - r.time < 10000 // last 10 seconds
    );

    if (recentRequests.length > 50) { // Increased threshold from 25 (was too restrictive)
        suspiciousScore += 2;
        reasons.push(`High frequency: ${recentRequests.length} requests in 10s`);
    } else if (recentRequests.length > 30) { // Increased threshold from 15 (was too restrictive)
        suspiciousScore += 1;
        reasons.push(`Moderate frequency: ${recentRequests.length} requests in 10s`);
    }

    // Check for rapid successive requests - made more lenient (allow 200ms instead of 100ms)
    const timeSinceLastRequest = currentTime - ipRecord.lastRequestTime;
    if (timeSinceLastRequest < 20) { // Only flag if <20ms (was <50ms) - increased to be more permissive
        suspiciousScore += 1;
        reasons.push(`Very rapid requests: ${timeSinceLastRequest}ms interval`);
    }

    // Check for pattern of accessing many different resolver endpoints quickly - made much more lenient
    const resolverRequests = ipRecord.requestHistory.filter(r => r.path.startsWith('/resolve/'));
    const uniqueResolverPaths = new Set(resolverRequests.map(r => r.path)).size;

    if (resolverRequests.length > 60 && uniqueResolverPaths > 30) { // Increased significantly (was 30 and 15)
        suspiciousScore += 2;
        reasons.push(`Multiple resolver endpoints accessed: ${uniqueResolverPaths} unique paths`);
    }

    // Check for sequential or patterned access - made much more lenient
    if (resolverRequests.length > 20) { // Increased from 10 (was too sensitive)
        // Only check if there's a high number of resolver requests
        const pathPatterns = resolverRequests.map(r => r.path);
        // Count how many paths are similar (indicating systematic scraping)
        let similarCount = 0;
        for (let i = 0; i < pathPatterns.length - 1; i++) {
            if (pathPatterns[i] !== pathPatterns[i + 1]) {
                // Check if paths are very similar (potential scraping pattern)
                const currentPath = pathPatterns[i];
                const nextPath = pathPatterns[i + 1];

                // If the paths are in the same endpoint family but different params, it could be scraping
                if (currentPath.split('/')[1] === nextPath.split('/')[1]) {
                    similarCount++;
                }
            }
        }

        if (similarCount > 15) { // Increased from 8 (was too sensitive)
            suspiciousScore += 1;
            reasons.push(`Patterned access: ${similarCount} similar endpoints`);
        }
    }

    // Add current score to IP record
    ipRecord.count += suspiciousScore;
    ipRecord.lastRequestTime = currentTime;

    // Block if score exceeds threshold (increased to reduce false positives)
    if (ipRecord.count >= BLOCK_THRESHOLD && !ipRecord.isBlocked) {
        ipRecord.isBlocked = true;
        console.log(`[BOT-DETECTION] Blocking IP ${clientIp} for suspicious activity: ${reasons.join(', ')}`);

        // Set timeout to unblock after period
        setTimeout(() => {
            if (suspiciousIPs.has(clientIp)) {
                suspiciousIPs.delete(clientIp);
            }
        }, UNBLOCK_AFTER);
    }

    // If IP is blocked, reject the request
    if (ipRecord.isBlocked) {
        console.log(`[BOT-DETECTION] Rejecting request from blocked IP ${clientIp}`);
        return res.status(429).json({
            success: false,
            message: 'Request blocked due to suspicious activity. Please try again later.'
        });
    }

    // Update IP record
    suspiciousIPs.set(clientIp, ipRecord);

    if (suspiciousScore > 0) {
        console.log(`[BOT-DETECTION] Suspicious request from ${clientIp}: score=${suspiciousScore}, reasons=[${reasons.join(', ')}], UA="${userAgent}"`);
    }

    next();
}

// Ensure data directory exists before other imports
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const dataDir = path.join(__dirname, 'data');

if (!fs.existsSync(dataDir)) {
    console.log(`[SERVER] Creating data directory: ${dataDir}`);
    fs.mkdirSync(dataDir, { recursive: true });
    console.log(`[SERVER] Created data directory: ${dataDir}`);
} else {
    console.log(`[SERVER] Data directory already exists: ${dataDir}`);
}

// Cache backend selection (sqlite default, postgres optional)
const cacheBackend = (process.env.CACHE_BACKEND || 'sqlite').toLowerCase();
const cacheBackendLabel = cacheBackend === 'postgres' ? 'Postgres' : 'SQLite';
console.log(`[CACHE] Using ${cacheBackendLabel} for caching`);

// Override console to respect LOG_LEVEL environment variable
overrideConsole();

// CRITICAL: Global error handlers to prevent memory leaks from unhandled errors (worker processes)
process.on('unhandledRejection', (reason, promise) => {
    console.error('[WORKER-CRITICAL] Unhandled Promise Rejection:', reason?.message || reason);
    // Don't log the full error object to avoid retaining large response bodies in memory
});

process.on('uncaughtException', (error) => {
    console.error('[WORKER-CRITICAL] Uncaught Exception:', error?.message || error);
    // Don't log the full error object to avoid retaining large response bodies in memory
});

// Import compression if available, otherwise provide a no-op middleware
let compression = null;
let compressionFilter = null;
try {
  const compressionModule = await import('compression');
  compression = compressionModule.default;
  compressionFilter = compressionModule.filter;
} catch (e) {
  console.warn('Compression middleware not available, using no-op middleware');
  compression = () => (req, res, next) => next(); // No-op if compression not available
  compressionFilter = () => true;
}



// Function to check memory usage and clear caches if needed
function checkMemoryUsage() {
    const memoryUsage = process.memoryUsage();
    const rssInMB = memoryUsage.rss / 1024 / 1024;
    const heapUsedInMB = memoryUsage.heapUsed / 1024 / 1024;
    
    // If we're using more than 700MB RSS or 400MB heap, log a warning and consider cleanup
    if (rssInMB > 700 || heapUsedInMB > 400) {
        console.warn(`[MEMORY] High memory usage - RSS: ${rssInMB.toFixed(2)}MB, Heap: ${heapUsedInMB.toFixed(2)}MB`);
        return true; // Indicate high memory usage
    }
    return false; // Memory usage is OK
}

// MEMORY LEAK FIX: Add size limits and proper cleanup for URL caches
// Using in-memory cache with SQLite for persistence
const RESOLVED_URL_CACHE = new Map();
const RESOLVED_URL_CACHE_MAX_SIZE = 500; // Reduced from 2000 to prevent memory issues
const CACHE_TIMERS = new Map(); // Track setTimeout IDs for proper cleanup
const PENDING_RESOLVES = new Map();
const PENDING_RESOLVES_MAX_SIZE = 100; // Reduced from 1000 to prevent memory issues

// Helper function to evict oldest cache entry (LRU-style FIFO eviction)
function evictOldestCacheEntry() {
    if (RESOLVED_URL_CACHE.size >= RESOLVED_URL_CACHE_MAX_SIZE) {
        const firstKey = RESOLVED_URL_CACHE.keys().next().value;
        RESOLVED_URL_CACHE.delete(firstKey);

        // Clear associated timer to prevent memory leak
        const timerId = CACHE_TIMERS.get(firstKey);
        if (timerId) {
            clearTimeout(timerId);
            CACHE_TIMERS.delete(firstKey);
        }

        console.log(`[CACHE] Evicted oldest entry (cache size: ${RESOLVED_URL_CACHE.size})`);
    }
}

// Helper function to set cache with proper timer tracking
async function setCacheWithTimer(cacheKey, value, ttlMs) {
    // Evict old entries if needed
    evictOldestCacheEntry();

    // Clear existing timer if re-caching
    const existingTimer = CACHE_TIMERS.get(cacheKey);
    if (existingTimer) {
        clearTimeout(existingTimer);
    }

    // Set cache value in local memory
    RESOLVED_URL_CACHE.set(cacheKey, value);

    // Set new timer and track it
    const timerId = setTimeout(() => {
        RESOLVED_URL_CACHE.delete(cacheKey);
        CACHE_TIMERS.delete(cacheKey);
    }, ttlMs);

    CACHE_TIMERS.set(cacheKey, timerId);
}

// Helper function to get cached value from local cache
async function getCacheValue(cacheKey) {
    if (RESOLVED_URL_CACHE.has(cacheKey)) {
        const value = RESOLVED_URL_CACHE.get(cacheKey);
        console.log(`[CACHE] Cache hit for key: ${cacheKey.substring(0, 8)}...`);
        return value;
    }

    return null;
}

function normalizeClientIp(rawIp) {
    if (!rawIp) return '';
    const ip = String(rawIp).trim();
    if (!ip) return '';
    return ip.split(',')[0].trim();
}

function buildResolverScopeKey(debridProvider, debridApiKey, decodedUrl, clientIp) {
    const urlHash = crypto.createHash('md5').update(decodedUrl).digest('hex');
    const tokenHash = crypto.createHash('sha256').update(String(debridApiKey || '')).digest('hex').slice(0, 16);
    const normalizedIp = normalizeClientIp(clientIp) || 'no-ip';
    const ipHash = crypto.createHash('sha256').update(normalizedIp).digest('hex').slice(0, 16);
    return `${debridProvider}:${urlHash}:${tokenHash}:${ipHash}`;
}

const app = express();

// Cache client IP on the request once to avoid repeated lookups in downstream middleware
app.use((req, res, next) => {
    if (!req.clientIp) {
        req.clientIp = requestIp.getClientIp(req);
    }
    next();
});

app.get('/', (req, res) => {
    res.redirect('/configure');
});
app.get('/configure', async (req, res) => {
    const manifest = getManifest({}, true);
    res.send(await landingTemplate(manifest, {}));
});

// HTTP Streams Health Status — cached in memory so last results survive restarts
// (files in data/ persist on disk; memory cache is a fast-path fallback)
const healthStatusDir = path.join(path.dirname(fileURLToPath(import.meta.url)), 'data');
const healthStatusCache = { md: null, json: null };

function readHealthFile(filename) {
    const filePath = path.join(healthStatusDir, filename);
    try {
        if (fs.existsSync(filePath)) {
            const content = fs.readFileSync(filePath, 'utf8');
            // Update in-memory cache whenever we successfully read from disk
            const key = filename.endsWith('.json') ? 'json' : 'md';
            healthStatusCache[key] = content;
            return content;
        }
    } catch { /* fall through to cache */ }
    // Return cached version if disk read fails
    const key = filename.endsWith('.json') ? 'json' : 'md';
    return healthStatusCache[key];
}

// Pre-load cache from disk on startup (survives reboot as long as data/ persists)
try {
    readHealthFile('http-streams-status.md');
    readHealthFile('http-streams-status.json');
} catch { /* ignore — first run */ }

// HTTP Streams Health Check Dashboard
app.get('/health', (req, res) => {
    try {
        const dashboardPath = path.join(path.dirname(fileURLToPath(import.meta.url)), 'scripts', 'health-dashboard.html');
        const html = fs.readFileSync(dashboardPath, 'utf8');
        res.setHeader('Content-Type', 'text/html; charset=utf-8');
        res.send(html);
    } catch (err) {
        res.status(500).json({ error: 'Dashboard not found', message: err.message });
    }
});

// HTTP Streams Status (Markdown)
app.get('/http-streams-status', (req, res) => {
    const content = readHealthFile('http-streams-status.md');
    if (!content) {
        return res.status(404).json({ error: 'Health check has not run yet' });
    }
    res.setHeader('Content-Type', 'text/markdown; charset=utf-8');
    res.send(content);
});

// HTTP Streams Status (JSON)
app.get('/http-streams-status.json', (req, res) => {
    const content = readHealthFile('http-streams-status.json');
    if (!content) {
        return res.status(404).json({ error: 'Health check has not run yet' });
    }
    res.setHeader('Content-Type', 'application/json; charset=utf-8');
    res.send(content);
});

app.get('/manifest-no-catalogs.json', (req, res) => {
    const manifest = getManifest({}, true);
    res.json(manifest);
});

// Track active Usenet streams: nzoId -> { lastAccess, streamCount, config, videoFilePath, usenetConfig }
const ACTIVE_USENET_STREAMS = new Map();

/**
 * Stream error video from Python server (proxy through Node)
 * TVs and some video players don't follow 302 redirects, so we proxy instead
 * @param {string} errorText - The error message to display
 * @param {object} res - Express response object
 * @param {string} fileServerUrl - Python file server URL
 */
async function redirectToErrorVideo(errorText, res, fileServerUrl) {
    console.log(`[ERROR-VIDEO] Streaming error video: "${errorText}"`);

    try {
        const axios = (await import('axios')).default;

        // URL-encode the error message
        const encodedMessage = encodeURIComponent(errorText);

        // Construct error video URL on Python server
        const errorUrl = `${fileServerUrl.replace(/\/$/, '')}/error?message=${encodedMessage}`;

        console.log(`[ERROR-VIDEO] Fetching from: ${errorUrl}`);

        // Fetch the error video from Python server
        const response = await axios({
            method: 'GET',
            url: errorUrl,
            responseType: 'stream',
            timeout: 30000
        });

        // Copy headers from Python server
        res.status(200);
        res.set('Content-Type', response.headers['content-type'] || 'video/mp4');
        if (response.headers['content-length']) {
            res.set('Content-Length', response.headers['content-length']);
        }
        res.set('Accept-Ranges', 'bytes');
        res.set('Cache-Control', 'public, max-age=3600'); // Cache for 1 hour

        // Pipe the video stream to the client
        // Note: pipe() automatically ends the response when the source stream ends
        response.data.pipe(res);

        // Log when streaming completes
        response.data.on('end', () => {
            console.log(`[ERROR-VIDEO] ✓ Finished streaming error video`);
        });

        // Handle errors during streaming
        response.data.on('error', (err) => {
            console.error(`[ERROR-VIDEO] Stream error: ${err.message}`);
            // CRITICAL: Destroy the stream on error to prevent memory leak
            if (response.data && typeof response.data.destroy === 'function') {
                response.data.destroy();
            }
            if (!res.headersSent) {
                res.status(500).end();
            }
        });

        // CRITICAL: Clean up stream when client disconnects
        res.on('close', () => {
            if (response.data && typeof response.data.destroy === 'function') {
                response.data.destroy();
            }
        });

    } catch (error) {
        console.error(`[ERROR-VIDEO] Failed to fetch error video: ${error.message}`);
        if (!res.headersSent) {
            res.status(500).send(`Error: ${errorText}`);
        }
    }
}

// Note: Proxy requests removed - we now use direct 302 redirects to Python file server
// This eliminates proxy overhead and allows proper client disconnect detection

// Store Usenet configs globally (so auto-clean works even without active streams)
const USENET_CONFIGS = new Map(); // fileServerUrl -> config
// Track pending Usenet submissions to prevent race conditions
const PENDING_USENET_SUBMISSIONS = new Map(); // title -> Promise

// Cleanup interval for inactive streams (check every 2 minutes)
const STREAM_CLEANUP_INTERVAL = 2 * 60 * 1000;
// Delete downloads after 10 minutes of inactivity
// This is aggressive to save bandwidth and disk space
// If user was just paused/buffering, they can restart the stream
const STREAM_INACTIVE_TIMEOUT = 10 * 60 * 1000; // 10 minutes of inactivity


// Performance: Set up connection pooling and reuse
app.set('trust proxy', true); // Trust proxy headers if behind reverse proxy
app.set('etag', false); // Disable etag generation for static performance

app.use(cors());

// Event loop overload protection - prevents death spiral under heavy load
// Monitors event loop lag and returns 503 when the server is overwhelmed
const OVERLOAD_LAG_THRESHOLD_MS = parseInt(process.env.OVERLOAD_LAG_THRESHOLD || '2000', 10);
const OVERLOAD_CHECK_INTERVAL_MS = 500;
let eventLoopLag = 0;
let overloadCheckTimer = null;

function startOverloadMonitor() {
    let lastCheck = process.hrtime.bigint();
    overloadCheckTimer = setInterval(() => {
        const now = process.hrtime.bigint();
        const elapsed = Number(now - lastCheck) / 1e6; // ms
        eventLoopLag = Math.max(0, elapsed - OVERLOAD_CHECK_INTERVAL_MS);
        lastCheck = now;
    }, OVERLOAD_CHECK_INTERVAL_MS);
    if (overloadCheckTimer.unref) overloadCheckTimer.unref();
}
startOverloadMonitor();

const OVERLOAD_SKIP_PREFIXES = ['/configure', '/manifest.json', '/manifest-no-catalogs.json'];

app.use((req, res, next) => {
    if (eventLoopLag > OVERLOAD_LAG_THRESHOLD_MS) {
        // Allow lightweight endpoints through even under load
        if (req.path === '/' || OVERLOAD_SKIP_PREFIXES.some(p => req.path === p || req.path.startsWith(p))) {
            return next();
        }
        console.error(`[OVERLOAD] Rejecting request (lag: ${Math.round(eventLoopLag)}ms): ${req.method} ${req.path.substring(0, 80)}`);
        res.status(503).json({ streams: [], err: 'Server overloaded, please retry shortly' });
        return;
    }
    next();
});

// Anti-bot detection middleware
app.use(botDetectionMiddleware);

const COMPRESSION_SKIP_PREFIXES = ['/resolve', '/usenet']; // Skip compression for streaming/redirect-heavy paths to save CPU

// Performance: Add compression for API responses
app.use(compression({
    level: 6, // Balanced compression level
    threshold: 1024, // Only compress responses larger than 1KB
    filter: (req, res) => {
        if (COMPRESSION_SKIP_PREFIXES.some(prefix => req.path.startsWith(prefix))) {
            return false;
        }
        return compressionFilter(req, res);
    }
}));

// Swagger stats middleware - disabled by default to save CPU under load
// Set SWAGGER_STATS_ENABLED=true in .env to re-enable
if (process.env.SWAGGER_STATS_ENABLED === 'true') {
    app.use(swStats.getMiddleware({
        name: addonInterface.manifest.name,
        version: addonInterface.manifest.version,
    }));
    console.log('[SERVER] swagger-stats enabled');
}

// Global rate limiter - more permissive limits
const globalRateLimiter = rateLimit({
    windowMs: 15 * 60 * 1000, // 15 minutes
    limit: 400, // Increased from 200 to 400 requests per window
    standardHeaders: true,
    legacyHeaders: false,
    keyGenerator: (req) => req.clientIp || requestIp.getClientIp(req),
    message: {
        success: false,
        message: 'Too many requests from this IP, please try again later.'
    },
    skip: (req) => {
        // Skip rate limiting for health checks and internal endpoints
        const skipPaths = ['/configure', '/manifest-no-catalogs.json', '/'];
        return skipPaths.includes(req.path);
    }
});

// Specific rate limiter for resolve endpoints (more permissive limits)
const resolveRateLimiter = rateLimit({
    windowMs: 10 * 60 * 1000, // 10 minutes
    limit: 80, // Increased from 40 to 80 resolve requests per window
    standardHeaders: true,
    legacyHeaders: false,
    keyGenerator: (req) => req.clientIp || requestIp.getClientIp(req),
    message: {
        success: false,
        message: 'Too many resolve requests from this IP, please try again later.'
    }
});

// Graceful shutdown - properly close all connections
let isShuttingDown = false;
for (const sig of ["SIGINT","SIGTERM"]) {
    process.on(sig, async () => {
        if (isShuttingDown) return; // Prevent multiple shutdown attempts
        isShuttingDown = true;

        console.log(`[SERVER] Received ${sig}. Shutting down gracefully...`);

        // Clear all intervals and timeouts
        try {
            if (cleanupIntervalId) clearInterval(cleanupIntervalId);
            if (autoCleanIntervalId) clearInterval(autoCleanIntervalId);
            if (autoCleanTimeoutId) clearTimeout(autoCleanTimeoutId);
            if (monitorIntervalId) clearInterval(monitorIntervalId);



            // MEMORY LEAK FIX: Clear all pending cache timers
            for (const timerId of CACHE_TIMERS.values()) {
                clearTimeout(timerId);
            }
            CACHE_TIMERS.clear();
            console.log('[SERVER] All intervals, timeouts, and cache timers cleared');
        } catch (error) {
            console.error(`[SERVER] Error clearing intervals: ${error.message}`);
        }

        // Close SQLite connections
        try {
            await Promise.all([
                sqliteCache.closeSqlite(),
                sqliteHashCache.closeConnection()
            ]);
            console.log('[SERVER] All SQLite connections closed');
        } catch (error) {
            console.error(`[SERVER] Error closing SQLite connections: ${error.message}`);
        }

        // MEMORY LEAK FIX: Shutdown additional modules with cleanup intervals
        try {
            searchCoordinator.shutdown();
            scraperPerformance.shutdown();
            Usenet.shutdown();
            console.log('[SERVER] All module cleanup intervals stopped');
        } catch (error) {
            console.error(`[SERVER] Error shutting down modules: ${error.message}`);
        }

        // Close HTTP server
        server.close(() => {
            console.log('[SERVER] HTTP server closed');
            process.exit(0);
        });

        // Force exit after 10 seconds if graceful shutdown fails
        setTimeout(() => {
            console.error('[SERVER] Forced shutdown after timeout');
            process.exit(1);
        }, 10000).unref();
    });
}
app.use(globalRateLimiter);

// VVVV REVERTED: The resolver now performs a simple redirect VVVV
app.get('/resolve/:debridProvider/:debridApiKey/:url', resolveRateLimiter, async (req, res) => {
    const { debridProvider, debridApiKey, url } = req.params;

    // Validate required parameters
    if (!url || url === 'undefined') {
        console.error('[RESOLVER] Missing or invalid URL parameter');
        return res.status(400).send('Missing or invalid URL parameter');
    }

    const decodedUrl = decodeURIComponent(url);
    const clientIp = normalizeClientIp(req.clientIp || requestIp.getClientIp(req));
    req.clientIp = clientIp;

    // Extract config from query if provided (for NZB resolution)
    const configParam = req.query.config;
    let config = {};
    if (configParam) {
        try {
            // Safe parsing with memory and size limits
            const decodedConfigParam = decodeURIComponent(configParam);
            // Check size before parsing to prevent memory issues
            if (decodedConfigParam.length > 100000) { // 100KB limit
                console.log('[RESOLVER] Config parameter too large, rejecting');
                return res.status(400).send('Config parameter too large');
            }
            config = JSON.parse(decodedConfigParam);
        } catch (e) {
            console.log('[RESOLVER] Failed to parse config from query', e.message);
        }
    }
    const cacheKey = typeof req.query.cacheKey === 'string' ? req.query.cacheKey : null;
    const cacheHash = typeof req.query.cacheHash === 'string' ? req.query.cacheHash : null;
    if (cacheKey && cacheKey.length < 512) {
        config.cacheKey = cacheKey;
    }
    if (cacheHash && cacheHash.length < 128) {
        config.cacheHash = cacheHash;
    }

    // Scope resolver cache/in-flight dedupe by provider + URL + requester token + requester IP.
    // This prevents cross-user token/IP reuse when two users resolve the same source URL.
    const resolverCacheKey = buildResolverScopeKey(debridProvider, debridApiKey, decodedUrl, clientIp);

    try {
        let finalUrl;

        const cachedValue = await getCacheValue(resolverCacheKey);
        if (cachedValue) {
            // Handle case where cachedValue might be an object from UHDMovies resolver
            if (cachedValue && typeof cachedValue === 'object' && cachedValue.url) {
                finalUrl = cachedValue.url;
            } else {
                finalUrl = cachedValue;
            }
            console.log(`[CACHE] Using cached URL for key: ${resolverCacheKey.substring(0, 16)}...`);
        } else if (PENDING_RESOLVES.has(resolverCacheKey)) {
            console.log(`[RESOLVER] Joining in-flight resolve for key: ${resolverCacheKey.substring(0, 16)}...`);
            finalUrl = await PENDING_RESOLVES.get(resolverCacheKey);
            // Handle case where finalUrl might be an object from UHDMovies resolver
            if (finalUrl && typeof finalUrl === 'object' && finalUrl.url) {
                finalUrl = finalUrl.url;
            }
        } else {
            console.log(`[RESOLVER] Cache miss. Resolving URL for ${debridProvider}`);
            const resolvePromise = streamProvider.resolveUrl(debridProvider, debridApiKey, null, decodedUrl, clientIp, config);

            // Set a configurable timeout for performance tuning - increase for NZB downloads
            const isNzb = decodedUrl.startsWith('nzb:');
            const timeoutMs = isNzb ? 600000 : parseInt(process.env.RESOLVE_TIMEOUT || '20000', 10); // 10 min for NZB, 20s otherwise
            const timedResolve = Promise.race([
                resolvePromise,
                new Promise((_, reject) =>
                    setTimeout(() => reject(new Error('Resolve timeout')), timeoutMs)
                )
            ]);

            // MEMORY LEAK FIX: Limit pending requests to prevent unbounded growth
            if (PENDING_RESOLVES.size >= PENDING_RESOLVES_MAX_SIZE) {
                const oldestKey = PENDING_RESOLVES.keys().next().value;
                const oldestPromise = PENDING_RESOLVES.get(oldestKey);
                // Cancel the oldest pending request if possible
                PENDING_RESOLVES.delete(oldestKey);
                console.log(`[RESOLVER] Evicted oldest pending request (size: ${PENDING_RESOLVES.size})`);
            }

            // Track the pending request
            const pendingRequest = timedResolve.catch(err => {
                console.error(`[RESOLVER] Pending resolve failed: ${err.message}`);
                return null;
            }).finally(() => {
                PENDING_RESOLVES.delete(resolverCacheKey);
            });
            PENDING_RESOLVES.set(resolverCacheKey, pendingRequest);

            finalUrl = await pendingRequest;

            if (finalUrl) {
                // Handle case where finalUrl might be an object from UHDMovies resolver that has .url property
                let cacheUrl;
                if (typeof finalUrl === 'object' && finalUrl.url) {
                    cacheUrl = finalUrl.url;
                } else {
                    cacheUrl = finalUrl;
                }

                // MEMORY LEAK FIX: Use new cache function with proper timer tracking
                // Make cache TTL configurable for better performance tuning
                const cacheTtlMs = parseInt(process.env.RESOLVE_CACHE_TTL_MS || '900000', 10); // 15 min default (reduced from 2 hours)
                await setCacheWithTimer(resolverCacheKey, cacheUrl, cacheTtlMs);
            }
        }

        if (finalUrl) {
            // Handle case where finalUrl might be an object (e.g., from UHDMovies resolver)
            let redirectUrl;
            if (finalUrl && typeof finalUrl === 'object' && finalUrl.url) {
                redirectUrl = finalUrl.url;
            } else {
                redirectUrl = finalUrl;
            }

            // Sanitize finalUrl before logging - it may contain API keys or auth tokens
            const sanitizedUrl = obfuscateSensitive(redirectUrl, debridApiKey);
            console.log("[RESOLVER] Redirecting to final stream URL:", sanitizedUrl);
            // Encode URL to handle spaces and special characters, then issue a 302 redirect
            const encodedUrl = encodeUrlForStreaming(redirectUrl);
            res.redirect(302, encodedUrl);
        } else {
            res.status(404).send('Could not resolve link');
        }
    } catch (error) {
        console.error("[RESOLVER] A critical error occurred:", error.message);
        res.status(500).send("Error resolving stream.");
    }
});

// HTTP Streaming resolver endpoint (for 4KHDHub, UHDMovies, etc.)
// This endpoint provides lazy resolution - decrypts URLs only when user selects a stream
app.get('/resolve/httpstreaming/:url', resolveRateLimiter, async (req, res) => {
    const { url } = req.params;
    const decodedUrl = decodeURIComponent(url);
    const isUHDMoviesUrl = decodedUrl.includes('driveleech') ||
        decodedUrl.includes('driveseed') ||
        decodedUrl.includes('tech.unblockedgames.world') ||
        decodedUrl.includes('tech.creativeexpressionsblog.com') ||
        decodedUrl.includes('tech.examzculture.in');
    const isShortlinkResolveUrl = decodedUrl.includes('ouo.io') ||
        decodedUrl.includes('ouo.press') ||
        decodedUrl.includes('oii.la') ||
        decodedUrl.includes('viewcrate.cc') ||
        decodedUrl.includes('filecrypt.cc') ||
        decodedUrl.includes('filecrypt.co');
    const isProviderArchiveResolveUrl = decodedUrl.includes('modpro.blog') ||
        decodedUrl.includes('leechpro.blog') ||
        decodedUrl.includes('episodes.animeflix.') ||
        decodedUrl.includes('/getlink/');

    // Use hash of URL as cache key
    const cacheKeyHash = crypto.createHash('md5').update(decodedUrl).digest('hex');
    const cacheKey = `httpstreaming:${cacheKeyHash}`;

    const looksLikeAsset = (value) => /\.(?:js|css|png|jpe?g|gif|webp|svg|ico|woff2?|ttf|eot|map|json)(?:$|[?#])/i.test(value || '');

    try {
        let finalUrl;

        const cachedValue = await getCacheValue(cacheKey);
        if (cachedValue) {
            // Handle case where cachedValue might be an object from UHDMovies resolver
            if (typeof cachedValue === 'object' && cachedValue.url) {
                finalUrl = cachedValue.url;
            } else {
                finalUrl = cachedValue;
            }
            if (looksLikeAsset(finalUrl)) {
                console.log(`[HTTP-RESOLVER] Cached URL looks like an asset, ignoring cache for key: httpstreaming:${cacheKeyHash.substring(0, 8)}...`);
                finalUrl = null;
            } else {
            console.log(`[CACHE] Using cached URL for key: httpstreaming:${cacheKeyHash.substring(0, 8)}...`);
            }
        } else if (PENDING_RESOLVES.has(cacheKey)) {
            console.log(`[HTTP-RESOLVER] Joining in-flight resolve for key: ${cacheKeyHash.substring(0, 8)}...`);
            finalUrl = await PENDING_RESOLVES.get(cacheKey);
            // Handle case where finalUrl might be an object from UHDMovies resolver
            if (finalUrl && typeof finalUrl === 'object' && finalUrl.url) {
                finalUrl = finalUrl.url;
            }
        } else {
            console.log(`[HTTP-RESOLVER] Resolving HTTP stream URL...`);

            // Determine which resolver to use based on URL pattern
            let resolvePromise;
            if (isUHDMoviesUrl) {
                // UHDMovies SID/driveleech URL
                console.log(`[HTTP-RESOLVER] Detected UHDMovies URL, using UHDMovies resolver`);
                resolvePromise = resolveUHDMoviesUrl(decodedUrl);
            } else if (isShortlinkResolveUrl && (
                decodedUrl.includes('ouo.io') ||
                decodedUrl.includes('ouo.press') ||
                decodedUrl.includes('oii.la')
            )) {
                console.log(`[HTTP-RESOLVER] Detected OUO shortlink, using subprocess resolver`);
                resolvePromise = resolveHttpStreamUrlInSubprocess(decodedUrl);
            } else {
                // 4KHDHub/other HTTP streaming URLs
                console.log(`[HTTP-RESOLVER] Detected 4KHDHub URL, using HTTP stream resolver`);
                resolvePromise = resolveHttpStreamUrl(decodedUrl);
            }

            // Set timeout for HTTP stream resolution
            const baseTimeoutMs = parseInt(process.env.HTTP_RESOLVE_TIMEOUT || '15000', 10);
            const uhdTimeoutMs = parseInt(process.env.UHDMOVIES_RESOLVE_TIMEOUT || '25000', 10);
            const shortlinkTimeoutMs = parseInt(process.env.SHORTLINK_HTTP_RESOLVE_TIMEOUT || '210000', 10);
            const providerArchiveTimeoutMs = parseInt(process.env.PROVIDER_ARCHIVE_HTTP_RESOLVE_TIMEOUT || '30000', 10);
            const timeoutMs = isUHDMoviesUrl
                ? Math.max(baseTimeoutMs, uhdTimeoutMs)
                : ((isShortlinkResolveUrl || isProviderArchiveResolveUrl)
                    ? Math.max(baseTimeoutMs, isProviderArchiveResolveUrl ? providerArchiveTimeoutMs : shortlinkTimeoutMs)
                    : baseTimeoutMs);
            const timedResolve = Promise.race([
                resolvePromise,
                new Promise((_, reject) =>
                    setTimeout(() => reject(new Error('HTTP resolve timeout')), timeoutMs)
                )
            ]);

            // MEMORY LEAK FIX: Limit pending requests to prevent unbounded growth
            if (PENDING_RESOLVES.size >= PENDING_RESOLVES_MAX_SIZE) {
                const oldestKey = PENDING_RESOLVES.keys().next().value;
                const oldestPromise = PENDING_RESOLVES.get(oldestKey);
                // Cancel the oldest pending request if possible
                PENDING_RESOLVES.delete(oldestKey);
                console.log(`[HTTP-RESOLVER] Evicted oldest pending request (size: ${PENDING_RESOLVES.size})`);
            }

            // Track the pending request
            const pendingRequest = timedResolve.catch(err => {
                console.error(`[HTTP-RESOLVER] Pending resolve failed: ${err.message}`);
                return null;
            }).finally(() => {
                PENDING_RESOLVES.delete(cacheKey);
            });
            PENDING_RESOLVES.set(cacheKey, pendingRequest);

            finalUrl = await pendingRequest;

            if (finalUrl) {
                // Handle case where finalUrl might be an object from UHDMovies resolver that has .url property
                let cacheUrl;
                if (finalUrl && typeof finalUrl === 'object' && finalUrl.url) {
                    cacheUrl = finalUrl.url;
                } else {
                    cacheUrl = finalUrl;
                }

                // Use the same TTL as the main resolver for consistency
                const cacheTtlMs = parseInt(process.env.RESOLVE_CACHE_TTL_MS || '900000', 10); // 15 min default
                await setCacheWithTimer(cacheKey, cacheUrl, cacheTtlMs);
            }
        }

        if (finalUrl) {
            // Handle case where finalUrl might be an object (e.g., from UHDMovies resolver)
            let redirectUrl;
            if (typeof finalUrl === 'object' && finalUrl.url) {
                redirectUrl = finalUrl.url;
            } else {
                redirectUrl = finalUrl;
            }

            // Encode URL to handle spaces and special characters in filenames
            const encodedUrl = encodeUrlForStreaming(redirectUrl);
            console.log("[HTTP-RESOLVER] Redirecting to final stream URL:",
                typeof encodedUrl === 'string' ? encodedUrl.substring(0, 100) + '...' : encodedUrl);
            res.redirect(302, encodedUrl);
        } else {
            res.status(404).send('Could not resolve HTTP stream link');
        }
    } catch (error) {
        console.error("[HTTP-RESOLVER] Error occurred:", error.message);
        res.status(500).send("Error resolving HTTP stream.");
    }
});

// Middleware to check admin token
function checkAdminAuth(req, res, next) {
    const adminToken = process.env.ADMIN_TOKEN;
    if (!adminToken) {
        return res.status(503).json({
            success: false,
            message: 'Admin endpoints disabled. Set ADMIN_TOKEN environment variable to enable.'
        });
    }

    const providedToken = req.headers['authorization']?.replace('Bearer ', '') || req.query.token;
    if (providedToken !== adminToken) {
        return res.status(401).json({
            success: false,
            message: 'Unauthorized. Invalid or missing admin token.'
        });
    }

    next();
}



// Endpoint to verify MediaFlow proxy connectivity
app.get('/verify-proxy', async (req, res) => {
    const { url, password } = req.query;

    if (!url) {
        return res.json({ success: false, error: 'Proxy URL is required' });
    }

    try {
        // Normalize URL - remove trailing slash
        const baseUrl = url.replace(/\/+$/, '');
        const verifyUrl = `${baseUrl}/proxy/ip` + (password ? `?api_password=${encodeURIComponent(password)}` : '');

        const response = await fetch(verifyUrl, {
            method: 'GET',
            timeout: 10000,
            headers: {
                'Accept': 'application/json'
            }
        });

        if (!response.ok) {
            return res.json({
                success: false,
                error: `Proxy returned status ${response.status}: ${response.statusText}`
            });
        }

        const data = await response.json().catch(() => ({}));
        res.json({ success: true, ip: data.ip || data.origin || 'verified' });
    } catch (error) {
        console.error('[PROXY-VERIFY] Error verifying proxy:', error.message);
        res.json({
            success: false,
            error: error.message || 'Failed to connect to proxy'
        });
    }
});

// Endpoint to clear SQLite search cache (stream results)
app.get('/admin/clear-search-cache', checkAdminAuth, async (req, res) => {
    const result = await sqliteCache.clearSearchCache();
    res.json(result);
});

// Endpoint to clear SQLite torrent hash cache (optionally for specific service)
app.get('/admin/clear-torrent-cache', checkAdminAuth, async (req, res) => {
    const service = req.query.service; // Optional: ?service=realdebrid or ?service=alldebrid
    const result = await sqliteCache.clearTorrentCache(service);
    res.json(result);
});

// Endpoint to clear ALL SQLite cache (search results + torrent metadata)
app.get('/admin/clear-all-cache', checkAdminAuth, async (req, res) => {
    const result = await sqliteCache.clearAllCache();

    res.json(result);
});

// Endpoint to clear all scraper penalties and reset consecutive failure counters
// Useful when a proxy/network outage caused mass penalization of otherwise-healthy scrapers
app.get('/admin/clear-scraper-penalties', checkAdminAuth, (req, res) => {
    const tracker = scraperPerformance.default;
    tracker.clearAllPenalties();
    res.json({ success: true, message: 'All scraper penalties cleared and counters reset' });
});



// Endpoint to view active Usenet streams
app.get('/admin/usenet-streams', checkAdminAuth, (req, res) => {
    const streams = [];
    const now = Date.now();

    for (const [streamKey, streamInfo] of ACTIVE_USENET_STREAMS.entries()) {
        const inactiveTime = Math.round((now - streamInfo.lastAccess) / 1000 / 60); // minutes
        streams.push({
            streamKey,
            isPersonal: streamInfo.isPersonal || false,
            activeConnections: streamInfo.activeConnections || 0,
            completionPercentage: streamInfo.completionPercentage || 0,
            totalRequests: streamInfo.streamCount,
            lastAccessMinutesAgo: inactiveTime,
            willCleanupIn: Math.max(0, Math.round((STREAM_INACTIVE_TIMEOUT - (now - streamInfo.lastAccess)) / 1000 / 60)),
            deleteOnStop: streamInfo.usenetConfig?.deleteOnStreamStop || false
        });
    }

    res.json({
        success: true,
        activeStreams: streams.length,
        streams: streams,
        cleanupInterval: `${STREAM_CLEANUP_INTERVAL / 1000 / 60} minutes`,
        inactiveTimeout: `${STREAM_INACTIVE_TIMEOUT / 1000 / 60} minutes`
    });
});

// Endpoint to manually trigger stream cleanup
app.post('/admin/cleanup-streams', checkAdminAuth, async (req, res) => {
    try {
        await cleanupInactiveStreams();
        res.json({
            success: true,
            message: 'Stream cleanup completed'
        });
    } catch (error) {
        res.status(500).json({
            success: false,
            message: error.message
        });
    }
});

/**
 * Delete file from file server
 */
async function deleteFileFromServer(fileServerUrl, filePath) {
    try {
        const axios = (await import('axios')).default;
        const url = `${fileServerUrl.replace(/\/$/, '')}/${filePath}`;
        await axios.delete(url, { timeout: 10000 });
        console.log(`[USENET-CLEANUP] Deleted file from server: ${filePath}`);
        return true;
    } catch (error) {
        console.error(`[USENET-CLEANUP] Failed to delete file from server: ${error.message}`);
        return false;
    }
}

/**
 * Cleanup inactive Usenet streams
 * Removes downloads from SABnzbd if no stream has accessed them recently
 * Also deletes files from file server if deleteOnStreamStop is enabled
 */
async function cleanupInactiveStreams() {
    const now = Date.now();
    console.log('[USENET-CLEANUP] Checking for inactive streams...');

    for (const [streamKey, streamInfo] of ACTIVE_USENET_STREAMS.entries()) {
        const inactiveTime = now - streamInfo.lastAccess;

        if (inactiveTime > STREAM_INACTIVE_TIMEOUT) {
            const inactiveMinutes = Math.round(inactiveTime / 1000 / 60);
            console.log(`[USENET-CLEANUP] Stream inactive for ${inactiveMinutes} minutes: ${streamKey}`);

            // Check if we should delete the file from the file server
            const shouldDeleteFile = streamInfo.usenetConfig?.deleteOnStreamStop;

            // Handle personal files differently (they don't have NZO IDs)
            if (streamInfo.isPersonal) {
                console.log(`[USENET-CLEANUP] Personal file stream inactive: ${streamKey}`);

                if (shouldDeleteFile && streamInfo.videoFilePath && streamInfo.usenetConfig?.fileServerUrl) {
                    console.log(`[USENET-CLEANUP] deleteOnStreamStop enabled, deleting personal file from server`);
                    await deleteFileFromServer(streamInfo.usenetConfig.fileServerUrl, streamInfo.videoFilePath);
                }

                ACTIVE_USENET_STREAMS.delete(streamKey);
                continue;
            }

            // Handle regular Usenet downloads (with NZO IDs)
            const nzoId = streamKey;
            const status = await SABnzbd.getDownloadStatus(
                streamInfo.config.sabnzbdUrl,
                streamInfo.config.sabnzbdApiKey,
                nzoId
            );

            // User stopped watching - delete the download if incomplete
            if (status.status === 'downloading' || status.status === 'Downloading' || status.status === 'Paused') {
                console.log(`[USENET-CLEANUP] User stopped streaming incomplete download: ${nzoId} (${status.percentComplete?.toFixed(1)}%)`);

                // Only delete if deleteOnStreamStop is enabled
                if (shouldDeleteFile) {
                    console.log(`[USENET-CLEANUP] deleteOnStreamStop enabled, deleting incomplete download and files`);

                    // Delete download from SABnzbd
                    const deleted = await SABnzbd.deleteItem(
                        streamInfo.config.sabnzbdUrl,
                        streamInfo.config.sabnzbdApiKey,
                        nzoId,
                        true // Delete files
                    );

                    if (deleted) {
                        console.log(`[USENET-CLEANUP] ✓ Deleted incomplete download and files: ${nzoId}`);
                    }

                    // Also delete from file server if configured
                    if (streamInfo.videoFilePath && streamInfo.usenetConfig?.fileServerUrl) {
                        console.log(`[USENET-CLEANUP] Deleting incomplete file from file server: ${streamInfo.videoFilePath}`);
                        await deleteFileFromServer(streamInfo.usenetConfig.fileServerUrl, streamInfo.videoFilePath);
                    }
                } else {
                    console.log(`[USENET-CLEANUP] deleteOnStreamStop disabled, keeping incomplete download`);
                }

                ACTIVE_USENET_STREAMS.delete(nzoId);
            } else if (status.status === 'completed') {
                console.log(`[USENET-CLEANUP] Download completed: ${nzoId}`);
                // DO NOT delete completed files - they become "personal" files for instant playback
                // They will be cleaned up by autoCleanOldFiles after the configured age (default 7 days)
                console.log(`[USENET-CLEANUP] Keeping completed file (will auto-clean after ${streamInfo.usenetConfig?.autoCleanAgeDays || 7} days if enabled)`);

                // Remove from tracking
                ACTIVE_USENET_STREAMS.delete(nzoId);
            } else {
                // Not found or failed, remove from tracking
                ACTIVE_USENET_STREAMS.delete(nzoId);
            }
        }
    }
}

// Schedule cleanup every 15 minutes
const cleanupIntervalId = setInterval(() => {
    cleanupInactiveStreams().catch(err => {
        console.error('[USENET-CLEANUP] Error during cleanup:', err.message);
    });
}, STREAM_CLEANUP_INTERVAL);

/**
 * Auto-clean old files from file server based on age
 * Uses globally stored configs, works even without active streams
 */
async function autoCleanOldFiles() {
    console.log('[USENET-AUTO-CLEAN] Checking for old files to clean...');

    // Also check active streams for any additional configs
    for (const [streamKey, streamInfo] of ACTIVE_USENET_STREAMS.entries()) {
        const config = streamInfo.usenetConfig;
        if (config?.fileServerUrl && config?.autoCleanOldFiles) {
            USENET_CONFIGS.set(config.fileServerUrl, config);
        }
    }

    if (USENET_CONFIGS.size === 0) {
        console.log('[USENET-AUTO-CLEAN] No Usenet configs with auto-clean enabled');
        return;
    }

    console.log(`[USENET-AUTO-CLEAN] Found ${USENET_CONFIGS.size} file server(s) with auto-clean enabled`);

    for (const [fileServerUrl, config] of USENET_CONFIGS.entries()) {
        try {
            const ageDays = config.autoCleanAgeDays || 7;
            const ageThresholdMs = ageDays * 24 * 60 * 60 * 1000;
            const now = Date.now();

            console.log(`[USENET-AUTO-CLEAN] Checking files on ${fileServerUrl} (age threshold: ${ageDays} days)`);

            // Get list of files from file server
            const axios = (await import('axios')).default;
            const headers = {};
            // Use fileServerPassword from config if available, otherwise use env variable
            const apiKey = config?.fileServerPassword || process.env.USENET_FILE_SERVER_API_KEY;
            if (apiKey) {
                headers['X-API-Key'] = apiKey;
            }
            const response = await axios.get(`${fileServerUrl.replace(/\/$/, '')}/api/list`, {
                timeout: 10000,
                headers: headers
            });

            if (!response.data?.files) {
                console.log(`[USENET-AUTO-CLEAN] No files found on ${fileServerUrl}`);
                continue;
            }

            const files = response.data.files;
            let deletedCount = 0;

            for (const file of files) {
                // Only delete COMPLETED files (not incomplete/in-progress downloads)
                if (!file.isComplete) {
                    continue; // Skip incomplete files
                }

                const fileAgeMs = now - (file.modified * 1000); // Convert to milliseconds

                if (fileAgeMs > ageThresholdMs) {
                    const ageDaysActual = Math.round(fileAgeMs / (24 * 60 * 60 * 1000));
                    console.log(`[USENET-AUTO-CLEAN] Completed file is ${ageDaysActual} days old, deleting: ${file.path}`);

                    const deleted = await deleteFileFromServer(fileServerUrl, file.path);
                    if (deleted) {
                        deletedCount++;
                    }
                }
            }

            if (deletedCount > 0) {
                console.log(`[USENET-AUTO-CLEAN] Deleted ${deletedCount} old files from ${fileServerUrl}`);
            } else {
                console.log(`[USENET-AUTO-CLEAN] No old files to delete from ${fileServerUrl}`);
            }

        } catch (error) {
            console.error(`[USENET-AUTO-CLEAN] Error cleaning files from ${fileServerUrl}:`, error.message);
        }
    }
}

// Schedule auto-clean every hour
const AUTO_CLEAN_INTERVAL = 60 * 60 * 1000; // 1 hour
const autoCleanIntervalId = setInterval(() => {
    autoCleanOldFiles().catch(err => {
        console.error('[USENET-AUTO-CLEAN] Error during auto-clean:', err.message);
    });
}, AUTO_CLEAN_INTERVAL);

// Run auto-clean on startup after 5 minutes
const autoCleanTimeoutId = setTimeout(() => {
    autoCleanOldFiles().catch(err => {
        console.error('[USENET-AUTO-CLEAN] Error during startup auto-clean:', err.message);
    });
}, 5 * 60 * 1000);

/**
 * Monitor active streams and manage SABnzbd pause/resume
 * - Resume downloads when playback is getting close to download position
 * - Resume downloads when user stops streaming
 */
async function monitorStreamDownloads() {
    const totalStreams = ACTIVE_USENET_STREAMS.size;
    const nonPersonalStreams = Array.from(ACTIVE_USENET_STREAMS.values()).filter(s => !s.isPersonal).length;

    if (totalStreams === 0) {
        console.log('[USENET-MONITOR] No active streams to monitor');
        return;
    }

    console.log(`[USENET-MONITOR] Checking ${nonPersonalStreams} stream(s) (${totalStreams} total, ${totalStreams - nonPersonalStreams} personal)...`);

    for (const [nzoId, streamInfo] of ACTIVE_USENET_STREAMS.entries()) {
        // Skip personal files (no download to monitor)
        if (streamInfo.isPersonal) {
            continue;
        }

        try {
            // Get current download status
            const status = await SABnzbd.getDownloadStatus(
                streamInfo.config.sabnzbdUrl,
                streamInfo.config.sabnzbdApiKey,
                nzoId
            );

            // Skip if not paused or not downloading
            if (status.status !== 'Paused' && status.status !== 'downloading') {
                console.log(`[USENET-MONITOR] Skipping ${nzoId}: status is "${status.status}" (not Paused/downloading)`);
                continue;
            }

            // Calculate playback percentage
            const playbackPercent = streamInfo.fileSize > 0
                ? (streamInfo.lastPlaybackPosition / streamInfo.fileSize) * 100
                : 0;

            const downloadPercent = status.percentComplete || streamInfo.lastDownloadPercent;

            console.log(`[USENET-MONITOR] ${nzoId}: Playback ${playbackPercent.toFixed(1)}% | Download ${downloadPercent.toFixed(1)}%`);

            // Resume if paused and playback is within 15% of download position
            const bufferPercent = 15;
            if (streamInfo.paused && playbackPercent > downloadPercent - bufferPercent) {
                console.log(`[USENET-MONITOR] ⚠️ Playback catching up to download! Resuming to maintain buffer...`);
                await SABnzbd.resumeDownload(
                    streamInfo.config.sabnzbdUrl,
                    streamInfo.config.sabnzbdApiKey,
                    nzoId
                );
                streamInfo.paused = false;
            }

            // Update last known download percent
            streamInfo.lastDownloadPercent = downloadPercent;

        } catch (error) {
            console.error(`[USENET-MONITOR] Error monitoring ${nzoId}:`, error.message);
        }
    }
}

// Schedule monitoring every 30 seconds
const STREAM_MONITOR_INTERVAL = 30 * 1000; // 30 seconds
const monitorIntervalId = setInterval(() => {
    monitorStreamDownloads().catch(err => {
        console.error('[USENET-MONITOR] Error during monitoring:', err.message);
    });
}, STREAM_MONITOR_INTERVAL);

/**
 * Check for orphaned paused downloads on startup
 * Resume any paused downloads that aren't actively being streamed
 * This handles server restarts while downloads were paused
 */
async function checkOrphanedPausedDownloads() {
    console.log('[USENET-STARTUP] Checking for orphaned paused downloads...');

    // Get all active configs from environment or stored configs
    const configsToCheck = new Set();

    // Add any configs from USENET_CONFIGS
    for (const config of USENET_CONFIGS.values()) {
        if (config.sabnzbdUrl && config.sabnzbdApiKey) {
            configsToCheck.add(JSON.stringify({
                url: config.sabnzbdUrl,
                key: config.sabnzbdApiKey
            }));
        }
    }

    if (configsToCheck.size === 0) {
        console.log('[USENET-STARTUP] No SABnzbd configs to check');
        return;
    }

    for (const configStr of configsToCheck) {
        const config = JSON.parse(configStr);

        try {
            // Get SABnzbd queue
            const queue = await SABnzbd.getQueue(config.url, config.key);

            if (!queue?.slots || queue.slots.length === 0) {
                continue;
            }

            // Check each download
            for (const slot of queue.slots) {
                if (slot.status === 'Paused') {
                    const nzoId = slot.nzo_id;

                    // Check if this download is being actively streamed
                    const isActiveStream = ACTIVE_USENET_STREAMS.has(nzoId);

                    if (!isActiveStream) {
                        console.log(`[USENET-STARTUP] Found orphaned paused download: ${slot.filename} (${nzoId})`);
                        console.log(`[USENET-STARTUP] Resuming orphaned download...`);

                        await SABnzbd.resumeDownload(config.url, config.key, nzoId);
                    } else {
                        console.log(`[USENET-STARTUP] Paused download is actively streaming, keeping paused: ${slot.filename}`);
                    }
                }
            }
        } catch (error) {
            console.error(`[USENET-STARTUP] Error checking SABnzbd queue:`, error.message);
        }
    }
}

// Run orphaned download check on startup after 10 seconds
setTimeout(() => {
    checkOrphanedPausedDownloads().catch(err => {
        console.error('[USENET-STARTUP] Error checking orphaned downloads:', err.message);
    });
}, 10 * 1000);

// Helper function to find video file in directory (including incomplete)
// Find video file via file server API (uses rar2fs mounted directory)
async function findVideoFileViaAPI(fileServerUrl, releaseName, options = {}, fileServerPassword = null) {
    try {
        const axios = (await import('axios')).default;
        console.log(`[USENET] Querying file server for release: ${releaseName}`);

        const headers = {};
        const apiKey = fileServerPassword || process.env.USENET_FILE_SERVER_API_KEY;
        if (apiKey) {
            headers['X-API-Key'] = apiKey;
        }
        const response = await axios.get(`${fileServerUrl.replace(/\/$/, '')}/api/list`, {
            timeout: 5000,
            validateStatus: (status) => status === 200,
            headers: headers
        });

        if (!response.data?.files || !Array.isArray(response.data.files)) {
            console.log('[USENET] No files returned from file server');
            return null;
        }

        console.log(`[USENET] File server returned ${response.data.files.length} total video files`);

        // Filter files that match the release name (normalize the folder path)
        const normalizedRelease = releaseName.toLowerCase();
        let matchingFiles = response.data.files.filter(file => {
            if (!file || !file.path) {
                console.log(`[USENET] Warning: Invalid file entry in response`);
                return false;
            }
            const filePath = file.path.toLowerCase();
            const fileName = file.name ? file.name.toLowerCase() : '';

            // Match if path contains release name OR filename contains release name
            // This helps find files in nested subdirectories
            const pathMatch = filePath.includes(normalizedRelease);
            const nameMatch = fileName.includes(normalizedRelease);

            return pathMatch || nameMatch;
        });

        console.log(`[USENET] Found ${matchingFiles.length} files matching release "${releaseName}"`);

        // Debug: show paths of all matching files
        if (matchingFiles.length > 0) {
            console.log(`[USENET] Matching file paths:`, matchingFiles.slice(0, 5).map(f => f.path));
            console.log(`[USENET] First match:`, JSON.stringify(matchingFiles[0]));
        } else {
            // Show what we got from API to debug why nothing matched
            console.log(`[USENET] No matches found. Sample of files from API (first 3):`);
            response.data.files.slice(0, 3).forEach(f => {
                console.log(`  - Path: "${f.path}" | Name: "${f.name}"`);
            });
            console.log(`[USENET] Looking for release: "${normalizedRelease}"`);
        }

        if (matchingFiles.length === 0) {
            return null;
        }

        // Exclude sample files, extras, and featurettes
        matchingFiles = matchingFiles.filter(f => {
            if (!f || !f.name) return false;
            const nameLower = f.name.toLowerCase();
            const pathLower = f.path ? f.path.toLowerCase() : '';

            // Exclude common non-main-feature files
            const excludeKeywords = ['sample', 'extra', 'featurette', 'deleted', 'trailer', 'bonus'];
            const shouldExclude = excludeKeywords.some(keyword =>
                nameLower.includes(keyword) || pathLower.includes(keyword)
            );

            if (shouldExclude) {
                console.log(`[USENET] Excluding: ${f.name} (contains ${excludeKeywords.find(k => nameLower.includes(k) || pathLower.includes(k))})`);
            }

            return !shouldExclude;
        });

        if (matchingFiles.length === 0) {
            console.log(`[USENET] No files left after filtering non-main-feature files`);
            return null;
        }

        console.log(`[USENET] ${matchingFiles.length} files after filtering (showing sizes):`);
        matchingFiles.slice(0, 5).forEach(f => {
            console.log(`  - ${f.name}: ${(f.size / 1024 / 1024 / 1024).toFixed(2)} GB`);
        });

        // For series, try to match season/episode
        if (options.season && options.episode) {
            const PTT = (await import('./lib/util/parse-torrent-title.js')).default;
            const matchedFile = matchingFiles.find(file => {
                const parsed = PTT.parse(file.name);
                return parsed.season === Number(options.season) && parsed.episode === Number(options.episode);
            });
            if (matchedFile) {
                console.log(`[USENET] Matched S${options.season}E${options.episode}: ${matchedFile.name}`);
                return {
                    name: matchedFile.name,
                    path: matchedFile.path, // Use full path with folder
                    size: matchedFile.size
                };
            }
        }

        // Return largest file
        matchingFiles.sort((a, b) => (b.size || 0) - (a.size || 0));
        const largestFile = matchingFiles[0];

        if (!largestFile || !largestFile.name) {
            console.log(`[USENET] Error: largest file is invalid`);
            return null;
        }

        console.log(`[USENET] Selected largest file: ${largestFile.name} (${(largestFile.size / 1024 / 1024 / 1024).toFixed(2)} GB`);

        // Use full path with folder so rar2fs can find the extracted file
        return {
            name: largestFile.name,
            path: largestFile.path, // Use full path, not flatPath
            size: largestFile.size
        };

    } catch (error) {
        console.error('[USENET] Error querying file server:', error.message);
        return null;
    }
}

async function findVideoFile(baseDir, fileName, options = {}) {
    const videoExtensions = ['.mp4', '.mkv', '.avi', '.mov', '.wmv', '.flv', '.webm', '.m4v', '.mpg', '.mpeg'];

    try {
        if (!fs.existsSync(baseDir)) {
            return null;
        }

        // Check if baseDir is directly a file
        const stat = fs.statSync(baseDir);
        if (stat.isFile()) {
            const ext = path.extname(baseDir).toLowerCase();
            if (videoExtensions.includes(ext)) {
                return baseDir;
            }
        }

        // Search in directory recursively
        const files = fs.readdirSync(baseDir, { withFileTypes: true, recursive: true });

        // Filter video files and exclude samples
        // Note: with recursive: true, dirent.name contains the relative path from baseDir
        let videoFiles = files
            .filter(f => f.isFile())
            .map(f => {
                // f.path is the parent directory, f.name is the filename (or relative path with recursive)
                // Join them correctly to get the full path
                const fullPath = path.join(f.path || baseDir, f.name);
                return fullPath;
            })
            .filter(p => videoExtensions.includes(path.extname(p).toLowerCase()))
            .filter(p => !path.basename(p).toLowerCase().includes('sample')); // Exclude sample files

        console.log(`[USENET] Found ${videoFiles.length} video files in ${baseDir}`);
        if (videoFiles.length > 0) {
            console.log('[USENET] Video files:', videoFiles.map(f => path.basename(f)).join(', '));
        }

        if (videoFiles.length === 0) {
            return null;
        }

        // For series, try to match season/episode
        if (options.season && options.episode) {
            const PTT = (await import('./lib/util/parse-torrent-title.js')).default;
            const matchedFile = videoFiles.find(file => {
                const parsed = PTT.parse(path.basename(file));
                return parsed.season === Number(options.season) && parsed.episode === Number(options.episode);
            });
            if (matchedFile) return matchedFile;
        }

        // Return largest file
        const filesWithSize = videoFiles.map(f => ({ path: f, size: fs.statSync(f).size }));
        filesWithSize.sort((a, b) => b.size - a.size);
        return filesWithSize[0]?.path || null;

    } catch (error) {
        console.error('[USENET] Error finding video file:', error.message);
        return null;
    }
}

// Usenet video readiness polling endpoint
app.get('/usenet/poll/:nzbUrl/:title/:type/:id', async (req, res) => {
    const { nzbUrl, title, type, id } = req.params;

    try {
        const configJson = req.query.config;
        if (!configJson) {
            return res.status(400).json({ ready: false, error: 'Missing configuration' });
        }

        // Safe parsing with memory and size limits
        const decodedConfigJson = decodeURIComponent(configJson);
        // Check size before parsing to prevent memory issues
        if (decodedConfigJson.length > 100000) { // 100KB limit
            return res.status(400).json({ ready: false, error: 'Config parameter too large' });
        }
        const config = JSON.parse(decodedConfigJson);

        if (!config.newznabUrl || !config.newznabApiKey || !config.sabnzbdUrl || !config.sabnzbdApiKey) {
            return res.status(400).json({ ready: false, error: 'Usenet not configured' });
        }

        const decodedNzbUrl = decodeURIComponent(nzbUrl);
        const decodedTitle = decodeURIComponent(title);

        // Check if already downloading
        let nzoId = null;
        for (const [downloadId, info] of Usenet.activeDownloads.entries()) {
            if (info.name === decodedTitle) {
                nzoId = downloadId;
                break;
            }
        }

        if (!nzoId) {
            return res.json({ ready: false, progress: 0, message: 'Download not started' });
        }

        // Get current status
        const status = await SABnzbd.getDownloadStatus(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);

        if (status.status === 'error' || status.status === 'failed') {
            return res.json({ ready: false, error: status.error || status.failMessage || 'Download failed' });
        }

        // Try to find video file
        let videoFilePath = null;
        const sabnzbdConfig = await SABnzbd.getConfig(config.sabnzbdUrl, config.sabnzbdApiKey);
        let searchPath = null;

        if (status.status === 'downloading' && sabnzbdConfig?.incompleteDir) {
            searchPath = path.join(sabnzbdConfig.incompleteDir, decodedTitle);
        } else if (status.status === 'completed' && status.path) {
            searchPath = status.path;
        } else if (status.incompletePath) {
            searchPath = status.incompletePath;
        }

        if (searchPath && fs.existsSync(searchPath)) {
            videoFilePath = await findVideoFile(
                searchPath,
                decodedTitle,
                type === 'series' ? { season: id.split(':')[1], episode: id.split(':')[2] } : {}
            );
        }

        // Return status
        if (videoFilePath && fs.existsSync(videoFilePath)) {
            return res.json({
                ready: true,
                progress: status.percentComplete || 0,
                status: status.status,
                message: 'Video file ready for streaming'
            });
        } else {
            return res.json({
                ready: false,
                progress: status.percentComplete || 0,
                status: status.status,
                message: `Extracting files... ${status.percentComplete?.toFixed(1) || 0}% downloaded`
            });
        }

    } catch (error) {
        console.error('[USENET] Polling error:', error.message);
        return res.json({ ready: false, error: error.message });
    }
});

// Personal file streaming endpoint (files already on server)
// PROXY through Node.js to track when stream stops
app.get('/usenet/personal/*', async (req, res) => {
    try {
        const configJson = req.query.config;
        if (!configJson) {
            return res.status(400).send('Missing configuration');
        }

        // Safe parsing with memory and size limits
        const decodedConfigJson = decodeURIComponent(configJson);
        // Check size before parsing to prevent memory issues
        if (decodedConfigJson.length > 100000) { // 100KB limit
            return res.status(400).send('Config parameter too large');
        }
        const config = JSON.parse(decodedConfigJson);

        // Extract the file path from the URL (everything after /usenet/personal/)
        const filePath = req.params[0];
        const decodedFilePath = decodeURIComponent(filePath);

        console.log(`[USENET-PERSONAL] Stream request for personal file: ${decodedFilePath}`);

        // Track this access for cleanup purposes
        const fileKey = `personal:${decodedFilePath}`;
        if (!ACTIVE_USENET_STREAMS.has(fileKey)) {
            ACTIVE_USENET_STREAMS.set(fileKey, {
                lastAccess: Date.now(),
                streamCount: 1,
                activeConnections: 0,
                maxBytePosition: 0,
                fileSize: 0,
                completionPercentage: 0,
                config: {
                    sabnzbdUrl: config.sabnzbdUrl,
                    sabnzbdApiKey: config.sabnzbdApiKey
                },
                videoFilePath: decodedFilePath,
                usenetConfig: config,
                isPersonal: true
            });
            console.log(`[USENET-PERSONAL] Tracking new personal stream: ${fileKey}`);
        }

        const streamInfo = ACTIVE_USENET_STREAMS.get(fileKey);
        streamInfo.lastAccess = Date.now();
        streamInfo.activeConnections++;

        // Store config globally for auto-clean (even when no active streams)
        if (config.fileServerUrl && config.autoCleanOldFiles) {
            USENET_CONFIGS.set(config.fileServerUrl, config);
            console.log(`[USENET-PERSONAL] Stored config for auto-clean: ${config.fileServerUrl}`);
        }

        // Track range requests to calculate completion
        if (req.headers.range) {
            const rangeMatch = req.headers.range.match(/bytes=(\d+)-(\d*)/);
            if (rangeMatch) {
                const startByte = parseInt(rangeMatch[1]);
                if (startByte > streamInfo.maxBytePosition) {
                    streamInfo.maxBytePosition = startByte;
                }
            }
        }

        // Track connection close to detect when stream stops
        req.on('close', () => {
            streamInfo.activeConnections--;
            console.log(`[USENET-PERSONAL] Connection closed for ${fileKey}, active connections: ${streamInfo.activeConnections}, completion: ${streamInfo.completionPercentage}%`);

            // If no more active connections and deleteOnStreamStop is enabled
            if (streamInfo.activeConnections === 0 && streamInfo.usenetConfig?.deleteOnStreamStop) {
                // Only delete if user watched at least 90% of the file (they finished it)
                const completionThreshold = 90;

                if (streamInfo.completionPercentage >= completionThreshold) {
                    console.log(`[USENET-PERSONAL] Stream finished (${streamInfo.completionPercentage}% watched), scheduling delete for: ${fileKey}`);
                    // Wait 30 seconds before deleting (in case user is seeking or reloading)
                    setTimeout(async () => {
                        if (streamInfo.activeConnections === 0) {
                            console.log(`[USENET-PERSONAL] Deleting finished file: ${decodedFilePath}`);
                            await deleteFileFromServer(streamInfo.usenetConfig.fileServerUrl, decodedFilePath);
                            ACTIVE_USENET_STREAMS.delete(fileKey);
                        }
                    }, 30000);
                } else {
                    console.log(`[USENET-PERSONAL] Stream stopped but not finished (${streamInfo.completionPercentage}% < ${completionThreshold}%), keeping file`);
                    // Don't delete, but clean up tracking after 1 hour if no reconnection
                    setTimeout(() => {
                        if (streamInfo.activeConnections === 0) {
                            console.log(`[USENET-PERSONAL] Removing tracking for unfinished stream: ${fileKey}`);
                            ACTIVE_USENET_STREAMS.delete(fileKey);
                        }
                    }, 60 * 60 * 1000); // 1 hour
                }
            }
        });

        // PROXY the request to file server (don't redirect)
        const fileServerUrl = config.fileServerUrl.replace(/\/$/, '');
        const proxyUrl = `${fileServerUrl}/${filePath}`;

        console.log(`[USENET-PERSONAL] Proxying to file server: ${proxyUrl}`);

        // Forward the request to file server with range headers
        const axios = (await import('axios')).default;
        const headers = {};
        if (req.headers.range) {
            headers['Range'] = req.headers.range;
        }

        // Add API key for file server authentication
        const apiKey = config.fileServerPassword || process.env.USENET_FILE_SERVER_API_KEY;
        if (apiKey) {
            headers['X-API-Key'] = apiKey;
        }

        const response = await axios.get(proxyUrl, {
            headers,
            responseType: 'stream',
            validateStatus: (status) => status < 500
        });

        // Forward response headers
        res.status(response.status);
        Object.keys(response.headers).forEach(key => {
            res.setHeader(key, response.headers[key]);
        });

        // Extract file size from Content-Range or Content-Length
        if (response.headers['content-range']) {
            const rangeMatch = response.headers['content-range'].match(/bytes \d+-\d+\/(\d+)/);
            if (rangeMatch) {
                streamInfo.fileSize = parseInt(rangeMatch[1]);
            }
        } else if (response.headers['content-length']) {
            streamInfo.fileSize = parseInt(response.headers['content-length']);
        }

        // Calculate completion percentage
        if (streamInfo.fileSize > 0) {
            streamInfo.completionPercentage = Math.round((streamInfo.maxBytePosition / streamInfo.fileSize) * 100);
        }

        // Pipe the response
        response.data.pipe(res);

    } catch (error) {
        console.error('[USENET-PERSONAL] Error:', error.message);
        if (!res.headersSent) {
            return res.status(500).send('Error streaming personal file');
        }
    }
});

// Universal Usenet streaming endpoint - dynamically resolves file location
// This endpoint queries the file server API to find the current file path
// Works even when files move from incomplete/ to personal/ during completion
// Enables immediate streaming without waiting for 5% download threshold
app.get('/usenet/universal/:releaseName/:type/:id', async (req, res) => {
    const { releaseName, type, id } = req.params;
    let axiosResponse = null; // Track response for cleanup

    try {
        const configJson = req.query.config;
        if (!configJson) {
            return res.status(400).send('Missing configuration');
        }

        const decodedConfigJson = decodeURIComponent(configJson);
        if (decodedConfigJson.length > 100000) {
            return res.status(400).send('Config parameter too large');
        }
        const config = JSON.parse(decodedConfigJson);

        if (!config.fileServerUrl) {
            return res.status(400).send('File server not configured');
        }

        const decodedReleaseName = decodeURIComponent(releaseName);
        const nzoId = req.query.nzoId ? decodeURIComponent(req.query.nzoId) : null;
        console.log(`[USENET-UNIVERSAL] Stream request for: ${decodedReleaseName}${nzoId ? ` (nzoId: ${nzoId})` : ''}`);

        // Query file server API to find current file location
        // Poll for up to 2 minutes to allow time for extraction/download to start
        const { findVideoFileViaAPI } = await import('./server/usenet/video-finder.js');
        const SABnzbd = (await import('./lib/sabnzbd.js')).default;

        const maxWaitTime = 120000; // 2 minutes
        const pollInterval = 1000; // Check every 1 second
        const startTime = Date.now();
        let fileInfo = null;
        let attempt = 0;
        let lastProgress = -1;
        let lastDownloadStatus = null;

        while (!fileInfo && (Date.now() - startTime) < maxWaitTime) {
            attempt++;

            // Check SABnzbd download status if nzoId is available
            let downloadStatus = null;
            if (nzoId && config.sabnzbdUrl && config.sabnzbdApiKey) {
                try {
                    downloadStatus = await SABnzbd.getDownloadStatus(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);
                    lastDownloadStatus = downloadStatus;

                    // Log progress changes
                    const currentProgress = downloadStatus.percentComplete || 0;
                    if (currentProgress !== lastProgress && currentProgress > 0) {
                        console.log(`[USENET-UNIVERSAL] SABnzbd download progress: ${currentProgress.toFixed(1)}% (status: ${downloadStatus.status})`);
                        lastProgress = currentProgress;
                    }

                    // Check for errors
                    if (downloadStatus.status === 'error' || downloadStatus.status === 'failed') {
                        const errorMsg = downloadStatus.error || downloadStatus.failMessage || 'Unknown error';
                        console.log(`[USENET-UNIVERSAL] Download failed: ${errorMsg}`);
                        return res.status(500).send(`Download failed: ${errorMsg}`);
                    }
                } catch (error) {
                    console.log(`[USENET-UNIVERSAL] Could not check SABnzbd status: ${error.message}`);
                }
            }

            fileInfo = await findVideoFileViaAPI(
                config.fileServerUrl,
                decodedReleaseName,
                type === 'series' ? { season: id.split(':')[1], episode: id.split(':')[2] } : {},
                config.fileServerPassword
            );

            if (fileInfo) {
                console.log(`[USENET-UNIVERSAL] ✓ Found video file on attempt ${attempt}`);
                break;
            }

            if (attempt === 1) {
                console.log(`[USENET-UNIVERSAL] Video file not immediately available, polling for up to 2 minutes...`);
            } else if (attempt % 10 === 0) {
                const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
                const progressInfo = downloadStatus ? ` | Download: ${downloadStatus.percentComplete?.toFixed(1) || 0}%` : '';
                console.log(`[USENET-UNIVERSAL] Still waiting for file... (${elapsed}s elapsed, attempt ${attempt}${progressInfo})`);
            }

            // Wait before next poll
            await new Promise(resolve => setTimeout(resolve, pollInterval));
        }

        if (!fileInfo) {
            const elapsed = ((Date.now() - startTime) / 1000).toFixed(1);
            console.log(`[USENET-UNIVERSAL] Video file not found after ${elapsed}s (${attempt} attempts)`);
            return res.status(404).send(`Video file not found after waiting ${elapsed}s. The download may still be starting or extracting. Please try again in a moment.`);
        }

        console.log(`[USENET-UNIVERSAL] Resolved to: ${fileInfo.path} (${fileInfo.size} bytes)`);

        // Track this stream
        const streamKey = `universal:${decodedReleaseName}`;
        if (!ACTIVE_USENET_STREAMS.has(streamKey)) {
            ACTIVE_USENET_STREAMS.set(streamKey, {
                lastAccess: Date.now(),
                streamCount: 1,
                activeConnections: 0,
                maxBytePosition: 0,
                fileSize: fileInfo.size || 0,
                completionPercentage: 0,
                config: {
                    sabnzbdUrl: config.sabnzbdUrl,
                    sabnzbdApiKey: config.sabnzbdApiKey
                },
                videoFilePath: fileInfo.path,
                usenetConfig: config,
                releaseName: decodedReleaseName,
                isUniversal: true
            });
            console.log(`[USENET-UNIVERSAL] Created new stream tracker: ${streamKey}`);
        }

        const streamInfo = ACTIVE_USENET_STREAMS.get(streamKey);
        streamInfo.lastAccess = Date.now();

        // Store config for auto-clean
        if (config.fileServerUrl && config.autoCleanOldFiles) {
            USENET_CONFIGS.set(config.fileServerUrl, config);
        }

        // Track range requests for completion calculation
        const rangeHeader = req.headers.range;
        let requestedStart = 0;
        if (rangeHeader) {
            const rangeMatch = rangeHeader.match(/bytes=(\d+)-(\d*)/);
            if (rangeMatch) {
                requestedStart = parseInt(rangeMatch[1]);
                if (requestedStart > streamInfo.maxBytePosition) {
                    streamInfo.maxBytePosition = requestedStart;
                }
            }
        }

        let connectionCleaned = false;

        // Handle connection close - CRITICAL for preventing memory leaks
        const cleanupConnection = () => {
            if (connectionCleaned) {
                return;
            }
            connectionCleaned = true;
            streamInfo.activeConnections--;
            if (streamInfo.activeConnections < 0) streamInfo.activeConnections = 0;
            console.log(`[USENET-UNIVERSAL] Connection closed for ${streamKey}, active: ${streamInfo.activeConnections}`);

            // MEMORY LEAK FIX: Destroy axios response stream if it exists
            if (axiosResponse && axiosResponse.data && typeof axiosResponse.data.destroy === 'function') {
                try {
                    axiosResponse.data.destroy();
                    console.log(`[USENET-UNIVERSAL] Destroyed axios response stream`);
                } catch (e) {
                    console.log(`[USENET-UNIVERSAL] Error destroying stream: ${e.message}`);
                }
            }
            axiosResponse = null; // Clear reference for GC

            if (streamInfo.activeConnections === 0 && streamInfo.usenetConfig?.deleteOnStreamStop) {
                const completionThreshold = 90;
                if (streamInfo.completionPercentage >= completionThreshold) {
                    console.log(`[USENET-UNIVERSAL] Stream finished (${streamInfo.completionPercentage}%), scheduling delete`);
                    setTimeout(async () => {
                        if (streamInfo.activeConnections === 0) {
                            console.log(`[USENET-UNIVERSAL] Deleting finished file: ${fileInfo.path}`);
                            try {
                                // Delete file from server
                                const axios = (await import('axios')).default;
                                const apiKey = config.fileServerPassword || process.env.USENET_FILE_SERVER_API_KEY;
                                const headers = {};
                                if (apiKey) headers['X-API-Key'] = apiKey;

                                await axios.delete(
                                    `${config.fileServerUrl.replace(/\/$/, '')}/api/delete`,
                                    {
                                        data: { path: fileInfo.path },
                                        headers,
                                        timeout: 5000
                                    }
                                );
                                console.log(`[USENET-UNIVERSAL] File deleted successfully`);
                            } catch (e) {
                                console.log(`[USENET-UNIVERSAL] Error deleting file: ${e.message}`);
                            }
                            ACTIVE_USENET_STREAMS.delete(streamKey);
                        }
                    }, 30000); // Wait 30s before deleting
                }
            }
        };

        req.on('close', cleanupConnection);
        req.on('error', (err) => {
            console.log(`[USENET-UNIVERSAL] Request error: ${err.message}`);
            cleanupConnection();
        });

        // Proxy to file server
        const fileServerUrl = config.fileServerUrl.replace(/\/$/, '');
        const encodedProxyPath = encodeURI(fileInfo.path).replace(/\|/g, '%7C').replace(/#/g, '%23');
        const proxyUrl = `${fileServerUrl}/${encodedProxyPath}`;
        console.log(`[USENET-UNIVERSAL] Proxying to: ${proxyUrl}`);

        const axios = (await import('axios')).default;
        const headers = {};
        if (rangeHeader) {
            headers['Range'] = rangeHeader;
        }

        const apiKey = config.fileServerPassword || process.env.USENET_FILE_SERVER_API_KEY;
        if (apiKey) {
            headers['X-API-Key'] = apiKey;
        }
        const expectedFileSize = lastDownloadStatus?.bytesTotal ? Math.round(Number(lastDownloadStatus.bytesTotal)) : null;
        if (expectedFileSize) {
            headers['X-Expected-File-Size'] = expectedFileSize;
        }

        // Probe readiness with a small range request (respecting requested start if provided)
        try {
            const probeStart = Math.max(0, requestedStart);
            const probeEnd = probeStart + 1;
            const probeHeaders = { ...headers, Range: `bytes=${probeStart}-${probeEnd}` };
            const probeResp = await axios.get(proxyUrl, {
                headers: probeHeaders,
                responseType: 'stream',
                validateStatus: (status) => status === 206 || status === 200 || status === 416 || status === 404,
                timeout: 10000
            });

            console.log(`[USENET-UNIVERSAL] Probe status ${probeResp.status} for ${proxyUrl}`);

            if (probeResp.status === 416) {
                console.log(`[USENET-UNIVERSAL] Probe got 416 (range ${probeStart}-${probeEnd} not available yet)`);
                return res.status(202).send('Video file not yet ready for streaming. Please retry in a moment.');
            }
            if (probeResp.status === 404) {
                console.log(`[USENET-UNIVERSAL] Probe got 404 - file not found on server`);
                return res.status(202).send('Video file not yet found on file server. Please retry shortly.');
            }

            // If 200 without range support, still allow if content-length is non-zero
            const contentRange = probeResp.headers['content-range'];
            const contentLength = Number(probeResp.headers['content-length'] || 0);
            const minReadyBytes = 512 * 1024; // 0.5MB minimum before we attempt streaming
            if (probeResp.status === 206 && contentRange) {
                console.log(`[USENET-UNIVERSAL] Probe Content-Range: ${contentRange}`);
            }
            if (contentLength > 0 && contentLength < minReadyBytes && probeResp.status === 200) {
                console.log(`[USENET-UNIVERSAL] Probe returned too few bytes (${contentLength}), waiting for growth`);
                return res.status(202).send('Video file not yet ready for streaming. Please retry in a moment.');
            }

            // If we got 200/206, proceed with full proxy
            try {
                probeResp.data.destroy?.();
            } catch (e) {
                // ignore
            }
        } catch (err) {
            console.log(`[USENET-UNIVERSAL] Probe failed: ${err.message}`);
            return res.status(202).send('Video file not ready for streaming yet. Please retry shortly.');
        }

        // Redirect directly to file server to avoid Node proxy aborts; client will re-request ranges there
        const directUrl = `${proxyUrl}${apiKey ? (proxyUrl.includes('?') ? '&' : '?') + 'key=' + encodeURIComponent(apiKey) : ''}`;
        console.log(`[USENET-UNIVERSAL] Redirecting client directly to file server: ${directUrl}`);
        return res.redirect(302, directUrl);

        // Make request to file server (full stream)
        try {
            axiosResponse = await axios.get(proxyUrl, {
                headers,
                responseType: 'stream',
                validateStatus: (status) => status < 500,
                timeout: 60000,
                decompress: false
            });
        } catch (err) {
            console.log(`[USENET-UNIVERSAL] Stream request failed: ${err.message}`);
            cleanupConnection();
            return res.status(202).send('Video file not yet ready for streaming. Please retry in a moment.');
        }

        // Forward response status and headers
        res.status(axiosResponse.status);
        Object.keys(axiosResponse.headers).forEach(key => {
            res.setHeader(key, axiosResponse.headers[key]);
        });

        // Update file size and completion
        if (axiosResponse.headers['content-range']) {
            const rangeMatch = axiosResponse.headers['content-range'].match(/bytes \d+-\d+\/(\d+)/);
            if (rangeMatch) {
                streamInfo.fileSize = parseInt(rangeMatch[1]);
            }
        } else if (axiosResponse.headers['content-length']) {
            streamInfo.fileSize = parseInt(axiosResponse.headers['content-length']);
        }

        if (streamInfo.fileSize > 0) {
            streamInfo.completionPercentage = Math.round((streamInfo.maxBytePosition / streamInfo.fileSize) * 100);
        }

        // MEMORY LEAK FIX: Properly handle stream errors and cleanup
        axiosResponse.data.on('error', (err) => {
            console.log(`[USENET-UNIVERSAL] Stream error: ${err.message}`);
            cleanupConnection();
        });

        res.on('error', (err) => {
            console.log(`[USENET-UNIVERSAL] Response error: ${err.message}`);
            cleanupConnection();
        });

        res.on('close', cleanupConnection);

        // Pipe the response
        axiosResponse.data.pipe(res);

    } catch (error) {
        console.error('[USENET-UNIVERSAL] Error:', error.message);

        // MEMORY LEAK FIX: Clean up axios response on error
        if (axiosResponse && axiosResponse.data && typeof axiosResponse.data.destroy === 'function') {
            try {
                axiosResponse.data.destroy();
            } catch (e) {
                // Ignore cleanup errors
            }
        }
        axiosResponse = null; // Clear reference

        if (!res.headersSent) {
            return res.status(500).send('Error streaming file');
        }
    }
});

// Usenet progressive streaming endpoint with range request support
app.get('/usenet/stream/:nzbUrl/:title/:type/:id', async (req, res) => {
    const { nzbUrl, title, type, id } = req.params;

    try {
        const configJson = req.query.config;
        if (!configJson) {
            return res.status(400).send('Missing configuration');
        }

        // Safe parsing with memory and size limits
        const decodedConfigJson = decodeURIComponent(configJson);
        // Check size before parsing to prevent memory issues
        if (decodedConfigJson.length > 100000) { // 100KB limit
            return res.status(400).send('Config parameter too large');
        }
        const config = JSON.parse(decodedConfigJson);

        if (!config.newznabUrl || !config.newznabApiKey || !config.sabnzbdUrl || !config.sabnzbdApiKey) {
            return res.status(400).send('Usenet not configured');
        }

        const decodedNzbUrl = decodeURIComponent(nzbUrl);
        const decodedTitle = decodeURIComponent(title);

        console.log('[USENET] Stream request for:', decodedTitle);

        // Check disk space first
        const diskSpace = await SABnzbd.getDiskSpace(config.sabnzbdUrl, config.sabnzbdApiKey);
        if (diskSpace) {
            if (diskSpace.incompleteDir.lowSpace) {
                console.log(`[USENET] WARNING: Low disk space in incomplete dir: ${diskSpace.incompleteDir.available}`);
            }
            if (diskSpace.completeDir.lowSpace) {
                console.log(`[USENET] WARNING: Low disk space in complete dir: ${diskSpace.completeDir.available}`);
            }

            // Return error if critically low (less than 2GB)
            const criticalThreshold = 2 * 1024 * 1024 * 1024;
            if (diskSpace.incompleteDir.availableBytes < criticalThreshold) {
                return res.status(507).send(
                    `⚠️ Insufficient storage space!\n\n` +
                    `Available: ${diskSpace.incompleteDir.available}\n` +
                    `Please free up space on your SABnzbd incomplete directory.`
                );
            }
        }

        // Check if already downloading in our memory cache
        let nzoId = null;
        for (const [downloadId, info] of Usenet.activeDownloads.entries()) {
            if (info.name === decodedTitle) {
                nzoId = downloadId;
                console.log('[USENET] Found existing download in memory:', nzoId);
                break;
            }
        }

        // Check SABnzbd queue and history for existing downloads
        if (!nzoId) {
            const existing = await SABnzbd.findDownloadByName(config.sabnzbdUrl, config.sabnzbdApiKey, decodedTitle);
            if (existing) {
                nzoId = existing.nzoId;
                console.log(`[USENET] Found existing download in ${existing.location}: ${nzoId} (${existing.status})`);

                // If it's completed, verify the files actually exist
                if (existing.status === 'completed') {
                    const status = await SABnzbd.getDownloadStatus(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);
                    if (status.path && !fs.existsSync(status.path)) {
                        console.log(`[USENET] ⚠️  Completed download folder missing: ${status.path}`);
                        console.log(`[USENET] Deleting stale history entry and re-downloading...`);

                        // Delete from history
                        await SABnzbd.deleteItem(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId, false);
                        nzoId = null; // Reset so we re-download below
                    }
                }

                if (nzoId) {
                    // Add to our memory cache
                    Usenet.activeDownloads.set(nzoId, {
                        nzoId: nzoId,
                        name: decodedTitle,
                        startTime: Date.now(),
                        status: existing.status
                    });

                    // Only delete other INCOMPLETE downloads if this is still downloading
                    // Don't delete anything if this is already completed
                    if (existing.status === 'downloading' || existing.status === 'Downloading' || existing.status === 'Paused') {
                        console.log('[USENET] Deleting other incomplete downloads to prioritize existing stream...');
                        const deletedCount = await SABnzbd.deleteAllExcept(
                            config.sabnzbdUrl,
                            config.sabnzbdApiKey,
                            nzoId,
                            true // Delete files
                        );
                        if (deletedCount > 0) {
                            console.log(`[USENET] ✓ Deleted ${deletedCount} other download(s)`);
                        }
                    } else {
                        console.log('[USENET] Existing download is completed, keeping all other downloads');
                    }
                }
            }
        }

        // Before submitting NZB, check if file already exists on file server
        if (!nzoId && config.fileServerUrl) {
            console.log('[USENET] Checking file server for existing file before submitting NZB...');
            const { findVideoFileViaAPI } = await import('./server/usenet/video-finder.js');
            const existingFile = await findVideoFileViaAPI(
                config.fileServerUrl,
                decodedTitle,
                type === 'series' ? { season: id.split(':')[1], episode: id.split(':')[2] } : {},
                config.fileServerPassword
            );

            if (existingFile) {
                console.log(`[USENET] ✓ File already exists on file server: ${existingFile.path}`);
                console.log(`[USENET] Streaming directly from file server (no download needed)`);

                // Redirect to personal file endpoint
                const encodedPath = existingFile.path.split('/').map(encodeURIComponent).join('/');
                const configParam = encodeURIComponent(configJson);
                return res.redirect(307, `/usenet/personal/${encodedPath}?config=${configParam}`);
            }
        }

        // Submit NZB to SABnzbd if not already downloading and file not on server
        if (!nzoId) {
            // Check for pending submission to prevent race conditions
            if (PENDING_USENET_SUBMISSIONS.has(decodedTitle)) {
                console.log('[USENET] Another request is already submitting this NZB, waiting...');
                try {
                    const pendingResult = await PENDING_USENET_SUBMISSIONS.get(decodedTitle);
                    nzoId = pendingResult.nzoId;
                    console.log('[USENET] Using NZO ID from concurrent submission:', nzoId);
                } catch (error) {
                    console.log('[USENET] Pending submission failed, will try again:', error.message);
                    // Continue to submit below if the other request failed
                }
            }

            if (!nzoId) {
                // Delete ALL incomplete downloads BEFORE submitting new one to free up bandwidth immediately
                console.log('[USENET] Deleting all incomplete downloads to free bandwidth for new stream...');
                const deletedCount = await SABnzbd.deleteAllExcept(
                    config.sabnzbdUrl,
                    config.sabnzbdApiKey,
                    null, // No exception - delete everything incomplete
                    true  // Delete files
                );
                if (deletedCount > 0) {
                    console.log(`[USENET] ✓ Deleted ${deletedCount} incomplete download(s) to free bandwidth`);
                }

                console.log('[USENET] Submitting NZB to SABnzbd...');

                // Create submission promise and store it
                const submissionPromise = Usenet.submitNzb(
                    config.sabnzbdUrl,
                    config.sabnzbdApiKey,
                    config.newznabUrl,
                    config.newznabApiKey,
                    decodedNzbUrl,
                    decodedTitle
                );
                PENDING_USENET_SUBMISSIONS.set(decodedTitle, submissionPromise);

                try {
                    const submitResult = await submissionPromise;
                    nzoId = submitResult.nzoId;
                } finally {
                    // Clean up pending submission after 5 seconds
                    setTimeout(() => {
                        PENDING_USENET_SUBMISSIONS.delete(decodedTitle);
                    }, 5000);
                }

                // Add to memory cache immediately to prevent race conditions
                Usenet.activeDownloads.set(nzoId, {
                    nzoId: nzoId,
                    name: decodedTitle,
                    startTime: Date.now(),
                    status: 'downloading'
                });

                console.log(`[USENET] ✓ New download started, all bandwidth dedicated to: ${decodedTitle}`);
            }

            // Don't delete completed folders - they become personal files for instant playback
            // Auto-clean will handle old files based on user settings
            console.log(`[USENET] Keeping all completed folders (personal files)`);

        }

        // IMMEDIATE STREAMING: If file server is configured, redirect to universal endpoint
        // This allows streaming to start as soon as any data is available, and continues
        // working even when SABnzbd moves files from incomplete/ to complete/
        // The universal endpoint queries the file server API dynamically to find current location
        if (config.fileServerUrl && config.immediateStreaming !== false) {
            console.log('[USENET] File server configured - redirecting to universal streaming endpoint for immediate playback');
            console.log('[USENET] Universal endpoint will stream as soon as file is available (no 5% wait)');

            const encodedReleaseName = encodeURIComponent(decodedTitle);
            const encodedType = encodeURIComponent(type);
            const encodedId = encodeURIComponent(id);
            const configParam = encodeURIComponent(configJson);

            // Pass nzoId to allow monitoring download progress during polling
            const universalUrl = `/usenet/universal/${encodedReleaseName}/${encodedType}/${encodedId}?config=${configParam}&nzoId=${encodeURIComponent(nzoId)}`;
            console.log(`[USENET] Redirecting to: ${universalUrl}`);

            return res.redirect(307, universalUrl);
        }

        // FALLBACK: Progressive streaming with 5% wait (when file server not configured)
        console.log('[USENET] File server not configured or immediate streaming disabled - using progressive mode with 5% wait');

        // Check current download status
        let status = await SABnzbd.getDownloadStatus(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);

        // Only wait if download hasn't reached 5% yet
        if ((status.percentComplete || 0) < 5 && status.status !== 'completed') {
            console.log('[USENET] Waiting for download to start...');
            try {
                status = await Usenet.waitForStreamingReady(
                    config.sabnzbdUrl,
                    config.sabnzbdApiKey,
                    nzoId,
                    5, // 5% minimum - ensure enough data for initial streaming
                    60000 // 1 minute max wait for download to start
                );
            } catch (error) {
                console.log(`[USENET] Download failed or timed out: ${error.message}`);

                // Delete the failed download
                try {
                    await SABnzbd.deleteItem(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId, true);
                    console.log(`[USENET] Deleted failed download: ${nzoId}`);
                } catch (deleteError) {
                    console.log(`[USENET] Could not delete failed download: ${deleteError.message}`);
                }

                // Return error video
                const fileServerUrl = config.fileServerUrl || process.env.USENET_FILE_SERVER_URL;
                if (fileServerUrl) {
                    let errorMessage = 'Download failed or timed out';
                    if (error.message.includes('Aborted')) {
                        errorMessage = 'Download failed - file incomplete or missing from Usenet servers';
                    } else if (error.message.includes('Timeout')) {
                        errorMessage = 'Download timed out - file may be missing or too slow';
                    }
                    return redirectToErrorVideo(errorMessage, res, fileServerUrl);
                } else {
                    return res.status(500).send(error.message);
                }
            }
        } else {
            console.log(`[USENET] Download already at ${status.percentComplete?.toFixed(1)}%, skipping wait`);
        }

        let videoFilePath = null;
        let videoFileSize = 0; // Track file size from API

        // Get SABnzbd config to find the incomplete directory
        const sabnzbdConfig = await SABnzbd.getConfig(config.sabnzbdUrl, config.sabnzbdApiKey);
        console.log('[USENET] SABnzbd directories:', {
            downloadDir: sabnzbdConfig?.downloadDir,
            incompleteDir: sabnzbdConfig?.incompleteDir
        });

        let searchPath = null;

        // Check if using file server API (for archivemount mounted directory) - declare outside loop
        const fileServerUrl = config.fileServerUrl || process.env.USENET_FILE_SERVER_URL;

        // Extract actual folder name from status (SABnzbd may append .1, .2 etc if folder exists)
        // Use basename of incompletePath if available, otherwise use status.name
        let actualFolderName = decodedTitle;
        if (status.incompletePath) {
            actualFolderName = path.basename(status.incompletePath);
            console.log(`[USENET] Using actual folder name from SABnzbd: ${actualFolderName}`);
        } else if (status.name) {
            actualFolderName = status.name;
            console.log(`[USENET] Using folder name from status: ${actualFolderName}`);
        }

        // Wait for video file to be extracted - poll more frequently for faster streaming
        const maxWaitForFile = 120000; // 2 minutes max
        const fileCheckInterval = 1000; // Check every 1 second (faster detection)
        const fileCheckStart = Date.now();

        while (Date.now() - fileCheckStart < maxWaitForFile) {
            // Try to find video file in incomplete folder first (for progressive streaming)
            if (status.status === 'downloading') {
                // Build path to incomplete download folder
                if (sabnzbdConfig?.incompleteDir) {
                    searchPath = path.join(sabnzbdConfig.incompleteDir, decodedTitle);
                } else if (status.incompletePath) {
                    searchPath = status.incompletePath;
                }

                // Log what we're checking
                console.log(`[USENET] Checking for video file in: ${searchPath}`);

                // Look for release name folder in incomplete directory
                // RAR files are mounted transparently via archivemount python server

                if (fileServerUrl) {
                    // Query the file server API directly (don't check local filesystem)
                    // The file server has its own filesystem access and FUSE archive mounting

                    const fileInfo = await findVideoFileViaAPI(
                        fileServerUrl,
                        decodedTitle,
                        type === 'series' ? { season: id.split(':')[1], episode: id.split(':')[2] } : {},
                        config.fileServerPassword
                    );
                    if (fileInfo) {
                        // Use the full path from the file server (no cleaning needed)
                        const encodedServerPath = encodeURI(fileInfo.path).replace(/\|/g, '%7C').replace(/#/g, '%23');
                        videoFilePath = `${fileServerUrl.replace(/\/$/, '')}/${encodedServerPath}`;
                        videoFileSize = fileInfo.size; // Store the file size for tracking
                        console.log('[USENET] Found video file via API:', videoFilePath);
                        break; // Exit the waiting loop
                    } else {
                        console.log(`[USENET] Video file not found yet via API. Progress: ${status.percentComplete?.toFixed(1) || 0}%`);
                    }
                } else if (searchPath && fs.existsSync(searchPath)) {
                    // Fallback to direct filesystem search (no rar2fs)
                    // List what's in the directory
                    let files = [];
                    try {
                        files = fs.readdirSync(searchPath);
                        console.log(`[USENET] Files in download directory (${files.length}):`, files.slice(0, 5).join(', '));
                    } catch (e) {
                        console.log(`[USENET] Could not list directory: ${e.message}`);
                    }

                    videoFilePath = await findVideoFile(
                        searchPath,
                        decodedTitle,
                        type === 'series' ? { season: id.split(':')[1], episode: id.split(':')[2] } : {}
                    );
                    if (videoFilePath) {
                        console.log('[USENET] Found video file in download folder:', videoFilePath);
                        break; // Exit the waiting loop
                    }
                }

                if (!videoFilePath && !fileServerUrl && searchPath && fs.existsSync(searchPath)) {
                    // Check for archives if we're not using file server
                    let files = [];
                    try {
                        files = fs.readdirSync(searchPath);
                    } catch (e) {
                        console.log(`[USENET] Could not list directory: ${e.message}`);
                    }

                    // Check for archive files (RAR, 7z, ZIP)
                    const has7zFiles = files.some(f => {
                        const lower = f.toLowerCase();
                        return lower.endsWith('.7z') || lower.match(/\.7z\.\d+$/);
                    });
                    if (has7zFiles) {
                        console.log('[USENET] ⚠️ 7z archive detected - ensure fuse-archive is installed on file server');
                    }

                    // Check if we see RAR files (FUSE will mount them transparently)
                    const hasRarFiles = files.some(f =>
                        f.toLowerCase().endsWith('.rar') ||
                        f.toLowerCase().match(/\.r\d+$/) ||
                        f.toLowerCase().endsWith('.zip')
                    );
                    if (hasRarFiles) {
                        console.log('[USENET] ⚠️ RAR/ZIP archives detected - waiting for FUSE to mount them');
                    } else {
                        console.log('[USENET] No video file found yet, download may still be in progress');
                    }
                }

                if (!videoFilePath && !fileServerUrl && !fs.existsSync(searchPath)) {
                    console.log(`[USENET] Path does not exist yet: ${searchPath}`);
                }
            }

            // If complete, get from complete folder
            if (status.status === 'completed' && status.path) {
                console.log('[USENET] Download completed, looking in complete folder:', status.path);

                // Check if there are RAR files - use file server API with rar2fs
                const hasRarFiles = fs.existsSync(status.path) &&
                    fs.readdirSync(status.path).some(f => f.toLowerCase().match(/\.(rar|r\d+)$/));

                if (hasRarFiles && fileServerUrl) {
                    console.log('[USENET] Completed RAR archive detected, using file server API with rar2fs');
                    const fileInfo = await findVideoFileViaAPI(
                        fileServerUrl,
                        decodedTitle,
                        type === 'series' ? { season: id.split(':')[1], episode: id.split(':')[2] } : {},
                        config.fileServerPassword
                    );
                    if (fileInfo) {
                        // Use the full path from the file server (no cleaning needed)
                        const encodedServerPath = encodeURI(fileInfo.path).replace(/\|/g, '%7C').replace(/#/g, '%23');
                        videoFilePath = `${fileServerUrl.replace(/\/$/, '')}/${encodedServerPath}`;
                        videoFileSize = fileInfo.size;
                        console.log('[USENET] Found video file via API (completed):', videoFilePath);
                        break; // Exit the waiting loop
                    }
                } else {
                    // Direct video file (no RAR) - use filesystem
                    videoFilePath = await findVideoFile(
                        status.path,
                        decodedTitle,
                        type === 'series' ? { season: id.split(':')[1], episode: id.split(':')[2] } : {}
                    );
                    if (videoFilePath) {
                        console.log('[USENET] Found direct video file (completed):', videoFilePath);
                        break; // Exit the waiting loop
                    }
                }
            }

            // File not found yet, wait and refresh status
            console.log(`[USENET] Video file not extracted yet, waiting... Progress: ${status.percentComplete?.toFixed(1) || 0}%`);
            await new Promise(resolve => setTimeout(resolve, fileCheckInterval));
            status = await SABnzbd.getDownloadStatus(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);

            // Check for failures
            if (status.status === 'error' || status.status === 'failed') {
                const errorMsg = `Download failed: ${status.error || status.failMessage || 'Unknown error'}`;
                console.log(`[USENET] ${errorMsg}`);
                const fileServerUrl = config.fileServerUrl || process.env.USENET_FILE_SERVER_URL;
                if (!fileServerUrl) {
                    return res.status(500).send(errorMsg);
                }
                return redirectToErrorVideo(errorMsg, res, fileServerUrl);
            }
        }

        // Check if videoFilePath is a URL or local file
        // fileServerUrl already declared above
        const isUrl = videoFilePath && (videoFilePath.startsWith('http://') || videoFilePath.startsWith('https://'));
        const fileExists = isUrl ? true : (videoFilePath && fs.existsSync(videoFilePath));

        if (!videoFilePath || !fileExists) {
            // File still not ready after waiting
            console.log('[USENET] Video file not found after waiting.');
            console.log('[USENET] Status:', status.status, 'Progress:', status.percentComplete + '%');
            console.log('[USENET] Searched path:', searchPath);

            return res.status(202).send(
                `Download in progress: ${status.percentComplete?.toFixed(1) || 0}%. ` +
                `Video file not yet available from archive. Please try again in a moment.`
            );
        }

        console.log('[USENET] Streaming from:', videoFilePath);

        // Check if external file server is configured - if so, skip range checks and redirect immediately
        const fileServerUrl2 = config.fileServerUrl || process.env.USENET_FILE_SERVER_URL;
        const usingFileServer = !!fileServerUrl2;

        // Check if videoFilePath is already a URL (from API query)
        const videoPathIsUrl = videoFilePath && (videoFilePath.startsWith('http://') || videoFilePath.startsWith('https://'));

        // If videoFilePath is already a URL, redirect to Python file server directly
        if (videoPathIsUrl) {
            console.log(`[USENET] Redirecting to Python file server: ${videoFilePath}`);

            // Track stream access
            if (!ACTIVE_USENET_STREAMS.has(nzoId)) {
                ACTIVE_USENET_STREAMS.set(nzoId, {
                    videoFilePath: videoFilePath,
                    downloadPercent: status.percentComplete || 0,
                    streamCount: 1,
                    startTime: Date.now(),
                    lastAccess: Date.now(),
                    estimatedFileSize: videoFileSize, // File size from API
                    lastDownloadPercent: status.percentComplete || 0,
                    config: config, // Store config for monitoring
                    paused: false,
                    fileSize: videoFileSize, // File size from API
                    lastPlaybackPosition: 0
                });
            } else {
                const streamInfo = ACTIVE_USENET_STREAMS.get(nzoId);
                streamInfo.lastAccess = Date.now();
                streamInfo.streamCount++;
                streamInfo.lastDownloadPercent = status.percentComplete || 0;
            }

            // Add API key for file server authentication
            const apiKey = config.fileServerPassword || process.env.USENET_FILE_SERVER_API_KEY;
            if (apiKey) {
                // Append as query parameter for direct streaming support
                const separator = videoFilePath.includes('?') ? '&' : '?';
                videoFilePath = `${videoFilePath}${separator}key=${apiKey}`;
            }

            console.log(`[USENET] Direct stream URL: ${videoFilePath}`);
            console.log(`[USENET] 🔀 Sending 302 redirect to client - client will connect directly to Python server`);

            // Return 302 redirect to Python file server
            // Client (VLC/Stremio) will connect directly to Python server
            return res.redirect(302, videoFilePath);
        }

        // Check if user is trying to resume from middle (Range request)
        // Skip this check if using file server - let file server handle ranges
        const rangeHeader = req.headers.range;
        if (!usingFileServer && rangeHeader && status.status === 'downloading') {
            const rangeMatch = rangeHeader.match(/bytes=(\d+)-/);
            if (rangeMatch) {
                const requestedByte = parseInt(rangeMatch[1]);

                // Get video file size (either from file if exists, or estimate from download)
                let videoFileSize = 0;
                if (fs.existsSync(videoFilePath)) {
                    videoFileSize = fs.statSync(videoFilePath).size;
                } else if (status.bytesTotal && status.bytesTotal > 0) {
                    // Estimate video size (usually slightly smaller than download size due to compression)
                    videoFileSize = status.bytesTotal * 0.9;
                }

                if (videoFileSize > 0 && requestedByte > 0) {
                    const requestedPercent = Math.min((requestedByte / videoFileSize) * 100, 100);
                    let downloadPercent = status.percentComplete || 0;

                    console.log(`[USENET] User resuming from ${requestedPercent.toFixed(1)}%, download at ${downloadPercent.toFixed(1)}%`);

                    // If user is trying to seek ahead of download, wait for download to catch up
                    if (requestedPercent > downloadPercent + 5) { // +5% buffer for safety
                        const targetPercent = Math.min(requestedPercent + 10, 100); // Wait for 10% extra buffer, max 100%
                        console.log(`[USENET] ⏳ User requesting ${requestedPercent.toFixed(1)}% (byte ${requestedByte}), download at ${downloadPercent.toFixed(1)}%, waiting for ${targetPercent.toFixed(1)}%...`);

                        // Wait in loop until download catches up
                        const maxWaitTime = 5 * 60 * 1000; // Max 5 minutes
                        const startWaitTime = Date.now();

                        while (downloadPercent < targetPercent) {
                            // Check if we've waited too long
                            if (Date.now() - startWaitTime > maxWaitTime) {
                                return res.status(408).send(
                                    `Download not progressing fast enough to reach your playback position.\n\n` +
                                    `Your position: ${requestedPercent.toFixed(1)}%\n` +
                                    `Download progress: ${downloadPercent.toFixed(1)}%\n\n` +
                                    `Please try starting from the beginning or wait for more of the file to download.`
                                );
                            }

                            // Wait 2 seconds before checking again
                            await new Promise(resolve => setTimeout(resolve, 2000));

                            // Refresh download status
                            status = await SABnzbd.getDownloadStatus(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);
                            downloadPercent = status.percentComplete || 0;

                            console.log(`[USENET] ⏳ Waiting for download: ${downloadPercent.toFixed(1)}% / ${targetPercent.toFixed(1)}%`);

                            // Check for download failures
                            if (status.status === 'error' || status.status === 'failed') {
                                return res.status(500).send(`Download failed: ${status.error || status.failMessage || 'Unknown error'}`);
                            }

                            // If download completed, break out and stream
                            if (status.status === 'completed') {
                                console.log('[USENET] Download completed while waiting');
                                break;
                            }
                        }

                        console.log(`[USENET] ✓ Download reached ${downloadPercent.toFixed(1)}%, proceeding with stream`);
                    }
                }
            }
        }

        // Only pause if download is at 99% or higher and has no missing blocks
        // This prevents pausing too early and ensures repairs can complete
        let downloadPaused = false;
        if (status.percentComplete >= 99) {
            // Check for missing blocks - if any files have missing blocks, don't pause
            let hasMissingBlocks = false;
            if (status.files && Array.isArray(status.files)) {
                for (const file of status.files) {
                    // SABnzbd files have 'bytes' (downloaded) and 'bytes_left' properties
                    // If bytes_left > 0, there are still blocks to download
                    if (file.bytes_left && parseInt(file.bytes_left) > 0) {
                        hasMissingBlocks = true;
                        console.log(`[USENET] ⚠️ File "${file.filename}" has ${file.bytes_left} bytes left to download`);
                        break;
                    }
                    // Also check 'mb' and 'mb_left' as SABnzbd uses both
                    if (file.mb_left && parseFloat(file.mb_left) > 0) {
                        hasMissingBlocks = true;
                        console.log(`[USENET] ⚠️ File "${file.filename}" has ${file.mb_left} MB left to download`);
                        break;
                    }
                }
            }

            if (hasMissingBlocks) {
                console.log('[USENET] ⚠️ NOT pausing download - missing blocks detected, letting SABnzbd finish for repair');
            } else {
                console.log('[USENET] Pausing SABnzbd download to protect streaming files (99%+ complete, no missing blocks)...');
                await SABnzbd.pauseDownload(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);
                downloadPaused = true;
            }
        } else {
            console.log(`[USENET] NOT pausing download yet - only at ${status.percentComplete?.toFixed(1)}%, will pause at 99%`);
        }

        // Redirect to external file server if configured
        if (usingFileServer) {
            // Redirect to external file server instead of streaming through Node.js
            // Try to make path relative to either downloadDir or incompleteDir
            let relativePath = videoFilePath;

            // Try downloadDir first (complete directory)
            if (sabnzbdConfig?.downloadDir && videoFilePath.startsWith(sabnzbdConfig.downloadDir)) {
                relativePath = videoFilePath.replace(sabnzbdConfig.downloadDir, '').replace(/^\//, '');
                console.log(`[USENET] File in complete directory, relative path: ${relativePath}`);
            }
            // Try incompleteDir if file is there instead
            else if (sabnzbdConfig?.incompleteDir && videoFilePath.startsWith(sabnzbdConfig.incompleteDir)) {
                relativePath = videoFilePath.replace(sabnzbdConfig.incompleteDir, '').replace(/^\//, '');
                console.log(`[USENET] File in incomplete directory, relative path: ${relativePath}`);
            }
            // If neither matched, just use the basename or try to extract a relative path
            else {
                // Extract just the folder and filename (last 2 path segments)
                const pathParts = videoFilePath.split('/').filter(p => p);
                if (pathParts.length >= 2) {
                    relativePath = pathParts.slice(-2).join('/');
                } else {
                    relativePath = pathParts[pathParts.length - 1] || videoFilePath;
                }
                console.log(`[USENET] ⚠️ File path not under SABnzbd directories, using extracted path: ${relativePath}`);
                console.log(`[USENET] Full path: ${videoFilePath}`);
                console.log(`[USENET] downloadDir: ${sabnzbdConfig?.downloadDir}`);
                console.log(`[USENET] incompleteDir: ${sabnzbdConfig?.incompleteDir}`);
            }

            // Encode each path segment separately for proper URL encoding
            const pathSegments = relativePath.split('/').map(segment => encodeURIComponent(segment));
            const encodedPath = pathSegments.join('/');

            const externalUrl = `${fileServerUrl.replace(/\/$/, '')}/${encodedPath}`;
            console.log(`[USENET] Redirecting to external file server: ${externalUrl}`);
            console.log(`[USENET] File exists check: ${fs.existsSync(videoFilePath)}`);

            // Test connectivity to file server (HEAD request to check if reachable)
            try {
                const testUrl = new URL(fileServerUrl);
                const httpModule = testUrl.protocol === 'https:' ? https : http;

                const testReq = httpModule.request({
                    hostname: testUrl.hostname,
                    port: testUrl.port || (testUrl.protocol === 'https:' ? 443 : 80),
                    path: '/',
                    method: 'HEAD',
                    timeout: 2000
                }, (testRes) => {
                    console.log(`[USENET] File server is reachable (status: ${testRes.statusCode})`);
                }).on('error', (err) => {
                    console.error(`[USENET] ⚠️ WARNING: File server is NOT reachable at ${fileServerUrl}: ${err.message}`);
                    console.error(`[USENET] Make sure the Python file server is running!`);
                }).on('timeout', () => {
                    console.error(`[USENET] ⚠️ WARNING: File server connection timeout at ${fileServerUrl}`);
                });
                testReq.end();
            } catch (err) {
                console.error(`[USENET] ⚠️ WARNING: Invalid file server URL: ${err.message}`);
            }

            // Store config globally for auto-clean
            if (config.fileServerUrl && config.autoCleanOldFiles) {
                USENET_CONFIGS.set(config.fileServerUrl, config);
            }

            // Track stream access before redirecting
            if (!ACTIVE_USENET_STREAMS.has(nzoId)) {
                const currentFileSize = fs.statSync(videoFilePath).size;
                const isIncomplete = status.status === 'downloading' && sabnzbdConfig?.incompleteDir && videoFilePath.includes(sabnzbdConfig.incompleteDir);

                // Estimate final file size - use SABnzbd total if downloading, otherwise actual size
                let estimatedFileSize = currentFileSize;
                if (isIncomplete && status.percentComplete && status.percentComplete > 0) {
                    // Estimate based on: currentSize / percentExtracted
                    // Assume extraction progress roughly matches download progress
                    const estimateFromProgress = currentFileSize / (status.percentComplete / 100);

                    // Also try using bytesTotal if available
                    let estimateFromTotal = currentFileSize;
                    if (status.bytesTotal && status.bytesTotal > currentFileSize) {
                        estimateFromTotal = status.bytesTotal * 0.9;
                    }

                    // Use the larger of the two estimates (more conservative)
                    estimatedFileSize = Math.max(estimateFromProgress, estimateFromTotal, currentFileSize);

                    console.log(`[USENET] File extracting - Current: ${(currentFileSize / 1024 / 1024).toFixed(1)} MB, Progress: ${status.percentComplete.toFixed(1)}%, Estimated final: ${(estimatedFileSize / 1024 / 1024).toFixed(1)} MB (from progress: ${(estimateFromProgress / 1024 / 1024).toFixed(1)} MB, from total: ${(estimateFromTotal / 1024 / 1024).toFixed(1)} MB)`);
                }

                let initialPosition = 0;

                // Check if user is starting from a specific position (range request)
                if (req.headers.range) {
                    const rangeMatch = req.headers.range.match(/bytes=(\d+)-/);
                    if (rangeMatch) {
                        initialPosition = parseInt(rangeMatch[1]);
                        const seekPercent = estimatedFileSize > 0
                            ? (initialPosition / estimatedFileSize * 100).toFixed(1)
                            : '?';
                        console.log(`[USENET] 🎯 User starting at ${seekPercent}% (byte ${initialPosition.toLocaleString()}), download at ${status.percentComplete?.toFixed(1)}%`);
                    }
                }

                ACTIVE_USENET_STREAMS.set(nzoId, {
                    lastAccess: Date.now(),
                    streamCount: 1,
                    paused: downloadPaused, // True only if we actually paused SABnzbd
                    config: {
                        sabnzbdUrl: config.sabnzbdUrl,
                        sabnzbdApiKey: config.sabnzbdApiKey
                    },
                    videoFilePath: relativePath, // Relative path for deletion
                    usenetConfig: config, // Full config with cleanup options
                    fileSize: estimatedFileSize,
                    lastPlaybackPosition: initialPosition,
                    lastDownloadPercent: status.percentComplete || 0
                });
            } else {
                const streamInfo = ACTIVE_USENET_STREAMS.get(nzoId);
                streamInfo.lastAccess = Date.now();
                streamInfo.streamCount++;

                // Update file size estimate if file is still downloading and we have better info
                const currentFileSize = fs.statSync(videoFilePath).size;
                const isIncomplete = status.status === 'downloading' && sabnzbdConfig?.incompleteDir && videoFilePath.includes(sabnzbdConfig.incompleteDir);
                if (isIncomplete && status.percentComplete && status.percentComplete > 0) {
                    // Estimate based on current progress
                    const estimateFromProgress = currentFileSize / (status.percentComplete / 100);

                    let estimateFromTotal = currentFileSize;
                    if (status.bytesTotal && status.bytesTotal > currentFileSize) {
                        estimateFromTotal = status.bytesTotal * 0.9;
                    }

                    const newEstimate = Math.max(estimateFromProgress, estimateFromTotal, currentFileSize, streamInfo.fileSize);

                    // Log extraction progress
                    const extractedPercent = streamInfo.fileSize > 0 ? (currentFileSize / streamInfo.fileSize * 100) : 0;
                    console.log(`[USENET] File extraction: ${(currentFileSize / 1024 / 1024).toFixed(1)} MB extracted (${extractedPercent.toFixed(1)}%), download at ${status.percentComplete.toFixed(1)}%, estimated final: ${(newEstimate / 1024 / 1024).toFixed(1)} MB`);

                    streamInfo.fileSize = newEstimate;
                } else if (!isIncomplete && currentFileSize > streamInfo.fileSize) {
                    // File finished downloading, use actual size
                    streamInfo.fileSize = currentFileSize;
                }

                // Update playback position from range header if present
                if (req.headers.range) {
                    const rangeMatch = req.headers.range.match(/bytes=(\d+)-/);
                    if (rangeMatch) {
                        const bytePosition = parseInt(rangeMatch[1]);
                        streamInfo.lastPlaybackPosition = bytePosition;

                        // Log seek position with actual vs estimated size
                        const seekPercent = streamInfo.fileSize > 0
                            ? (bytePosition / streamInfo.fileSize * 100).toFixed(1)
                            : '?';

                        // Check if seeking beyond extracted range (with 5MB safety buffer)
                        // For MKV files, also check if extraction is far enough for seeking to work
                        const safetyBuffer = 5 * 1024 * 1024; // 5 MB
                        const maxSafePosition = Math.max(0, currentFileSize - safetyBuffer);

                        // MKV files need index at end - require at least 80% extraction for reliable seeking
                        const isMKV = videoFilePath.toLowerCase().endsWith('.mkv');
                        const extractionPercent = streamInfo.fileSize > 0 ? (currentFileSize / streamInfo.fileSize * 100) : 0;
                        const mkvSeekThreshold = 80; // Need 80% extracted for MKV seeking

                        if (isMKV && bytePosition > 0 && extractionPercent < mkvSeekThreshold) {
                            console.log(`[USENET] ⚠️ MKV file only ${extractionPercent.toFixed(1)}% extracted - seeking may not work until ${mkvSeekThreshold}% (MKV index usually at end of file)`);
                            return res.status(416).send(
                                `⚠️ Seeking not yet available for this MKV file.\n\n` +
                                `MKV files store their seeking index at the end of the file.\n` +
                                `Extraction progress: ${extractionPercent.toFixed(1)}%\n` +
                                `Seeking available at: ${mkvSeekThreshold}%\n` +
                                `Download progress: ${status.percentComplete?.toFixed(1)}%\n\n` +
                                `Please start from the beginning or wait for more extraction.\n` +
                                `The video will play normally from the start.`
                            );
                        }

                        if (bytePosition >= maxSafePosition) {
                            const extractedPercent = streamInfo.fileSize > 0 ? (currentFileSize / streamInfo.fileSize * 100) : 0;
                            const targetSize = bytePosition + (10 * 1024 * 1024); // Need 10MB past seek point
                            const waitMessage = bytePosition >= currentFileSize
                                ? `Seeking beyond extracted range (${(bytePosition / 1024 / 1024).toFixed(1)} MB requested, only ${(currentFileSize / 1024 / 1024).toFixed(1)} MB extracted)`
                                : `Seeking too close to extraction edge (${(currentFileSize - bytePosition) / 1024 / 1024} MB buffer)`;

                            console.log(`[USENET] ⚠️ ${waitMessage}. Waiting for extraction to reach ${(targetSize / 1024 / 1024).toFixed(1)} MB...`);

                            // Wait for extraction to catch up
                            const maxWaitTime = 2 * 60 * 1000; // 2 minutes max
                            const startWait = Date.now();

                            while (Date.now() - startWait < maxWaitTime) {
                                await new Promise(resolve => setTimeout(resolve, 2000)); // Check every 2 seconds

                                // Re-check file size
                                const newFileSize = fs.statSync(videoFilePath).size;
                                const newStatus = await SABnzbd.getDownloadStatus(
                                    streamInfo.config.sabnzbdUrl,
                                    streamInfo.config.sabnzbdApiKey,
                                    nzoId
                                );

                                console.log(`[USENET] ⏳ Extraction progress: ${(newFileSize / 1024 / 1024).toFixed(1)} MB (target: ${(targetSize / 1024 / 1024).toFixed(1)} MB), download: ${newStatus.percentComplete?.toFixed(1)}%`);

                                if (newFileSize >= targetSize) {
                                    console.log(`[USENET] ✓ Extraction caught up! Proceeding with seek to ${seekPercent}%`);
                                    // Update currentFileSize for the redirect
                                    streamInfo.fileSize = Math.max(streamInfo.fileSize, newFileSize);
                                    break;
                                }

                                // Check if download failed
                                if (newStatus.status === 'failed' || newStatus.status === 'error') {
                                    return res.status(500).send(`Download failed: ${newStatus.error || 'Unknown error'}`);
                                }
                            }

                            // If we timed out, send error
                            const finalFileSize = fs.statSync(videoFilePath).size;
                            if (finalFileSize < targetSize) {
                                return res.status(416).send(
                                    `Cannot seek to ${seekPercent}% yet. File extraction is still in progress.\n\n` +
                                    `Requested position: ${(bytePosition / 1024 / 1024).toFixed(1)} MB\n` +
                                    `Extracted so far: ${(finalFileSize / 1024 / 1024).toFixed(1)} MB\n` +
                                    `Download progress: ${status.percentComplete?.toFixed(1)}%\n\n` +
                                    `Please try seeking to a lower position or wait for more of the file to extract.`
                                );
                            }
                        } else {
                            console.log(`[USENET] 🎯 User seeking to ${seekPercent}% (byte ${bytePosition.toLocaleString()}), file has ${(currentFileSize / 1024 / 1024).toFixed(1)} MB extracted, download at ${status.percentComplete?.toFixed(1)}%`);
                        }
                    }
                }
            }

            return res.redirect(302, externalUrl);
        }

        // Store config globally for auto-clean
        if (config.fileServerUrl && config.autoCleanOldFiles) {
            USENET_CONFIGS.set(config.fileServerUrl, config);
        }

        // Get file stats for direct streaming
        const stat = fs.statSync(videoFilePath);
        const isIncomplete = status.status === 'downloading' && sabnzbdConfig?.incompleteDir && videoFilePath.includes(sabnzbdConfig.incompleteDir);

        // Estimate final file size - use SABnzbd total if downloading, otherwise actual size
        let estimatedFileSize = stat.size;
        if (isIncomplete && status.percentComplete && status.percentComplete > 0) {
            // Estimate based on: currentSize / percentExtracted
            const estimateFromProgress = stat.size / (status.percentComplete / 100);

            // Also try using bytesTotal if available
            let estimateFromTotal = stat.size;
            if (status.bytesTotal && status.bytesTotal > stat.size) {
                estimateFromTotal = status.bytesTotal * 0.9;
            }

            // Use the larger of the two estimates (more conservative)
            estimatedFileSize = Math.max(estimateFromProgress, estimateFromTotal, stat.size);

            console.log(`[USENET] File extracting - Current: ${(stat.size / 1024 / 1024).toFixed(1)} MB, Progress: ${status.percentComplete.toFixed(1)}%, Estimated final: ${(estimatedFileSize / 1024 / 1024).toFixed(1)} MB (from progress: ${(estimateFromProgress / 1024 / 1024).toFixed(1)} MB, from total: ${(estimateFromTotal / 1024 / 1024).toFixed(1)} MB)`);
        }

        // Track this stream access
        if (!ACTIVE_USENET_STREAMS.has(nzoId)) {
            let initialPosition = 0;

            // Check if user is starting from a specific position (range request)
            if (req.headers.range) {
                const rangeMatch = req.headers.range.match(/bytes=(\d+)-/);
                if (rangeMatch) {
                    initialPosition = parseInt(rangeMatch[1]);
                    const seekPercent = estimatedFileSize > 0
                        ? (initialPosition / estimatedFileSize * 100).toFixed(1)
                        : '?';
                    console.log(`[USENET] 🎯 User starting at ${seekPercent}% (byte ${initialPosition.toLocaleString()}), download at ${status.percentComplete?.toFixed(1)}%`);
                }
            }

            ACTIVE_USENET_STREAMS.set(nzoId, {
                lastAccess: Date.now(),
                streamCount: 1,
                paused: downloadPaused, // True only if we actually paused SABnzbd
                config: {
                    sabnzbdUrl: config.sabnzbdUrl,
                    sabnzbdApiKey: config.sabnzbdApiKey
                },
                videoFilePath: null, // No file server, so no path needed for cleanup
                usenetConfig: config, // Full config with cleanup options
                fileSize: estimatedFileSize,
                lastPlaybackPosition: initialPosition,
                lastDownloadPercent: status.percentComplete || 0
            });
        } else {
            const streamInfo = ACTIVE_USENET_STREAMS.get(nzoId);
            streamInfo.lastAccess = Date.now();
            streamInfo.streamCount++;

            // Update file size estimate if file is still extracting and we have better info
            if (isBeingExtracted && status.percentComplete && status.percentComplete > 0) {
                // Estimate based on current progress
                const estimateFromProgress = stat.size / (status.percentComplete / 100);

                let estimateFromTotal = stat.size;
                if (status.bytesTotal && status.bytesTotal > stat.size) {
                    estimateFromTotal = status.bytesTotal * 0.9;
                }

                const newEstimate = Math.max(estimateFromProgress, estimateFromTotal, stat.size, streamInfo.fileSize);

                // Log extraction progress
                const extractedPercent = streamInfo.fileSize > 0 ? (stat.size / streamInfo.fileSize * 100) : 0;
                console.log(`[USENET] File extraction: ${(stat.size / 1024 / 1024).toFixed(1)} MB extracted (${extractedPercent.toFixed(1)}%), download at ${status.percentComplete.toFixed(1)}%, estimated final: ${(newEstimate / 1024 / 1024).toFixed(1)} MB`);

                streamInfo.fileSize = newEstimate;
            } else if (!isBeingExtracted && stat.size > streamInfo.fileSize) {
                // File finished extracting, use actual size
                streamInfo.fileSize = stat.size;
            }

            // Update playback position from range header if present
            if (req.headers.range) {
                const rangeMatch = req.headers.range.match(/bytes=(\d+)-/);
                if (rangeMatch) {
                    const bytePosition = parseInt(rangeMatch[1]);
                    streamInfo.lastPlaybackPosition = bytePosition;

                    // Log seek position with actual vs estimated size
                    const seekPercent = streamInfo.fileSize > 0
                        ? (bytePosition / streamInfo.fileSize * 100).toFixed(1)
                        : '?';

                    // Check if seeking beyond extracted range (with 5MB safety buffer)
                    // For MKV files, also check if extraction is far enough for seeking to work
                    const safetyBuffer = 5 * 1024 * 1024; // 5 MB
                    const maxSafePosition = Math.max(0, stat.size - safetyBuffer);

                    // MKV files need index at end - require at least 80% extraction for reliable seeking
                    const isMKV = videoFilePath.toLowerCase().endsWith('.mkv');
                    const extractionPercent = streamInfo.fileSize > 0 ? (stat.size / streamInfo.fileSize * 100) : 0;
                    const mkvSeekThreshold = 80; // Need 80% extracted for MKV seeking

                    if (isMKV && bytePosition > 0 && extractionPercent < mkvSeekThreshold) {
                        console.log(`[USENET] ⚠️ MKV file only ${extractionPercent.toFixed(1)}% extracted - seeking may not work until ${mkvSeekThreshold}% (MKV index usually at end of file)`);
                        return res.status(416).send(
                            `⚠️ Seeking not yet available for this MKV file.\n\n` +
                            `MKV files store their seeking index at the end of the file.\n` +
                            `Extraction progress: ${extractionPercent.toFixed(1)}%\n` +
                            `Seeking available at: ${mkvSeekThreshold}%\n` +
                            `Download progress: ${status.percentComplete?.toFixed(1)}%\n\n` +
                            `Please start from the beginning or wait for more extraction.\n` +
                            `The video will play normally from the start.`
                        );
                    }

                    if (isBeingExtracted && bytePosition >= maxSafePosition) {
                        const extractedPercent = streamInfo.fileSize > 0 ? (stat.size / streamInfo.fileSize * 100) : 0;
                        const targetSize = bytePosition + (10 * 1024 * 1024); // Need 10MB past seek point
                        const waitMessage = bytePosition >= stat.size
                            ? `Seeking beyond extracted range (${(bytePosition / 1024 / 1024).toFixed(1)} MB requested, only ${(stat.size / 1024 / 1024).toFixed(1)} MB extracted)`
                            : `Seeking too close to extraction edge (${(stat.size - bytePosition) / 1024 / 1024} MB buffer)`;

                        console.log(`[USENET] ⚠️ ${waitMessage}. Waiting for extraction to reach ${(targetSize / 1024 / 1024).toFixed(1)} MB...`);

                        // Wait for extraction to catch up
                        const maxWaitTime = 2 * 60 * 1000; // 2 minutes max
                        const startWait = Date.now();

                        while (Date.now() - startWait < maxWaitTime) {
                            await new Promise(resolve => setTimeout(resolve, 2000)); // Check every 2 seconds

                            // Re-check file size
                            const newFileStat = fs.statSync(videoFilePath);
                            const newStatus = await SABnzbd.getDownloadStatus(config.sabnzbdUrl, config.sabnzbdApiKey, nzoId);

                            console.log(`[USENET] ⏳ Extraction progress: ${(newFileStat.size / 1024 / 1024).toFixed(1)} MB (target: ${(targetSize / 1024 / 1024).toFixed(1)} MB), download: ${newStatus.percentComplete?.toFixed(1)}%`);

                            if (newFileStat.size >= targetSize) {
                                console.log(`[USENET] ✓ Extraction caught up! Proceeding with seek to ${seekPercent}%`);
                                // Update for streaming
                                streamInfo.fileSize = Math.max(streamInfo.fileSize, newFileStat.size);
                                break;
                            }

                            // Check if download failed
                            if (newStatus.status === 'failed' || newStatus.status === 'error') {
                                return res.status(500).send(`Download failed: ${newStatus.error || 'Unknown error'}`);
                            }
                        }

                        // If we timed out, send error
                        const finalFileStat = fs.statSync(videoFilePath);
                        if (finalFileStat.size < targetSize) {
                            return res.status(416).send(
                                `Cannot seek to ${seekPercent}% yet. File extraction is still in progress.\n\n` +
                                `Requested position: ${(bytePosition / 1024 / 1024).toFixed(1)} MB\n` +
                                `Extracted so far: ${(finalFileStat.size / 1024 / 1024).toFixed(1)} MB\n` +
                                `Download progress: ${status.percentComplete?.toFixed(1)}%\n\n` +
                                `Please try seeking to a lower position or wait for more of the file to extract.`
                            );
                        }
                    } else {
                        console.log(`[USENET] 🎯 User seeking to ${seekPercent}% (byte ${bytePosition.toLocaleString()}), file has ${(stat.size / 1024 / 1024).toFixed(1)} MB extracted, download at ${status.percentComplete?.toFixed(1)}%`);
                    }
                }
            }
        }

        // Handle range requests for seeking
        const range = req.headers.range;
        let fileSize = estimatedFileSize;

        console.log(`[USENET] File info - Size: ${(fileSize / 1024 / 1024).toFixed(2)} MB, Being extracted: ${isBeingExtracted}`);

        if (range) {
            const parts = range.replace(/bytes=/, '').split('-');
            const start = parseInt(parts[0], 10);
            let end = parts[1] ? parseInt(parts[1], 10) : stat.size - 1;

            // Clamp end to actual file size on disk
            end = Math.min(end, stat.size - 1);

            console.log(`[USENET] Range request: ${start}-${end}, File size: ${stat.size}`);

            // Check if requested range is beyond what's available
            if (start >= stat.size) {
                // Range not yet available - wait for it if file is still being extracted
                if (isBeingExtracted || status.status === 'downloading') {
                    console.log(`[USENET] Range ${start}-${end} not yet available, file size: ${stat.size} bytes`);

                    // Wait up to 60 seconds for the file to grow
                    const maxWait = 60000;
                    const startWait = Date.now();
                    const pollInterval = 2000;

                    while (Date.now() - startWait < maxWait) {
                        await new Promise(resolve => setTimeout(resolve, pollInterval));

                        // Re-check file size again
                        const newStat = fs.statSync(videoFilePath);
                        console.log(`[USENET] Waiting for file to grow... Current size: ${(newStat.size / 1024 / 1024).toFixed(2)} MB`);

                        if (start < newStat.size) {
                            // Range is now available
                            const newEnd = Math.min(end, newStat.size - 1);
                            const chunksize = (newEnd - start) + 1;
                            const file = fs.createReadStream(videoFilePath, { start, end: newEnd });

                            const headers = {
                                'Content-Range': `bytes ${start}-${newEnd}/${newStat.size}`,
                                'Accept-Ranges': 'bytes',
                                'Content-Length': chunksize,
                                'Content-Type': 'video/mp4',
                                'Cache-Control': 'no-cache',
                            };

                            console.log(`[USENET] Range now available: ${start}-${newEnd}/${newStat.size}`);
                            res.writeHead(206, headers);
                            return file.pipe(res);
                        }
                    }

                    // Timeout waiting
                    return res.status(416).send(
                        `Requested position not yet available. ` +
                        `File is still being extracted. Please try again in a moment.`
                    );
                } else {
                    return res.status(416).send('Requested range not available.');
                }
            }

            const chunksize = (end - start) + 1;
            const file = fs.createReadStream(videoFilePath, { start, end });

            const headers = {
                'Content-Range': `bytes ${start}-${end}/${stat.size}`,
                'Accept-Ranges': 'bytes',
                'Content-Length': chunksize,
                'Content-Type': 'video/mp4',
                'Cache-Control': 'no-cache',
            };

            res.writeHead(206, headers);
            file.pipe(res);

            // Log seek operation
            if (start > 0) {
                console.log(`[USENET] Serving range: ${start}-${end}/${stat.size} (${(start / stat.size * 100).toFixed(1)}% into file)`);
            }
        } else {
            // No range, stream from beginning
            const headers = {
                'Content-Length': stat.size,
                'Content-Type': 'video/mp4',
                'Accept-Ranges': 'bytes',
                'Cache-Control': 'no-cache',
            };

            console.log(`[USENET] Streaming from beginning, file size: ${(stat.size / 1024 / 1024).toFixed(2)} MB`);
            res.writeHead(200, headers);
            fs.createReadStream(videoFilePath).pipe(res);
        }

        // Monitor download progress in background
        if (status.status === 'downloading') {
            console.log(`[USENET] Streaming while downloading: ${status.percentComplete?.toFixed(1)}% complete`);
        }

    } catch (error) {
        console.error('[USENET] Streaming error:', error.message);
        if (error.stack) console.error(error.stack);
        res.status(500).send(`Error: ${error.message}`);
    }
});

app.use((req, res, next) => {
    if (['/', '/configure', '/manifest-no-catalogs.json'].includes(req.path) || req.path.startsWith('/resolve/') || req.path.startsWith('/usenet/') || req.path.startsWith('/admin/')) {
        return next();
    }
    serverless(req, res, next);
});

function applyHttpServerTuning(serverInstance) {
    if (!serverInstance) return;

    try {
        serverInstance.keepAliveTimeout = parseInt(process.env.HTTP_KEEPALIVE_TIMEOUT || "65000", 10);
        serverInstance.headersTimeout = parseInt(process.env.HTTP_HEADERS_TIMEOUT || "72000", 10);
        serverInstance.timeout = parseInt(process.env.HTTP_TIMEOUT || "120000", 10); // 2 minutes default
        serverInstance.maxHeadersCount = parseInt(process.env.HTTP_MAX_HEADERS_COUNT || "50", 10);
        serverInstance.maxConnections = parseInt(process.env.HTTP_MAX_CONNECTIONS || "500", 10);

        console.log(`[SERVER] HTTP Configuration: maxConnections=${serverInstance.maxConnections}, keepAliveTimeout=${serverInstance.keepAliveTimeout}ms, timeout=${serverInstance.timeout}ms`);
    } catch (error) {
        console.error(`[SERVER] HTTP tuning failed: ${error.message}`);
    }
}

const HOST = process.env.HOST || '0.0.0.0';
const PORT = process.env.PORT || 7000;  // Consistent port definition

let server = null;

/**
 * Run HTTP streams health check in background on startup
 * Generates status report to /http-streams-status and /http-streams-status.json
 */
function runHealthCheckOnStartup() {
    // Run in background using spawn to avoid blocking
    const __filename = fileURLToPath(import.meta.url);
    const healthCheckScript = path.join(path.dirname(__filename), 'scripts', 'test-http-streams-status.mjs');

    const child = spawn('node', [healthCheckScript], {
        detached: true,
        stdio: ['ignore', 'pipe', 'pipe']
    });

    // Log health check progress
    let output = '';
    child.stdout?.on('data', (data) => {
        const lines = data.toString().split('\n').filter(l => l.includes('[HTTP-HEALTH]'));
        if (lines.length > 0) {
            console.log('[STARTUP] Health check:', lines[0]);
            output += data;
        }
    });

    child.stderr?.on('data', (data) => {
        const str = data.toString();
        if (str.includes('[HTTP-HEALTH]')) {
            console.log('[STARTUP] Health check:', str.trim());
        }
    });

    // Don't wait for it, let it run in background
    child.unref();

    console.log('[STARTUP] HTTP streams health check started in background');
}

const HTTP_STREAMS_STARTUP_HEALTHCHECK_ENABLED = process.env.HTTP_STREAMS_STARTUP_HEALTHCHECK_ENABLED !== 'false';
const shouldRunStartupHealthCheck = HTTP_STREAMS_STARTUP_HEALTHCHECK_ENABLED && (!cluster.isWorker || cluster.worker?.id === 1);

// Check if we're running directly (not being imported by cluster)
// For standalone mode, start the server directly
if (import.meta.url === `file://${__filename}`) {
    // Start memory monitoring before server starts
    memoryMonitor.setThresholdHandler(() => {
        const cacheStats = {
            streamProvider: streamProvider.getCacheStats?.(),
            searchCoordinator: searchCoordinator.getStats?.(),
            personalFiles: personalFilesCache.getStats?.()
        };
        console.error(`[MEMORY] Cache stats snapshot: ${JSON.stringify(cacheStats)}`);

        streamProvider.clearInternalCaches?.('memory-pressure');
        searchCoordinator.clearCaches?.('memory-pressure');
        personalFilesCache.clear?.();

        if (global.gc) {
            console.error('[MEMORY] Triggering garbage collection');
            global.gc();
        }
    });
    memoryMonitor.startMonitoring();

    server = app.listen(PORT, HOST, () => {
        console.log('HTTP server listening on port: ' + server.address().port);
        if (shouldRunStartupHealthCheck) {
            // Run HTTP streams health check in background on startup
            runHealthCheckOnStartup();
        } else {
            console.log('[STARTUP] HTTP streams health check skipped');
        }
    });
    applyHttpServerTuning(server);
    
    // Handle graceful shutdown for standalone mode
    process.on('SIGINT', () => {
        console.log('\nShutting down standalone server...');
        memoryMonitor.stopMonitoring(); // Stop memory monitoring
        server.close(() => {
            console.log('Server closed');
            process.exit(0);
        });
    });

    process.on('SIGTERM', () => {
        console.log('Received SIGTERM, shutting down gracefully...');
        memoryMonitor.stopMonitoring(); // Stop memory monitoring
        server.close(() => {
            console.log('Server closed');
            process.exit(0);
        });
    });
}

// Export for cluster usage
export { app, server, PORT, HOST };

if (sqliteCache?.isEnabled()) {
    sqliteCache.initSqlite().then(() => {
        console.log(`[CACHE] ${cacheBackendLabel} cache initialized`);
    }).catch(err => {
        console.error(`[CACHE] ${cacheBackendLabel} init failed:`, err?.message || err);
    });
}

if (sqliteHashCache?.isEnabled()) {
    sqliteHashCache.initCleanup().then(() => {
        console.log(`[HASH-CACHE] ${cacheBackendLabel} hash cache cleanup initialized`);
    }).catch(err => {
        console.error(`[HASH-CACHE] ${cacheBackendLabel} hash cache init failed:`, err?.message || err);
    });
}