main.cjs

const { app, BrowserWindow, ipcMain, net } = require('electron/main');
const path = require('node:path');
const fs = require('node:fs');
const { getMpvBinaryPath } = require('./src/mpv-path');
const { mpvController } = require('./src/mpv-controller');
const { getDisplayContext } = require('./src/display-detector');
const { parseTorrentMetadata, parseTorrentName, sortTorrentsByQuality } = require('./src/torrent-metadata');
const { computeAdvisoryScore, computeAdvisoryScores, enrichTorrentsWithAdvisory } = require('./src/advisory-scorer');
const { selectTorrent } = require('./src/llm-torrent-selector');

// Load .env into process.env (main process only)
try {
  const envPath = path.join(__dirname, '.env');
  if (fs.existsSync(envPath)) {
    const content = fs.readFileSync(envPath, 'utf8');
    for (const line of content.split('\n')) {
      const m = line.match(/^\s*([^#=]+)=(.*)$/);
      if (m) process.env[m[1].trim()] = m[2].trim().replace(/^["']|["']$/g, '');
    }
  }
} catch (_) {}

let mainWindow = null;
let wtClient = null;
let wtServer = null;
let serverBaseUrl = null;
let currentTorrent = null;
let progressInterval = null;
let downloadsUpdateInterval = null;

const VIDEO_EXTENSIONS = ['.mp4', '.mkv', '.webm', '.avi', '.mov'];
const TORRENT_READY_TIMEOUT = 60000; // 60 seconds to wait for torrent metadata

// ─────────────────────────────────────────────────────────────────────────────
// Download Manager - State & Persistence
// ─────────────────────────────────────────────────────────────────────────────

// Active torrents being downloaded/seeded: Map<infoHash, { torrent, meta, status }>
const activeTorrents = new Map();

// Persisted download data
let downloadsData = {}; // { [infoHash]: { title, subtitle, thumbnail, progress, status, ... } }
let appSettings = { seedRatio: 1.0 };

// Paths for persistence
let appDataDir = null;
let downloadsDir = null;
let settingsPath = null;
let downloadsDataPath = null;

function ensureAppDataDirs() {
  appDataDir = path.join(app.getPath('userData'), 'FuckNetflix');
  downloadsDir = path.join(app.getPath('downloads'), 'FuckNetflix');
  settingsPath = path.join(appDataDir, 'settings.json');
  downloadsDataPath = path.join(appDataDir, 'downloads.json');

  // Create directories if they don't exist
  if (!fs.existsSync(appDataDir)) {
    fs.mkdirSync(appDataDir, { recursive: true });
  }
  if (!fs.existsSync(downloadsDir)) {
    fs.mkdirSync(downloadsDir, { recursive: true });
  }
}

function loadSettings() {
  try {
    if (fs.existsSync(settingsPath)) {
      const data = fs.readFileSync(settingsPath, 'utf8');
      appSettings = { ...appSettings, ...JSON.parse(data) };
    }
  } catch (_) {
    // Use defaults
  }
}

function saveSettings() {
  try {
    fs.writeFileSync(settingsPath, JSON.stringify(appSettings, null, 2));
  } catch (_) {
    // Ignore write errors
  }
}

function loadDownloadsData() {
  try {
    if (fs.existsSync(downloadsDataPath)) {
      const data = fs.readFileSync(downloadsDataPath, 'utf8');
      downloadsData = JSON.parse(data);
    }
  } catch (_) {
    downloadsData = {};
  }
}

function saveDownloadsData() {
  try {
    fs.writeFileSync(downloadsDataPath, JSON.stringify(downloadsData, null, 2));
  } catch (_) {
    // Ignore write errors
  }
}

function updateDownloadData(infoHash, updates) {
  if (!downloadsData[infoHash]) {
    downloadsData[infoHash] = {};
  }
  Object.assign(downloadsData[infoHash], updates);
  saveDownloadsData();
}

function getDownloadsList() {
  const list = [];
  
  // Add active torrents
  for (const [infoHash, active] of activeTorrents) {
    const t = active.torrent;
    const meta = active.meta || {};
    const isPaused = active.status === 'paused';
    const isSeeding = t.progress >= 1 && !isPaused;
    
    list.push({
      infoHash,
      title: meta.title || t.name || 'Unknown',
      subtitle: meta.subtitle || '',
      thumbnail: meta.thumbnail || null,
      status: isPaused ? 'paused' : isSeeding ? 'seeding' : 'downloading',
      progress: t.progress,
      downloaded: t.downloaded,
      uploaded: t.uploaded,
      length: t.length,
      downloadSpeed: t.downloadSpeed,
      uploadSpeed: t.uploadSpeed,
      seedRatio: t.downloaded > 0 ? t.uploaded / t.downloaded : 0,
      numPeers: t.numPeers,
    });
  }
  
  // Add completed downloads from persisted data (not currently active)
  for (const [infoHash, data] of Object.entries(downloadsData)) {
    if (!activeTorrents.has(infoHash) && data.status === 'completed') {
      list.push({
        infoHash,
        title: data.title || 'Unknown',
        subtitle: data.subtitle || '',
        thumbnail: data.thumbnail || null,
        status: 'completed',
        progress: 1,
        downloaded: data.downloaded || 0,
        uploaded: data.uploaded || 0,
        length: data.length || 0,
        downloadSpeed: 0,
        uploadSpeed: 0,
        filePath: data.filePath || null,
      });
    }
  }
  
  return list;
}

function sendDownloadsUpdate() {
  if (mainWindow && !mainWindow.isDestroyed()) {
    mainWindow.webContents.send('downloads-update', getDownloadsList());
  }
}

/**
 * Resume incomplete downloads from persisted data on app startup.
 * Re-adds magnets to WebTorrent for downloads that were in progress.
 */
async function resumeIncompleteDownloads() {
  if (!wtClient || !downloadsDir) return;

  for (const [infoHash, data] of Object.entries(downloadsData)) {
    // Skip completed downloads or those without a magnet
    if (data.status === 'completed' || !data.magnet) continue;
    
    // Skip if already active (shouldn't happen on startup, but safety check)
    if (activeTorrents.has(infoHash)) continue;

    try {
      // Re-add the torrent to WebTorrent
      const torrent = wtClient.add(data.magnet, { path: downloadsDir }, (t) => {
        const file = pickVideoFile(t.files);
        if (!file) {
          t.destroy();
          return;
        }

        // Track this resumed download
        activeTorrents.set(t.infoHash, {
          torrent: t,
          meta: {
            title: data.title,
            subtitle: data.subtitle,
            thumbnail: data.thumbnail,
          },
          status: t.progress >= 1 ? 'seeding' : 'downloading',
        });

        // Update persisted data with resumed status
        updateDownloadData(t.infoHash, {
          status: t.progress >= 1 ? 'completed' : 'downloading',
        });

        // Handle completion
        t.on('done', () => {
          const active = activeTorrents.get(t.infoHash);
          if (active) {
            active.status = 'seeding';
          }
          updateDownloadData(t.infoHash, {
            status: 'completed',
            completedAt: Date.now(),
            filePath: path.join(downloadsDir, file.path),
            downloaded: t.downloaded,
            length: t.length,
          });
          sendDownloadsUpdate();
          checkSeedRatio(t);
        });

        // Track upload progress for seed ratio
        t.on('upload', () => {
          checkSeedRatio(t);
        });

        sendDownloadsUpdate();
      });

      // Handle torrent-level errors (e.g., invalid magnet, network issues)
      if (torrent && typeof torrent.on === 'function') {
        torrent.on('error', (err) => {
          console.error(`Failed to resume download ${infoHash}:`, err.message);
          // Remove from active torrents on error
          activeTorrents.delete(infoHash);
          sendDownloadsUpdate();
        });
      }
    } catch (err) {
      console.error(`Error resuming download ${infoHash}:`, err.message);
    }
  }
}

function startDownloadsUpdateInterval() {
  stopDownloadsUpdateInterval();
  downloadsUpdateInterval = setInterval(sendDownloadsUpdate, 1000);
}

function stopDownloadsUpdateInterval() {
  if (downloadsUpdateInterval) {
    clearInterval(downloadsUpdateInterval);
    downloadsUpdateInterval = null;
  }
}

const YTS_TRACKERS = [
  'udp://open.demonii.com:1337/announce',
  'udp://tracker.openbittorrent.com:80',
  'udp://tracker.coppersurfer.tk:6969',
  'udp://glotorrents.pw:6969/announce',
  'udp://tracker.opentrackr.org:1337/announce',
  'udp://torrent.gresille.org:80/announce',
  'udp://p4p.arenabg.com:1337',
  'udp://tracker.leechers-paradise.org:6969',
];

function buildYtsMagnet(hash, title) {
  const dn = encodeURIComponent(title || 'movie');
  const tr = YTS_TRACKERS.map((t) => 'tr=' + encodeURI(t)).join('&');
  return `magnet:?xt=urn:btih:${hash}&dn=${dn}&${tr}`;
}

const API_HEADERS = {
  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; rv:109.0) Gecko/20100101 Firefox/115.0',
  Accept: 'application/json',
};

const YTS_BASE_URLS = [
  'https://yts.mx',
  'https://yts.lt',
  'https://yts.ag',
  'https://yts.am',
  'https://yts.gg',
  'https://yts.bz',
];

async function netFetchJson(url) {
  const res = await net.fetch(url, { headers: API_HEADERS });
  if (!res.ok) throw new Error(`Request failed: ${res.status}`);
  return res.json();
}

/**
 * Wrapper for network requests with retry logic and exponential backoff
 * @param {function} fetchFn - Async function that performs the fetch
 * @param {object} options - Retry options
 * @param {number} options.maxRetries - Maximum number of retry attempts (default: 3)
 * @param {number} options.baseDelay - Base delay in ms for exponential backoff (default: 1000)
 * @param {number} options.maxDelay - Maximum delay between retries (default: 10000)
 * @param {function} options.onRetry - Callback called before each retry (attempt, maxRetries, error)
 * @param {function} options.shouldRetry - Function to determine if error is retryable (default: true for network errors)
 * @returns {Promise<any>} - Result of the fetch function
 */
async function fetchWithRetry(fetchFn, options = {}) {
  const {
    maxRetries = 3,
    baseDelay = 1000,
    maxDelay = 10000,
    onRetry = null,
    shouldRetry = (err) => {
      // Retry on network errors, timeouts, and 5xx server errors
      const message = err.message || '';
      return (
        message.includes('fetch') ||
        message.includes('network') ||
        message.includes('ECONNREFUSED') ||
        message.includes('ETIMEDOUT') ||
        message.includes('ENOTFOUND') ||
        message.includes('timeout') ||
        message.includes('aborted') ||
        /Request failed: 5\d\d/.test(message)
      );
    },
  } = options;

  let lastError;

  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await fetchFn();
    } catch (err) {
      lastError = err;

      // Check if we should retry this error
      if (!shouldRetry(err) || attempt >= maxRetries) {
        break;
      }

      // Calculate delay with exponential backoff and jitter
      const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
      const jitter = Math.random() * 0.3 * exponentialDelay; // 0-30% jitter
      const delay = Math.min(exponentialDelay + jitter, maxDelay);

      // Notify about retry
      if (onRetry) {
        onRetry(attempt, maxRetries, err);
      }

      // Wait before retrying
      await new Promise((resolve) => setTimeout(resolve, delay));
    }
  }

  // Enhance error message for common network issues
  if (lastError) {
    const message = lastError.message || '';
    if (message.includes('ENOTFOUND') || message.includes('ECONNREFUSED')) {
      lastError.userMessage = 'Unable to connect. Please check your internet connection.';
      lastError.isNetworkError = true;
    } else if (message.includes('timeout') || message.includes('aborted')) {
      lastError.userMessage = 'Request timed out. The server may be slow or unreachable.';
      lastError.isNetworkError = true;
    } else if (/Request failed: 5\d\d/.test(message)) {
      lastError.userMessage = 'Server temporarily unavailable. Please try again later.';
      lastError.isNetworkError = true;
    }
  }

  throw lastError;
}

/**
 * Check if the system appears to be offline
 * @returns {boolean}
 */
function isOfflineError(err) {
  const message = (err?.message || '').toLowerCase();
  return (
    message.includes('enotfound') ||
    message.includes('econnrefused') ||
    message.includes('network') ||
    message.includes('offline')
  );
}

async function ytsFetch(path) {
  let lastErr = null;
  
  // Try each YTS mirror with retry logic
  for (const base of YTS_BASE_URLS) {
    try {
      const data = await fetchWithRetry(
        async () => {
          const url = base + path;
          return await netFetchJson(url);
        },
        {
          maxRetries: 2, // Quick retries per mirror before moving to next
          baseDelay: 500,
          maxDelay: 2000,
        }
      );
      
      if (data.status === 'ok') return data;
      lastErr = new Error(data.status_message || 'YTS error');
    } catch (err) {
      lastErr = err;
      // Continue to next mirror
    }
  }
  
  // Enhance error message for user
  if (lastErr) {
    if (isOfflineError(lastErr)) {
      lastErr.userMessage = 'Unable to reach movie database. Please check your internet connection.';
    } else {
      lastErr.userMessage = 'Movie database temporarily unavailable. Please try again.';
    }
    lastErr.isNetworkError = true;
  }
  
  throw lastErr || new Error('YTS unreachable');
}

async function searchMovies(query) {
  const q = encodeURIComponent(String(query).trim());
  const path = `/api/v2/list_movies.json?query_term=${q}&limit=20`;
  const data = await ytsFetch(path);
  const movies = data.data?.movies ?? [];
  return movies.map((m) => ({
    id: m.id,
    title: m.title ?? m.title_long ?? '',
    year: m.year,
    rating: m.rating,
    cover: m.medium_cover_image || m.small_cover_image,
  }));
}

async function getMovieDetails(movieId) {
  const path = `/api/v2/movie_details.json?movie_id=${movieId}`;
  const data = await ytsFetch(path);
  return data.data?.movie ?? null;
}

function pickMovieTorrent(torrents) {
  if (!torrents?.length) return null;
  const preferred = torrents.find((t) => (t.quality || '').toLowerCase() === '720p');
  return preferred || torrents[0];
}

/**
 * Pick the best torrent from YTS results using LLM with fallback
 * @param {Array} torrents - Array of YTS torrent objects
 * @param {string} title - Movie title for context
 * @returns {Promise<object|null>} Selected torrent or null
 */
async function pickMovieTorrentWithLlm(torrents, title) {
  if (!torrents?.length) return null;
  
  try {
    // Convert YTS format to unified format for LLM
    const unifiedTorrents = torrents.map((t) => ({
      title: `${title} ${t.quality} ${t.type || ''}`.trim(),
      seeders: t.seeds || 0,
      peers: t.peers || 0,
      size: t.size || 'Unknown',
      quality: t.quality,
      hash: t.hash,
    }));
    
    const selection = await selectTorrent(unifiedTorrents, { title });
    
    if (selection && selection.selectedIndex >= 0 && selection.selectedIndex < torrents.length) {
      console.log('[LLM Selection YTS]', selection.reasoning);
      return torrents[selection.selectedIndex];
    }
    
    // Fall back to heuristic
    return pickMovieTorrent(torrents);
  } catch (error) {
    console.error('[LLM] YTS selection failed, using fallback:', error.message);
    return pickMovieTorrent(torrents);
  }
}

async function searchTvShows(query) {
  const q = encodeURIComponent(String(query).trim());
  const url = `https://api.tvmaze.com/search/shows?q=${q}`;
  const list = await netFetchJson(url);
  return (list || []).map((item) => {
    const show = item.show || item;
    const imdb = show.externals?.imdb || null;
    return {
      id: show.id,
      name: show.name || '',
      imdbId: imdb ? imdb.replace(/^tt/, '') : null,
      image: show.image?.medium || show.image?.original,
    };
  });
}

async function getEztvTorrents(imdbId) {
  const id = String(imdbId).replace(/^tt/, '');
  const url = `https://eztvx.to/api/get-torrents?imdb_id=${id}&limit=100`;
  const data = await netFetchJson(url);
  const torrents = data.torrents ?? [];
  return torrents.map((t) => ({
    id: t.id,
    title: t.title || t.filename || '',
    season: t.season,
    episode: t.episode,
    magnetUrl: t.magnet_url,
    seeds: t.seeds,
    peers: t.peers,
  }));
}

// ─────────────────────────────────────────────────────────────────────────────
// Unified Torrent API (Torrent-API-Py) - aggregates multiple torrent sites
// Supported: 1337x, tgx (Torrent Galaxy), piratebay, kickass, limetorrent,
//            torrentfunk, glodls, bitsearch, magnetdl, torlock, yts, nyaasi
//
// IMPORTANT: Only 1337x supports search_by_category=true!
// Other sites have categories for recent/trending only, NOT for search.
// See: https://github.com/Ryuk-me/Torrent-Api-py#supported-methods-and-categories
// ─────────────────────────────────────────────────────────────────────────────
const TORRENT_API_BASE = 'https://torrent-api-py-nx0x.onrender.com';
const TORRENT_API_TIMEOUT = 8000; // 8 seconds per request

// Sites that support search_by_category (can use /api/v1/category endpoint)
const CATEGORY_SEARCH_SITES = ['1337x'];

// General search sites (use /api/v1/search endpoint - no category filtering)
// These sites work well but don't support category-filtered search
const GENERAL_SITES = ['tgx', 'piratebay', 'kickass', 'limetorrent', 'torrentfunk', 'magnetdl', 'torlock', 'bitsearch', 'glodls'];

/**
 * Search a single site on the unified torrent API.
 * @param {string} site - Site name (e.g. '1337x', 'tgx', 'piratebay')
 * @param {string} query - Search query
 * @param {object} options - { category?: string, limit?: number }
 * @returns {Promise<Array>}
 */
async function searchSingleSite(site, query, options = {}) {
  const { category, limit = 15 } = options;
  const q = encodeURIComponent(String(query).trim());
  if (!q) return [];

  let url;
  if (category) {
    // Use category endpoint for better filtering
    url = `${TORRENT_API_BASE}/api/v1/category?site=${site}&query=${q}&category=${category}&limit=${limit}`;
  } else {
    url = `${TORRENT_API_BASE}/api/v1/search?site=${site}&query=${q}&limit=${limit}`;
  }

  try {
    // Use fetchWithRetry for resilience against transient failures
    const result = await fetchWithRetry(
      async () => {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), TORRENT_API_TIMEOUT);

        try {
          const res = await net.fetch(url, {
            headers: API_HEADERS,
            signal: controller.signal,
          });

          if (!res.ok) {
            throw new Error(`Request failed: ${res.status}`);
          }
          return await res.json();
        } finally {
          clearTimeout(timeoutId);
        }
      },
      {
        maxRetries: 2,
        baseDelay: 500,
        maxDelay: 2000,
        // Only retry on network/timeout errors, not on 4xx responses
        shouldRetry: (err) => {
          const msg = err.message || '';
          return msg.includes('aborted') || msg.includes('timeout') || 
                 msg.includes('ECONNREFUSED') || msg.includes('ETIMEDOUT') ||
                 /Request failed: 5\d\d/.test(msg);
        },
      }
    );

    const data = result.data ?? [];
    return data
      .filter((t) => t.magnet)
      .map((t) => ({
        magnet: t.magnet,
        title: t.name || t.title || '',
        seeders: parseInt(t.seeders, 10) || 0,
        size: t.size || '',
        source: site,
      }));
  } catch (_) {
    // Return empty array on failure - parallel searches will continue
    return [];
  }
}

/**
 * Search multiple sites in parallel for movies.
 * @param {string} query - Movie title (optionally with year)
 * @param {number} limit - Results per site
 * @returns {Promise<Array>}
 */
async function searchMovieSources(query, limit = 10) {
  const searches = [
    // Category-filtered searches (only 1337x supports this)
    ...CATEGORY_SEARCH_SITES.map((site) => searchSingleSite(site, query, { category: 'movies', limit })),
    // General searches (all other sites - no category filtering available)
    ...GENERAL_SITES.map((site) => searchSingleSite(site, query, { limit })),
  ];

  const results = await Promise.all(searches);
  return results.flat();
}

/**
 * Search multiple sites in parallel for TV shows.
 * @param {string} query - Show name or "ShowName S01E05"
 * @param {number} limit - Results per site
 * @returns {Promise<Array>}
 */
async function searchTvSources(query, limit = 15) {
  const searches = [
    // Category-filtered searches (only 1337x supports this)
    ...CATEGORY_SEARCH_SITES.map((site) => searchSingleSite(site, query, { category: 'tv', limit })),
    // General searches (all other sites - no category filtering available)
    ...GENERAL_SITES.map((site) => searchSingleSite(site, query, { limit })),
  ];

  const results = await Promise.all(searches);
  return results.flat();
}

/**
 * Legacy function for backward compatibility - searches all sites.
 * @param {string} query - Search query
 * @param {object} options - { site?: string, limit?: number }
 * @returns {Promise<Array>}
 */
async function searchUnifiedApi(query, options = {}) {
  const { site, limit = 10 } = options;
  if (site) {
    return searchSingleSite(site, query, { limit });
  }
  // Search all sites in parallel
  const allSites = [...new Set([...CATEGORY_SEARCH_SITES, ...GENERAL_SITES])];
  const searches = allSites.map((s) => searchSingleSite(s, query, { limit: Math.ceil(limit / 2) }));
  const results = await Promise.all(searches);
  return results.flat();
}

/**
 * Pick the best torrent from results for a movie.
 * Prefers 1080p > 720p > highest seeders, with minimum seeder threshold.
 * @param {Array} results - Array of torrent results
 * @returns {object|null}
 */
function pickBestUnifiedTorrent(results) {
  if (!results?.length) return null;

  // Filter out very low seeder torrents (likely dead)
  const viable = results.filter((t) => t.seeders >= 1);
  if (!viable.length) return results[0]; // Fall back to any result

  // Prefer 1080p with good seeds
  const hd1080 = viable.filter((t) => /1080p/i.test(t.title));
  if (hd1080.length) {
    return hd1080.reduce((best, curr) => (curr.seeders > (best?.seeders || 0) ? curr : best), null);
  }

  // Then 720p
  const hd720 = viable.filter((t) => /720p/i.test(t.title));
  if (hd720.length) {
    return hd720.reduce((best, curr) => (curr.seeders > (best?.seeders || 0) ? curr : best), null);
  }

  // Otherwise highest seeders
  return viable.reduce((best, curr) => (curr.seeders > (best?.seeders || 0) ? curr : best), null);
}

/**
 * Pick the best torrent using LLM with fallback to heuristic method
 * @param {Array} results - Array of torrent results
 * @param {object} options - Selection options (title, contentType)
 * @returns {Promise<object|null>} Selected torrent or null
 */
async function pickBestTorrentWithLlm(results, options = {}) {
  if (!results?.length) return null;
  
  try {
    // Try LLM selection first
    const selection = await selectTorrent(results, options);
    
    // Check if LLM returned a valid selection
    if (selection && selection.selectedIndex >= 0 && selection.selectedIndex < results.length) {
      console.log('[LLM Selection]', selection.reasoning);
      if (selection.warnings?.length > 0) {
        console.log('[LLM Warnings]', selection.warnings);
      }
      return results[selection.selectedIndex];
    }
    
    // LLM returned -1 or invalid index, fall back to heuristic
    console.log('[LLM] No suitable torrent selected, using fallback heuristic');
    return pickBestUnifiedTorrent(results);
  } catch (error) {
    // LLM failed, fall back to heuristic
    console.error('[LLM] Selection failed, using fallback heuristic:', error.message);
    return pickBestUnifiedTorrent(results);
  }
}

/**
 * Parse season/episode from a torrent title (e.g. "Show.Name.S01E05.720p")
 * Also handles formats like "1x05", "Season 1 Episode 5"
 * @param {string} title
 * @returns {{season: number, episode: number}|null}
 */
function parseSeasonEpisode(title) {
  // Standard S01E05 format
  let match = title.match(/S(\d{1,2})E(\d{1,2})/i);
  if (match) {
    return { season: parseInt(match[1], 10), episode: parseInt(match[2], 10) };
  }
  // Alternative 1x05 format
  match = title.match(/(\d{1,2})x(\d{1,2})/i);
  if (match) {
    return { season: parseInt(match[1], 10), episode: parseInt(match[2], 10) };
  }
  // "Season 1 Episode 5" format
  match = title.match(/Season\s*(\d{1,2}).*Episode\s*(\d{1,2})/i);
  if (match) {
    return { season: parseInt(match[1], 10), episode: parseInt(match[2], 10) };
  }
  return null;
}

// OpenSubtitles REST API
const OPENSUBTITLES_BASE = 'https://api.opensubtitles.com/api/v1';

function openSubtitlesHeaders() {
  const key = process.env.open_subtitles_api_key || '';
  return {
    'Api-Key': key,
    'User-Agent': 'FuckNetflix/1.0',
    Accept: 'application/json',
    'Content-Type': 'application/json',
  };
}

async function openSubtitlesSearch(meta) {
  if (!meta || typeof meta !== 'object') return { error: 'No metadata provided for subtitle search.' };
  const key = process.env.open_subtitles_api_key;
  if (!key) return { error: 'OpenSubtitles API key not set (open_subtitles_api_key in .env).' };

  const params = new URLSearchParams();
  params.set('languages', 'en');
  params.set('order_by', 'download_count');
  if (meta.imdbId) {
    const id = String(meta.imdbId).replace(/^tt/, '').replace(/\D/g, '');
    if (id) params.set('imdb_id', id.padStart(7, '0'));
  }
  if (!params.has('imdb_id') && meta.title) {
    const q = meta.year ? `${meta.title} ${meta.year}` : meta.title;
    params.set('query', q);
  }
  if (!params.has('imdb_id') && !params.has('query')) {
    return { error: 'Need imdbId or title to search subtitles.' };
  }
  if (meta.type === 'episode') {
    params.set('type', 'episode');
    if (meta.season != null) params.set('season_number', String(meta.season));
    if (meta.episode != null) params.set('episode_number', String(meta.episode));
  } else {
    params.set('type', 'movie');
  }

  const url = `${OPENSUBTITLES_BASE}/subtitles?${params.toString()}`;
  
  // Use retry logic for subtitle search
  let json;
  try {
    json = await fetchWithRetry(
      async () => {
        const res = await net.fetch(url, { headers: openSubtitlesHeaders() });
        if (!res.ok) {
          const text = await res.text();
          const err = new Error(`OpenSubtitles search failed: ${res.status} ${text.slice(0, 200)}`);
          err.status = res.status;
          throw err;
        }
        return await res.json();
      },
      {
        maxRetries: 2,
        baseDelay: 1000,
        maxDelay: 3000,
        shouldRetry: (err) => {
          // Retry on network errors and 5xx, but not on 4xx (client errors)
          const msg = err.message || '';
          const status = err.status;
          return !status || status >= 500 || 
                 msg.includes('ECONNREFUSED') || msg.includes('ETIMEDOUT') ||
                 msg.includes('timeout') || msg.includes('network');
        },
      }
    );
  } catch (err) {
    if (isOfflineError(err)) {
      return { error: 'Unable to search subtitles. Please check your internet connection.' };
    }
    return { error: err.message || 'Subtitle search failed.' };
  }
  
  const data = json.data || [];

  // Deduplicate: one entry per language (keep best by download_count; already ordered)
  const byLang = new Map();
  for (const item of data) {
    const attrs = item.attributes || {};
    const lang = (attrs.language || '').toLowerCase();
    if (!lang || byLang.has(lang)) continue;
    const files = attrs.files || [];
    const file = files[0];
    if (!file || file.file_id == null) continue;
    byLang.set(lang, {
      language: lang,
      file_id: file.file_id,
      file_name: file.file_name || `${lang}.srt`,
      download_count: attrs.download_count ?? 0,
    });
  }
  return { subtitles: [...byLang.values()] };
}

async function openSubtitlesDownload(fileId) {
  const key = process.env.open_subtitles_api_key;
  if (!key) return { error: 'OpenSubtitles API key not set.' };

  // Get download link with retry
  let json;
  try {
    json = await fetchWithRetry(
      async () => {
        const res = await net.fetch(`${OPENSUBTITLES_BASE}/download`, {
          method: 'POST',
          headers: openSubtitlesHeaders(),
          body: JSON.stringify({ file_id: Number(fileId) }),
        });
        if (!res.ok) {
          const text = await res.text();
          const err = new Error(`OpenSubtitles download failed: ${res.status} ${text.slice(0, 200)}`);
          err.status = res.status;
          throw err;
        }
        return await res.json();
      },
      {
        maxRetries: 2,
        baseDelay: 1000,
        maxDelay: 3000,
        shouldRetry: (err) => {
          const status = err.status;
          return !status || status >= 500;
        },
      }
    );
  } catch (err) {
    if (isOfflineError(err)) {
      return { error: 'Unable to download subtitles. Please check your internet connection.' };
    }
    return { error: err.message || 'Subtitle download failed.' };
  }

  const link = json.link;
  if (!link) return { error: 'No download link in response.' };

  // Download the actual subtitle file with retry
  try {
    const result = await fetchWithRetry(
      async () => {
        const fileRes = await net.fetch(link);
        if (!fileRes.ok) {
          throw new Error(`Subtitle file fetch failed: ${fileRes.status}`);
        }
        return await fileRes.arrayBuffer();
      },
      {
        maxRetries: 2,
        baseDelay: 500,
        maxDelay: 2000,
      }
    );
    
    const buf = Buffer.from(result);
    const base64 = buf.toString('base64');
    const file_name = json.file_name || 'subtitles.srt';
    return { content: base64, file_name };
  } catch (err) {
    if (isOfflineError(err)) {
      return { error: 'Unable to download subtitle file. Please check your internet connection.' };
    }
    return { error: err.message || 'Subtitle file download failed.' };
  }
}

function createWindow() {
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    webPreferences: {
      preload: path.join(__dirname, 'preload.cjs'),
      contextIsolation: true,
    },
  });
  // Load the built React app from renderer-dist/
  mainWindow.loadFile(path.join(__dirname, 'renderer-dist', 'index.html'));
  mainWindow.on('closed', () => {
    mainWindow = null;
  });
}

function pickVideoFile(files) {
  const videoFiles = files.filter((file) => {
    const name = (file.name || '').toLowerCase();
    return VIDEO_EXTENSIONS.some((ext) => name.endsWith(ext));
  });
  if (videoFiles.length === 0) return null;
  return videoFiles.reduce((a, b) => (a.length > b.length ? a : b));
}

function buildStreamUrl(torrent, file) {
  const filePath = file.path.replace(/\\/g, '/').split('/').map(encodeURIComponent).join('/');
  return `${serverBaseUrl}/webtorrent/${torrent.infoHash}/${filePath}`;
}

function stopProgressUpdates() {
  if (progressInterval) {
    clearInterval(progressInterval);
    progressInterval = null;
  }
  currentTorrent = null;
}

function startProgressUpdates(torrent) {
  stopProgressUpdates();
  currentTorrent = torrent;
  const send = () => {
    if (!mainWindow || mainWindow.isDestroyed() || !currentTorrent) return;
    mainWindow.webContents.send('torrent-progress', {
      progress: currentTorrent.progress,
      downloaded: currentTorrent.downloaded,
      length: currentTorrent.length,
      downloadSpeed: currentTorrent.downloadSpeed,
      timeRemaining: currentTorrent.timeRemaining,
    });
  };
  torrent.on('download', send);
  progressInterval = setInterval(send, 500);
  send();
}

async function setupWebTorrent() {
  const { default: WebTorrent } = await import('webtorrent');
  wtClient = new WebTorrent();
  wtServer = wtClient.createServer();
  await new Promise((resolve) => {
    wtServer.server.listen(0, '127.0.0.1', () => {
      const port = wtServer.server.address().port;
      serverBaseUrl = `http://127.0.0.1:${port}`;
      resolve();
    });
  });
}

ipcMain.handle('search', async (_event, query, type) => {
  try {
    const q = (query || '').trim();
    if (!q) return { error: 'Enter a search term.' };
    if (type === 'movies') {
      const movies = await searchMovies(q);
      return { type: 'movies', results: movies };
    }
    if (type === 'tv') {
      const shows = await searchTvShows(q);
      return { type: 'tv', results: shows };
    }
    return { error: 'Invalid search type.' };
  } catch (err) {
    // Return enhanced error info for network failures
    const errorResponse = {
      error: err.userMessage || err.message || 'Search failed. Try again.',
    };
    if (err.isNetworkError || isOfflineError(err)) {
      errorResponse.isNetworkError = true;
      errorResponse.canRetry = true;
    }
    return errorResponse;
  }
});

ipcMain.handle('get-movie-magnet', async (_event, movieId) => {
  let movie = null;
  let ytsError = null;

  // Try YTS first (primary source)
  try {
    movie = await getMovieDetails(movieId);
  } catch (err) {
    ytsError = err;
  }

  const title = movie?.title || movie?.title_long || '';
  const year = movie?.year ?? null;
  const imdbCode = movie?.imdb_code || null;
  const imdbId = imdbCode
    ? String(imdbCode).startsWith('tt')
      ? imdbCode
      : 'tt' + String(imdbCode).padStart(7, '0')
    : null;

  // Check if YTS has torrents
  const ytsTorrents = movie?.torrents;
  const ytsPicked = await pickMovieTorrentWithLlm(ytsTorrents, title);

  if (ytsPicked) {
    // YTS has a torrent - use it
    const magnet = buildYtsMagnet(ytsPicked.hash, title);
    return { magnet, title, year, imdbId, source: 'YTS' };
  }

  // YTS failed or has no torrents - search multiple sources in parallel
  // Sources: 1337x, Torrent Galaxy, Kickass, LimeTorrent, TorrentFunk, MagnetDL, Torlock, BitSearch, Glodls
  if (title) {
    const searchQuery = year ? `${title} ${year}` : title;
    const movieResults = await searchMovieSources(searchQuery, 10);
    
    // Use LLM-powered selection with fallback to heuristic
    const bestPick = await pickBestTorrentWithLlm(movieResults, { title });

    if (bestPick) {
      return {
        magnet: bestPick.magnet,
        title: bestPick.title || title,
        year,
        imdbId,
        source: bestPick.source,
      };
    }
  }

  // Both sources failed
  if (ytsError) {
    const errorResponse = {
      error: ytsError.userMessage || ytsError.message || 'Failed to get magnet.',
    };
    if (ytsError.isNetworkError || isOfflineError(ytsError)) {
      errorResponse.isNetworkError = true;
      errorResponse.canRetry = true;
    }
    return errorResponse;
  }
  return { error: 'No torrents available for this movie.' };
});

ipcMain.handle('fetch-subtitles', async (_event, meta) => {
  try {
    return await openSubtitlesSearch(meta || {});
  } catch (err) {
    return { error: err.message || 'Subtitle search failed.' };
  }
});

ipcMain.handle('download-subtitle', async (_event, fileId) => {
  try {
    return await openSubtitlesDownload(fileId);
  } catch (err) {
    return { error: err.message || 'Subtitle download failed.' };
  }
});

/**
 * Save subtitle content to a temp file for mpv playback.
 * @param {string} base64Content - Base64 encoded subtitle content
 * @param {string} fileName - Original filename (used to determine extension)
 * @returns {Promise<{filePath: string} | {error: string}>}
 */
ipcMain.handle('save-subtitle-temp', async (_event, base64Content, fileName) => {
  try {
    if (!base64Content) {
      return { error: 'No subtitle content provided.' };
    }
    
    const os = require('os');
    const tempDir = os.tmpdir();
    const ext = (typeof fileName === 'string' && path.extname(fileName)) || '.srt';
    const tempFileName = `fucknetflix-subtitle-${Date.now()}${ext}`;
    const tempFilePath = path.join(tempDir, tempFileName);
    
    // Decode base64 and write to temp file
    const buffer = Buffer.from(base64Content, 'base64');
    fs.writeFileSync(tempFilePath, buffer);
    
    return { filePath: tempFilePath };
  } catch (err) {
    return { error: err.message || 'Failed to save subtitle file.' };
  }
});

ipcMain.handle('get-show-torrents', async (_event, imdbId, showName) => {
  let eztvEpisodes = [];
  let eztvError = null;

  // Try EZTV first (primary source for TV)
  try {
    if (imdbId) {
      eztvEpisodes = await getEztvTorrents(imdbId);
    }
  } catch (err) {
    eztvError = err;
  }

  // Build a map of episodes -> array of all available torrents
  // This allows LLM to choose the best torrent from multiple options
  const episodeMap = new Map();
  
  for (const ep of eztvEpisodes) {
    if (ep.season != null && ep.episode != null) {
      const key = `S${ep.season}E${ep.episode}`;
      const torrent = {
        id: ep.id,
        title: ep.title,
        season: ep.season,
        episode: ep.episode,
        magnetUrl: ep.magnetUrl,
        magnet: ep.magnetUrl, // Unified format for LLM selector
        seeds: ep.seeds || 0,
        seeders: ep.seeds || 0, // Unified format for LLM selector
        peers: ep.peers || 0,
        source: 'EZTV',
      };
      
      if (!episodeMap.has(key)) {
        episodeMap.set(key, []);
      }
      episodeMap.get(key).push(torrent);
    } else {
      // No S/E info - add with unique key as single-torrent episode
      const uniqueKey = `eztv-${ep.id}`;
      episodeMap.set(uniqueKey, [{
        ...ep,
        magnet: ep.magnetUrl,
        seeders: ep.seeds || 0,
        source: 'EZTV',
      }]);
    }
  }

  // Search multiple TV sources in parallel to collect more options per episode
  // Sources: 1337x, Torrent Galaxy, PirateBay, Kickass, LimeTorrent, TorrentFunk, MagnetDL, Torlock, BitSearch, Glodls
  if (showName) {
    try {
      const tvResults = await searchTvSources(showName, 20);

      for (const result of tvResults) {
        const parsed = parseSeasonEpisode(result.title);
        if (parsed) {
          const key = `S${parsed.season}E${parsed.episode}`;
          const torrent = {
            id: `unified-${key}-${result.source}`,
            title: result.title,
            season: parsed.season,
            episode: parsed.episode,
            magnetUrl: result.magnet,
            magnet: result.magnet, // Unified format for LLM selector
            seeds: result.seeders,
            seeders: result.seeders, // Unified format for LLM selector
            peers: 0,
            source: result.source,
          };
          
          if (!episodeMap.has(key)) {
            episodeMap.set(key, []);
          }
          episodeMap.get(key).push(torrent);
        }
      }
    } catch (_) {
      // Unified API failed - continue with EZTV results only
    }
  }

  // Use LLM to select the best torrent for each episode
  const episodes = [];
  for (const [key, torrents] of episodeMap.entries()) {
    if (torrents.length === 1) {
      // Only one option - use it directly
      const t = torrents[0];
      episodes.push({
        id: t.id,
        title: t.title,
        season: t.season,
        episode: t.episode,
        magnetUrl: t.magnetUrl || t.magnet,
        seeds: t.seeds || t.seeders,
        peers: t.peers || 0,
        source: t.source,
      });
    } else if (torrents.length > 1) {
      // Multiple options - use LLM to pick the best one
      const episodeTitle = `${showName} ${key}`;
      const bestTorrent = await pickBestTorrentWithLlm(torrents, { 
        title: episodeTitle,
        contentType: 'tv',
      });
      
      if (bestTorrent) {
        episodes.push({
          id: bestTorrent.id,
          title: bestTorrent.title,
          season: bestTorrent.season,
          episode: bestTorrent.episode,
          magnetUrl: bestTorrent.magnetUrl || bestTorrent.magnet,
          seeds: bestTorrent.seeds || bestTorrent.seeders,
          peers: bestTorrent.peers || 0,
          source: bestTorrent.source,
        });
      } else {
        // Fallback: pick highest seeder if LLM fails completely
        const fallback = torrents.reduce((best, curr) => 
          (curr.seeders || curr.seeds || 0) > (best.seeders || best.seeds || 0) ? curr : best
        );
        episodes.push({
          id: fallback.id,
          title: fallback.title,
          season: fallback.season,
          episode: fallback.episode,
          magnetUrl: fallback.magnetUrl || fallback.magnet,
          seeds: fallback.seeds || fallback.seeders,
          peers: fallback.peers || 0,
          source: fallback.source,
        });
      }
    }
  }

  // Sort by season, then episode
  episodes.sort((a, b) => {
    if (a.season !== b.season) return (a.season || 0) - (b.season || 0);
    return (a.episode || 0) - (b.episode || 0);
  });

  if (episodes.length === 0 && eztvError) {
    return { error: eztvError.message || 'Failed to load episodes.' };
  }
  if (episodes.length === 0 && !imdbId) {
    return { error: 'Show has no IMDB ID.' };
  }

  return { episodes };
});

ipcMain.handle('add-magnet', async (_event, magnet) => {
  const trim = (magnet || '').trim();
  if (!trim) {
    return { error: 'Please paste a magnet link.' };
  }
  if (!wtClient || !serverBaseUrl) {
    return { error: 'Streaming server not ready.' };
  }

  // Check if torrent already exists (e.g., from start-download)
  const existing = wtClient.get(trim);
  if (existing && existing.files) {
    const file = pickVideoFile(existing.files);
    if (file) {
      const streamURL = buildStreamUrl(existing, file);
      startProgressUpdates(existing);
      return { streamURL, fileName: file.name };
    }
  }

  return new Promise((resolve) => {
    let resolved = false;
    const done = (result) => {
      if (resolved) return;
      resolved = true;
      clearTimeout(timeoutId);
      resolve(result);
    };

    const timeoutId = setTimeout(() => {
      done({ error: 'Torrent timed out. Could not fetch metadata — check the magnet link or try again.' });
    }, TORRENT_READY_TIMEOUT);

    const torrent = wtClient.add(trim, (t) => {
      const file = pickVideoFile(t.files);
      if (!file) {
        t.destroy();
        return done({ error: 'No video file found in torrent.' });
      }
      const streamURL = buildStreamUrl(t, file);
      startProgressUpdates(t);
      done({ streamURL, fileName: file.name });
    });

    if (torrent && torrent.on) {
      torrent.on('error', (err) => done({ error: err.message || 'Failed to add torrent.' }));
    }
  });
});

ipcMain.handle('stop-current-stream', async () => {
  const stoppedTorrent = currentTorrent;
  stopProgressUpdates();

  // Destroy streaming-only torrent (not being downloaded)
  if (stoppedTorrent && !activeTorrents.has(stoppedTorrent.infoHash)) {
    stoppedTorrent.destroy();
  }

  return { success: true };
});

// ─────────────────────────────────────────────────────────────────────────────
// Download Manager IPC Handlers
// ─────────────────────────────────────────────────────────────────────────────

ipcMain.handle('start-download', async (_event, magnet, meta) => {
  const trim = (magnet || '').trim();
  if (!trim) {
    return { error: 'Invalid magnet link.' };
  }
  if (!wtClient) {
    return { error: 'Torrent client not ready.' };
  }

  return new Promise((resolve) => {
    let resolved = false;
    const done = (result) => {
      if (resolved) return;
      resolved = true;
      clearTimeout(timeoutId);
      resolve(result);
    };

    const timeoutId = setTimeout(() => {
      done({ error: 'Download timed out. Could not fetch torrent metadata — check the magnet link or try again.' });
    }, TORRENT_READY_TIMEOUT);

    // Check if already downloading
    const existing = wtClient.get(trim);
    // Only use existing if it's a valid Torrent object with EventEmitter methods
    if (existing && typeof existing.once === 'function') {
      // Torrent exists in WebTorrent - check if we're already tracking it
      if (activeTorrents.has(existing.infoHash)) {
        return done({ error: 'Already downloading this torrent.', infoHash: existing.infoHash });
      }

      // Torrent exists but not tracked - track it now (e.g., from previous session or streaming)
      // Helper function to track the torrent once files are available
      const trackTorrent = (t, videoFile) => {
        // Track this existing torrent
        activeTorrents.set(t.infoHash, {
          torrent: t,
          meta: meta || {},
          status: t.progress >= 1 ? 'seeding' : 'downloading',
        });

        // Persist data
        updateDownloadData(t.infoHash, {
          title: meta?.title || t.name || 'Unknown',
          subtitle: meta?.subtitle || '',
          thumbnail: meta?.thumbnail || null,
          magnet: trim,
          addedAt: Date.now(),
          status: t.progress >= 1 ? 'completed' : 'downloading',
          filePath: path.join(downloadsDir, videoFile.path),
          downloaded: t.downloaded,
          length: t.length,
        });

        // Set up completion handler if not already done
        if (t.progress < 1) {
          t.on('done', () => {
            const active = activeTorrents.get(t.infoHash);
            if (active) {
              active.status = 'seeding';
            }
            updateDownloadData(t.infoHash, {
              status: 'completed',
              completedAt: Date.now(),
              filePath: path.join(downloadsDir, videoFile.path),
              downloaded: t.downloaded,
              length: t.length,
            });
            sendDownloadsUpdate();
            checkSeedRatio(t);
          });

          t.on('upload', () => {
            checkSeedRatio(t);
          });
        }

        sendDownloadsUpdate();
      };

      // Check if torrent is ready (has files)
      if (existing.files && existing.files.length > 0) {
        const file = pickVideoFile(existing.files);
        if (!file) {
          return done({ error: 'No video file found in torrent.' });
        }
        trackTorrent(existing, file);
        return done({ success: true, infoHash: existing.infoHash });
      }

      // Torrent not ready yet - wait for 'ready' event
      existing.once('ready', () => {
        const file = pickVideoFile(existing.files || []);
        if (!file) {
          done({ error: 'No video file found in torrent.' });
          return;
        }
        trackTorrent(existing, file);
        done({ success: true, infoHash: existing.infoHash });
      });

      existing.once('error', (err) => {
        done({ error: err.message || 'Existing torrent encountered an error.' });
      });

      // Don't return here - let the promise wait for the ready event
      return;
    }

    const torrent = wtClient.add(trim, { path: downloadsDir }, (t) => {
      const file = pickVideoFile(t.files);
      if (!file) {
        t.destroy();
        return done({ error: 'No video file found in torrent.' });
      }

      // Track this download
      activeTorrents.set(t.infoHash, {
        torrent: t,
        meta: meta || {},
        status: 'downloading',
      });

      // Persist initial data
      updateDownloadData(t.infoHash, {
        title: meta?.title || t.name || 'Unknown',
        subtitle: meta?.subtitle || '',
        thumbnail: meta?.thumbnail || null,
        magnet: trim,
        addedAt: Date.now(),
        status: 'downloading',
      });

      // Handle completion
      t.on('done', () => {
        const active = activeTorrents.get(t.infoHash);
        if (active) {
          active.status = 'seeding';
        }
        updateDownloadData(t.infoHash, {
          status: 'completed',
          completedAt: Date.now(),
          filePath: path.join(downloadsDir, file.path),
          downloaded: t.downloaded,
          length: t.length,
        });
        sendDownloadsUpdate();

        // Check seed ratio and stop if reached
        checkSeedRatio(t);
      });

      // Track upload progress for seed ratio
      t.on('upload', () => {
        checkSeedRatio(t);
      });

      sendDownloadsUpdate();
      done({ success: true, infoHash: t.infoHash });
    });

    if (torrent && torrent.on) {
      torrent.on('error', (err) => done({ error: err.message || 'Failed to start download.' }));
    }
  });
});

function checkSeedRatio(torrent) {
  if (!torrent || torrent.progress < 1) return;
  
  const ratio = torrent.downloaded > 0 ? torrent.uploaded / torrent.downloaded : 0;
  const targetRatio = appSettings.seedRatio || 1.0;
  
  if (ratio >= targetRatio) {
    // Stop seeding - remove from active but keep in completed
    const infoHash = torrent.infoHash;
    activeTorrents.delete(infoHash);
    torrent.destroy();
    sendDownloadsUpdate();
  }
}

ipcMain.handle('pause-download', async (_event, infoHash) => {
  const active = activeTorrents.get(infoHash);
  if (!active) {
    return { error: 'Download not found.' };
  }
  
  active.status = 'paused';
  active.torrent.pause();
  sendDownloadsUpdate();
  return { success: true };
});

ipcMain.handle('resume-download', async (_event, infoHash) => {
  const active = activeTorrents.get(infoHash);
  if (!active) {
    return { error: 'Download not found.' };
  }
  
  active.status = active.torrent.progress >= 1 ? 'seeding' : 'downloading';
  active.torrent.resume();
  sendDownloadsUpdate();
  return { success: true };
});

ipcMain.handle('delete-download', async (_event, infoHash, deleteFiles) => {
  const active = activeTorrents.get(infoHash);
  const data = downloadsData[infoHash];

  // Resolve movie folder path before we destroy torrent or clear data
  let movieFolder = null;
  if (data?.filePath) {
    movieFolder = path.dirname(data.filePath);
  } else if (active?.torrent?.files?.length) {
    const file = pickVideoFile(active.torrent.files);
    if (file?.path) movieFolder = path.dirname(file.path);
  }

  if (active) {
    const torrent = active.torrent;
    activeTorrents.delete(infoHash);

    if (deleteFiles) {
      torrent.destroy({ destroyStore: true });
    } else {
      torrent.destroy();
    }
  }

  // Remove from persisted data
  delete downloadsData[infoHash];
  saveDownloadsData();

  // Remove movie folder from disk when deleteFiles is true
  if (deleteFiles && movieFolder && downloadsDir) {
    try {
      // Resolve symlinks to prevent path traversal attacks
      const realDownloadsDir = fs.realpathSync(downloadsDir);
      const realMovieFolder = fs.realpathSync(movieFolder);
      const relative = path.relative(realDownloadsDir, realMovieFolder);

      if (relative && !relative.startsWith('..') && !path.isAbsolute(relative)) {
        fs.rmSync(realMovieFolder, { recursive: true });
      }
    } catch (err) {
      // realpathSync throws if path doesn't exist, which is fine
      if (err.code !== 'ENOENT') {
        console.error('Failed to remove movie folder:', movieFolder, err);
      }
    }
  }

  sendDownloadsUpdate();
  return { success: true };
});

ipcMain.handle('get-downloads', async () => {
  return getDownloadsList();
});

ipcMain.handle('play-completed', async (_event, infoHash) => {
  // Check active torrents first
  const active = activeTorrents.get(infoHash);
  if (active && active.torrent) {
    const file = pickVideoFile(active.torrent.files);
    if (file) {
      const streamURL = buildStreamUrl(active.torrent, file);
      return { streamURL, fileName: file.name };
    }
  }
  
  // Check persisted data for file path
  const data = downloadsData[infoHash];
  if (data?.filePath && fs.existsSync(data.filePath)) {
    // Return local file path for playback
    return { filePath: data.filePath, fileName: path.basename(data.filePath) };
  }
  
  return { error: 'File not found.' };
});

ipcMain.handle('get-settings', async () => {
  return { ...appSettings };
});

ipcMain.handle('set-seed-ratio', async (_event, ratio) => {
  const num = parseFloat(ratio);
  if (isNaN(num) || num < 0 || !isFinite(num)) {
    return { error: 'Invalid ratio.' };
  }
  // Cap at reasonable maximum to prevent issues
  appSettings.seedRatio = Math.min(num, 100);
  saveSettings();
  
  // Check all active seeding torrents against new ratio
  for (const [, active] of activeTorrents) {
    if (active.torrent.progress >= 1) {
      checkSeedRatio(active.torrent);
    }
  }
  
  return { success: true };
});

// ─────────────────────────────────────────────────────────────────────────────
// mpv Binary Path - for external player support
// ─────────────────────────────────────────────────────────────────────────────

/**
 * Get the path to the bundled mpv binary.
 * Used when spawning mpv for video playback.
 * 
 * Example usage with node-mpv:
 *   const mpv = require('node-mpv');
 *   const player = new mpv({ binary: getMpvBinaryPath() });
 */
ipcMain.handle('get-mpv-path', async () => {
  try {
    const mpvPath = getMpvBinaryPath();
    const exists = fs.existsSync(mpvPath);
    return { path: mpvPath, exists };
  } catch (err) {
    return { error: err.message || 'Failed to get mpv path.' };
  }
});

// ─────────────────────────────────────────────────────────────────────────────
// mpv Player Control - IPC Handlers
// ─────────────────────────────────────────────────────────────────────────────

/**
 * Set up mpv event forwarding to renderer process
 */
function setupMpvEventForwarding() {
  mpvController.on('timeposition', (position) => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-timeposition', position);
    }
  });

  mpvController.on('statuschange', (status) => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-status', status);
    }
  });

  mpvController.on('started', () => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-started');
    }
  });

  mpvController.on('stopped', () => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-stopped');
    }
  });

  mpvController.on('paused', () => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-paused');
    }
  });

  mpvController.on('resumed', () => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-resumed');
    }
  });

  mpvController.on('seek', (data) => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-seek', data);
    }
  });

  // Handle mpv window closed by user or crashed
  mpvController.on('quit', () => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-quit');
    }
  });

  mpvController.on('crashed', () => {
    if (mainWindow && !mainWindow.isDestroyed()) {
      mainWindow.webContents.send('mpv-crashed');
    }
  });
}

// Playback control
ipcMain.handle('mpv-start', async (_event, streamUrl, options) => {
  try {
    return await mpvController.start(streamUrl, options);
  } catch (err) {
    // Include install instructions and path in error response
    return {
      error: err.message || 'Failed to start mpv playback.',
      code: err.code,
      path: err.path,
      installInstructions: err.installInstructions,
    };
  }
});

ipcMain.handle('mpv-play', async () => {
  try {
    return await mpvController.play();
  } catch (err) {
    return { error: err.message || 'Failed to play.' };
  }
});

ipcMain.handle('mpv-pause', async () => {
  try {
    return await mpvController.pause();
  } catch (err) {
    return { error: err.message || 'Failed to pause.' };
  }
});

ipcMain.handle('mpv-toggle-pause', async () => {
  try {
    return await mpvController.togglePause();
  } catch (err) {
    return { error: err.message || 'Failed to toggle pause.' };
  }
});

ipcMain.handle('mpv-stop', async () => {
  try {
    return await mpvController.stop();
  } catch (err) {
    return { error: err.message || 'Failed to stop.' };
  }
});

ipcMain.handle('mpv-quit', async () => {
  try {
    return await mpvController.quit();
  } catch (err) {
    return { error: err.message || 'Failed to quit mpv.' };
  }
});

// Seeking
ipcMain.handle('mpv-seek', async (_event, seconds) => {
  try {
    return await mpvController.seek(seconds);
  } catch (err) {
    return { error: err.message || 'Failed to seek.' };
  }
});

ipcMain.handle('mpv-go-to-position', async (_event, seconds) => {
  try {
    return await mpvController.goToPosition(seconds);
  } catch (err) {
    return { error: err.message || 'Failed to go to position.' };
  }
});

// Volume control
ipcMain.handle('mpv-volume', async (_event, level) => {
  try {
    return await mpvController.volume(level);
  } catch (err) {
    return { error: err.message || 'Failed to set volume.' };
  }
});

ipcMain.handle('mpv-adjust-volume', async (_event, delta) => {
  try {
    return await mpvController.adjustVolume(delta);
  } catch (err) {
    return { error: err.message || 'Failed to adjust volume.' };
  }
});

ipcMain.handle('mpv-mute', async () => {
  try {
    return await mpvController.mute();
  } catch (err) {
    return { error: err.message || 'Failed to mute.' };
  }
});

ipcMain.handle('mpv-unmute', async () => {
  try {
    return await mpvController.unmute();
  } catch (err) {
    return { error: err.message || 'Failed to unmute.' };
  }
});

ipcMain.handle('mpv-toggle-mute', async () => {
  try {
    return await mpvController.toggleMute();
  } catch (err) {
    return { error: err.message || 'Failed to toggle mute.' };
  }
});

// Fullscreen
ipcMain.handle('mpv-toggle-fullscreen', async () => {
  try {
    return await mpvController.toggleFullscreen();
  } catch (err) {
    return { error: err.message || 'Failed to toggle fullscreen.' };
  }
});

// Subtitles
ipcMain.handle('mpv-add-subtitles', async (_event, filePath) => {
  try {
    return await mpvController.addSubtitles(filePath);
  } catch (err) {
    return { error: err.message || 'Failed to add subtitles.' };
  }
});

// Status
ipcMain.handle('mpv-get-status', async () => {
  try {
    return mpvController.getStatus();
  } catch (err) {
    return { error: err.message || 'Failed to get status.' };
  }
});

ipcMain.handle('mpv-is-playing', async () => {
  try {
    return { playing: mpvController.isPlaying() };
  } catch (err) {
    return { error: err.message || 'Failed to check playing state.' };
  }
});

// ─────────────────────────────────────────────────────────────────────────────
// Display Detection
// ─────────────────────────────────────────────────────────────────────────────

ipcMain.handle('get-display-context', async () => {
  try {
    return getDisplayContext();
  } catch (err) {
    return { error: err.message || 'Failed to get display context.' };
  }
});

// ─────────────────────────────────────────────────────────────────────────────
// LLM Torrent Selection
// ─────────────────────────────────────────────────────────────────────────────

/**
 * Select the best torrent using LLM-powered intelligent selection
 * 
 * @param {Array} torrents - Array of torrent objects
 * @param {object} options - Selection options (title, contentType, displayContext, durationMinutes)
 * @returns {Promise<object>} Selection result with selectedIndex, reasoning, confidence, warnings
 */
ipcMain.handle('select-best-torrent', async (_event, torrents, options = {}) => {
  try {
    if (!Array.isArray(torrents) || torrents.length === 0) {
      return { error: 'No torrents provided for selection.' };
    }
    
    const result = await selectTorrent(torrents, options);
    return result;
  } catch (err) {
    console.error('[IPC] select-best-torrent error:', err);
    return { 
      error: err.message || 'Failed to select torrent.',
      selectedIndex: -1,
      confidence: 'low',
      warnings: ['Selection failed - use manual selection'],
    };
  }
});

// ─────────────────────────────────────────────────────────────────────────────
// App Lifecycle
// ─────────────────────────────────────────────────────────────────────────────

app.whenReady().then(async () => {
  // Initialize storage paths and load persisted data
  ensureAppDataDirs();
  loadSettings();
  loadDownloadsData();
  
  await setupWebTorrent();
  createWindow();
  
  // Set up mpv event forwarding to renderer
  setupMpvEventForwarding();
  
  // Resume incomplete downloads from previous session
  await resumeIncompleteDownloads();
  
  // Start sending download updates to renderer
  startDownloadsUpdateInterval();

  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) {
      createWindow();
    }
  });
});

app.on('window-all-closed', () => {
  stopDownloadsUpdateInterval();

  // Save final state of all downloads (synchronous)
  for (const [infoHash, active] of activeTorrents) {
    const t = active.torrent;
    updateDownloadData(infoHash, {
      progress: t.progress,
      downloaded: t.downloaded,
      uploaded: t.uploaded,
      seedRatio: t.downloaded > 0 ? t.uploaded / t.downloaded : 0,
    });
  }

  if (process.platform === 'darwin') {
    // On macOS the app stays running — keep resources alive so re-activate works
    return;
  }

  // Non-macOS: clean up resources then quit
  (async () => {
    try {
      await mpvController.quit();
    } catch (_) {
      // Ignore cleanup errors
    }

    if (wtClient) {
      wtClient.destroy();
      wtClient = null;
    }
    if (wtServer && wtServer.server) {
      wtServer.server.close();
      wtServer = null;
    }
    serverBaseUrl = null;
    activeTorrents.clear();

    app.quit();
  })().catch(() => {
    // Ensure app quits even if cleanup fails
    app.quit();
  });
});

app.on('before-quit', () => {
  // Synchronous best-effort cleanup — mpvController.quit() is fire-and-forget here
  // since Electron does not await async before-quit handlers either
  mpvController.quit().catch(() => {});
});