import { load } from 'cheerio';
import { spawn } from 'node:child_process';
import path from 'node:path';
import fs from 'node:fs';
import { fileURLToPath } from 'node:url';

/**
 * Rumble provider.
 *
 * Context (2026-09): rumble.com sits behind Cloudflare. Server-side fetches from
 * Node/OpenSSL receive 403 "Just a moment..." challenges on /search/* paths —
 * the TLS (JA3) fingerprint is rejected regardless of headers. Verified working
 * bypasses:
 *   - curl built against Windows Schannel (dev machine only, not portable);
 *   - python curl_cffi with browser impersonation (works on Linux/Docker).
 *
 * Fetch strategy, best-effort in order:
 *   1. Node fetch with a full browser header set + shared __cf_bm cookie jar
 *      (works on networks where CF does not challenge this fingerprint);
 *   2. python3 + curl_cffi helper (rumble_fetch.py) impersonating Chrome —
 *      the reliable path inside the Docker image (curl_cffi installed there);
 *   3. if everything is challenged, return [] — the unified search already
 *      degrades gracefully per-provider.
 */

const BROWSER_HEADERS = {
  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36',
  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
  'Accept-Language': 'en-US,en;q=0.9',
  'sec-ch-ua': '"Chromium";v="131", "Not_A Brand";v="24"',
  'sec-ch-ua-mobile': '?0',
  'sec-ch-ua-platform': '"Windows"',
  'sec-fetch-dest': 'document',
  'sec-fetch-mode': 'navigate',
  'sec-fetch-site': 'none',
  'sec-fetch-user': '?1',
  'upgrade-insecure-requests': '1',
};

// One shared cookie jar: Cloudflare issues __cf_bm on the first 200 and expects
// it on subsequent requests. Refreshed lazily every ~25 minutes.
let cookieJar = null;
let cookieJarAt = 0;
const COOKIE_JAR_TTL_MS = 25 * 60 * 1000;

const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
const PYTHON_HELPER = path.join(MODULE_DIR, 'rumble_fetch.py');
const PYTHON_HELPER_EXISTS = fs.existsSync(PYTHON_HELPER);

function mergeSetCookies(existing, setCookieHeaders) {
  if (!Array.isArray(setCookieHeaders) || setCookieHeaders.length === 0) return existing;
  const jar = new Map();
  for (const pair of String(existing || '').split(';').map(s => s.trim()).filter(Boolean)) {
    const idx = pair.indexOf('=');
    if (idx > 0) jar.set(pair.slice(0, idx), pair.slice(idx + 1));
  }
  for (const raw of setCookieHeaders) {
    const first = String(raw || '').split(';')[0].trim();
    const idx = first.indexOf('=');
    if (idx > 0) jar.set(first.slice(0, idx), first.slice(idx + 1));
  }
  return Array.from(jar.entries()).map(([k, v]) => `${k}=${v}`).join('; ');
}

function headersWithCookies() {
  const headers = { ...BROWSER_HEADERS };
  if (cookieJar && (Date.now() - cookieJarAt) < COOKIE_JAR_TTL_MS) {
    headers['Cookie'] = cookieJar;
  }
  return headers;
}

/** Node fetch with cookie-jar bookkeeping. Returns {status, html}. */
async function nodeFetch(url, { timeoutMs = 12_000 } = {}) {
  const controller = new AbortController();
  const tid = setTimeout(() => controller.abort(), timeoutMs);
  try {
    const res = await fetch(url, { headers: headersWithCookies(), redirect: 'follow', signal: controller.signal });
    try {
      const setCookies = typeof res.headers.getSetCookie === 'function' ? res.headers.getSetCookie() : [];
      if (setCookies.length > 0) {
        cookieJar = mergeSetCookies(cookieJar, setCookies);
        cookieJarAt = Date.now();
      }
    } catch {}
    const html = await res.text();
    return { status: res.status, html };
  } finally {
    clearTimeout(tid);
  }
}

/** python3 + curl_cffi helper. Returns {status, html} or null when unavailable. */
async function pythonFetch(url, { timeoutMs = 20_000 } = {}) {
  if (!PYTHON_HELPER_EXISTS) return null;
  const pythons = ['python3', 'python'];
  for (const py of pythons) {
    const result = await new Promise((resolve) => {
      let settled = false;
      const done = (v) => { if (!settled) { settled = true; resolve(v); } };
      const child = spawn(py, [PYTHON_HELPER, url, String(Math.ceil(timeoutMs / 1000))], {
        stdio: ['ignore', 'pipe', 'ignore'],
      });
      let stdout = '';
      let failed = false;
      const timer = setTimeout(() => { failed = true; try { child.kill(); } catch {} done(null); }, timeoutMs + 5_000);
      child.stdout.on('data', (d) => { stdout += d.toString(); });
      child.on('error', () => { clearTimeout(timer); done(null); });
      child.on('close', (code) => {
        clearTimeout(timer);
        if (failed) return;
        done(code === 0 && stdout.length > 1000 ? { status: 200, html: stdout } : null);
      });
    });
    if (result) return result;
  }
  return null;
}

/** Node fetch first, python/curl_cffi fallback. */
async function fetchHtml(url) {
  try {
    const r = await nodeFetch(url);
    if (r.status === 200 && !isChallenge(r.html)) return r;
  } catch { /* fallback */ }
  const py = await pythonFetch(url);
  if (py) return py;
  return null;
}

function isChallenge(html) {
  return /Just a moment|challenge-platform|cf-chl/i.test(String(html || '').slice(0, 4000));
}

/**
 * Phase 3.3 — cache négatif court.
 * Sans lui, chaque recherche Rumble déclenchait 2 fetch Node + 2 fetch Python
 * (12-20 s) pour finir sur un challenge Cloudflare, à chaque frappe utilisateur.
 * TTL volontairement court (5 min) : un challenge se lève vite, et on ne veut
 * pas figer une panne de plus de quelques minutes.
 * @type {Map<string, number>}
 */
const NEGATIVE_CACHE_TTL_MS = Number(process.env.RUMBLE_NEGATIVE_CACHE_TTL_MS || 5 * 60 * 1000);
const negativeCache = new Map();

function negativeCacheKey(q, page) { return `search:vide:${page}:${String(q || '').trim().toLowerCase()}`; }

function isNegativelyCached(key) {
  const ts = negativeCache.get(key);
  if (!ts) return false;
  if ((Date.now() - ts) >= NEGATIVE_CACHE_TTL_MS) { negativeCache.delete(key); return false; }
  return true;
}

function markNegative(key) {
  // Garde-fou mémoire : le cache ne doit pas grossir sans borne.
  if (negativeCache.size >= 200) {
    for (const [k, ts] of negativeCache) {
      if ((Date.now() - ts) >= NEGATIVE_CACHE_TTL_MS) negativeCache.delete(k);
      if (negativeCache.size < 150) break;
    }
  }
  negativeCache.set(key, Date.now());
}

export function resetRumbleNegativeCache() { negativeCache.clear(); }

/* --------------------------------- parsing -------------------------------- */

function parseDurationToSeconds(raw) {
  if (raw == null) return undefined;
  const value = String(raw).trim();
  if (!value) return undefined;
  // Garde-fou : les attributs datetime (dates de publication, ex.
  // "2026-09-23T18:11:52-04:00") ne sont JAMAIS des durées — sans ce test,
  // l'extraction des chiffres+':' produit des durées absurdes (~351840 s).
  if (/^\d{4}-\d{2}-\d{2}/.test(value)) return undefined;
  const numeric = Number(value);
  if (Number.isFinite(numeric) && numeric > 0) {
    // Rumble expose parfois des durées en millisecondes sur les cartes de
    // recherche (ex. 351840 ≈ 5:52). Au-delà de ~27 h en "secondes", c'est
    // quasi certainement des ms : on convertit (sans impact sur le filtre
    // Shorts, car >100 s reste une vidéo dans tous les cas).
    if (/^\d+(\.\d+)?$/.test(value) && numeric > 100000) return Math.floor(numeric / 1000);
    return Math.floor(numeric);
  }
  const isoMatch = value.match(/^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$/i);
  if (isoMatch) {
    const total = (Number(isoMatch[1] || 0) * 3600) + (Number(isoMatch[2] || 0) * 60) + Number(isoMatch[3] || 0);
    if (total > 0) return total;
  }
  const textMatch = value.match(/^(?:(\d+)\s*h(?:ours?)?)?\s*(?:(\d+)\s*m(?:in(?:utes)?)?)?\s*(?:(\d+)\s*s(?:ec(?:onds)?)?)?$/i);
  if (textMatch && (textMatch[1] || textMatch[2] || textMatch[3])) {
    const total = (Number(textMatch[1] || 0) * 3600) + (Number(textMatch[2] || 0) * 60) + Number(textMatch[3] || 0);
    if (total > 0) return total;
  }
  const colonCandidate = value.replace(/[^0-9:]/g, '');
  if (colonCandidate.includes(':')) {
    const segments = colonCandidate.split(':').filter(Boolean).map(s => Number(s));
    if (segments.length >= 2 && segments.every(n => Number.isFinite(n))) {
      while (segments.length < 3) segments.unshift(0);
      const [h, m, s] = segments.slice(-3);
      const total = (h * 3600) + (m * 60) + s;
      if (total > 0) return total;
    }
  }
  return undefined;
}

function normalizeThumb(raw) {
  const t = String(raw || '').replace(/\s+/g, '').trim();
  if (!t) return undefined;
  return t.startsWith('//') ? `https:${t}` : t;
}

/**
 * Compteur de vues localized : "1,2K views", "1.2M views", "3 456", "12,345".
 * L'ancien code faisait `.replace(/[^\d]/g, '')` : le suffixe disparaissait et
 * "1,2K" devenait 12 (au lieu de 1 200). Les vues étaient donc affichées
 * fausses sur la quasi-totalité des cartes Rumble au-delà de 999.
 */
export function parseRumbleViews(raw) {
  const s = String(raw ?? '').trim();
  if (!s) return undefined;
  const m = s.match(/([\d][\d\s\u00a0.,]*)\s*([KMBkmb])?/);
  if (!m) return undefined;
  // 1 234 -> "1234" ; 1,2 / 1.2 -> "1.2" (décimal) ; 1,234 -> "1234" (milliers)
  let digits = m[1].replace(/[\s\u00a0]/g, '');
  if (/^\d{1,3},\d{3}$/.test(digits) || /^\d{1,3}\.\d{3}$/.test(digits)) digits = digits.replace(/[.,]/g, '');
  else digits = digits.replace(',', '.');
  const num = Number(digits);
  if (!Number.isFinite(num) || num < 0) return undefined;
  const suffix = (m[2] || '').toLowerCase();
  const mult = suffix === 'b' ? 1e9 : suffix === 'm' ? 1e6 : suffix === 'k' ? 1e3 : 1;
  const total = Math.round(num * mult);
  return total > 0 ? total : undefined;
}

/** Clé de rapprochement stable : dernier segment d'URL, sans extension ni tracking. */
function urlKey(u) {
  const s = String(u || '').split('?')[0].replace(/\.html$/i, '').replace(/\/$/, '');
  return (s.split('/').filter(Boolean).pop() || '').toLowerCase();
}

/**
 * Phase 3.1 — extraction du JSON-LD (`application/ld+json`).
 * Plus stable que le DOM : quand le balisage change, le JSON-LD reste. On
 * accepte `VideoObject`, `ItemList` et `@graph`, et on n'indexe QUE ce qui est
 * explicitement présent (aucune valeur déduite).
 * @returns {Map<string, { publishedAt?: string, views?: number, thumbnail?: string, duration?: number, channelId?: string }>}
 */
export function parseJsonLd(html) {
  /** @type {Map<string, any>} */
  const out = new Map();
  const re = /<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
  let m;
  while ((m = re.exec(String(html || ''))) !== null) {
    let data;
    try { data = JSON.parse(m[1].trim()); } catch { continue; }
    const nodes = Array.isArray(data) ? data
      : Array.isArray(data?.['@graph']) ? data['@graph']
      : data ? [data] : [];
    for (const node of nodes) visit(node, out, 0);
  }
  return out;
}

function visit(node, out, depth) {
  if (!node || typeof node !== 'object' || depth > 4) return;
  const list = Array.isArray(node['@graph'])
    ? node['@graph']
    : (Array.isArray(node.itemListElement) ? node.itemListElement.map((e) => e?.item ?? e) : null);
  if (list) { for (const c of list) visit(c, out, depth + 1); }

  const type = String(node['@type'] || '').toLowerCase();
  if (!type.includes('video')) return;
  const key = urlKey(node.url || node.embedUrl || node.contentUrl || node['@id']);
  if (!key) return;

  const stats = node.interactionStatistic;
  const statList = Array.isArray(stats) ? stats : (stats ? [stats] : []);
  let views;
  for (const st of statList) {
    const t = String(st?.interactionType || '').toLowerCase();
    if (!t.includes('watch') && !t.includes('view')) continue;
    const n = Number(st?.userInteractionCount);
    if (Number.isFinite(n) && n >= 0) { views = Math.round(n); break; }
  }

  const dateRaw = node.uploadDate || node.datePublished;
  const parsed = dateRaw ? Date.parse(dateRaw) : NaN;
  const publishedAt = Number.isFinite(parsed) && parsed > 0 ? new Date(parsed).toISOString() : undefined;
  const duration = parseDurationToSeconds(node.duration);
  const thumbRaw = Array.isArray(node.thumbnailUrl)
    ? node.thumbnailUrl[0]
    : (typeof node.thumbnailUrl === 'string' ? node.thumbnailUrl : node.thumbnailUrl?.url);
  const authorUrl = typeof node.author === 'string' ? node.author : node.author?.url;
  const channelId = (String(authorUrl || '').match(/\/c\/([^/?#]+)/i)?.[1] || '').trim() || undefined;

  out.set(key, {
    ...(publishedAt ? { publishedAt } : {}),
    ...(views !== undefined && views > 0 ? { views } : {}),
    ...(duration !== undefined ? { duration } : {}),
    ...(thumbRaw ? { thumbnail: normalizeThumb(thumbRaw) } : {}),
    ...(channelId ? { channelId } : {}),
  });
}

/** Classic parser: li.video-listing-entry cards. */
export function parseSearchHtml(html, { limit = 50 } = {}) {
  const $ = load(html);
  const items = [];
  $('li.video-listing-entry').each((_idx, el) => {
    if (items.length >= limit) return false;
    const $el = $(el);
    const anchor = ($el.find('a.video-item--a').attr('href') || '').trim();
    if (!anchor) return;
    const img = $el.find('img.video-item--img');
    const rawThumbnail = img.attr('data-src') || img.attr('data-original') || img.attr('src') || '';
    const title = $el.find('h3.video-item--title').text().replace(/\s+/g, ' ').trim();
    const uploaderName = $el.find('.ellipsis-1').text().replace(/\s+/g, ' ').trim();
    // Strip tracking params (e9s, sci, …) from the anchor for a canonical URL
    const cleanAnchor = anchor.startsWith('http')
      ? anchor
      : `https://rumble.com${anchor.split('?')[0]}`;
    const url = cleanAnchor;
    const id = $el.attr('data-id')
      || (url.split('/').filter(Boolean).pop() || '').replace(/\.html$/, '')
      || String(Math.random());
    // Rumble expose la durée dans <span class="video-item--duration" data-value="3:06:42">
    // (le span n'a pas de contenu texte). L'attribut datetime des <time> est
    // une DATE de publication — jamais une durée (cf. garde-fou ci-dessus).
    const durEl = $el.find('.video-item--duration, .video-item--meta time, .video-item--meta .duration').first();
    const durationCandidates = [
      $el.attr('data-duration'),
      $el.attr('data-video-duration'),
      $el.find('[data-duration]').attr('data-duration'),
      durEl.attr('data-value'),
      durEl.attr('data-duration'),
      durEl.attr('title'),
      durEl.text(),
    ];
    let durationSeconds;
    for (const candidate of durationCandidates) {
      const parsed = parseDurationToSeconds(candidate);
      if (typeof parsed === 'number' && parsed > 0) { durationSeconds = parsed; break; }
    }
    const viewsText = $el.find('.video-item--views').first().text().trim();
    const views = parseRumbleViews(viewsText);
    // Phase 1.4 - date de publication. L'attribut `datetime` du <time> est la
    // vraie date ISO ; son texte est un libelle relatif ("2 months ago") que
    // Date.parse() ne sait pas lire, d'ou l'absence historique de publishedAt.
    const timeEl = $el.find('.video-item--meta time, time.video-item--date, time').first();
    const publishedRaw = (timeEl.attr('datetime') || timeEl.attr('data-datetime') || '').trim();
    const publishedMs = publishedRaw ? Date.parse(publishedRaw) : NaN;
    const publishedAt = Number.isFinite(publishedMs) && publishedMs > 0
      ? new Date(publishedMs).toISOString()
      : undefined;
    // Phase 1.5 - identifiant de chaine. L'URL porte soit /c/<username>/,
    // soit (en fallback) le sous-domaine ; l'avatar est sur l'image du by-line.
    const channelLink = $el.find('a.video-item--channel-link, a[href*="/c/"]').first();
    const channelHref = (channelLink.attr('href') || '').trim();
    const channelId = (channelHref.match(/\/c\/([^/?#]+)/i)?.[1] || '').trim() || undefined;
    const avatarEl = $el.find('img.video-item--channel-thumb, .video-item--by-line img, a.video-item--channel-link img').first();
    const uploaderAvatar = normalizeThumb(avatarEl.attr('src') || avatarEl.attr('data-src') || '');
      items.push({
        title: title || url,
        id,
        url,
        thumbnail: normalizeThumb(rawThumbnail),
        uploaderName: uploaderName || undefined,
        // Phase 1.4 / 1.5 / 1.6 - les trois champs etaient presents dans le HTML
        // mais jamais extraits, ce qui vidait la page chaine de sa date, de son
        // lien "voir la chaine" et de son avatar.
        publishedAt,
        channelId,
        uploaderAvatar,
        views,
        type: 'video',
        duration: durationSeconds,
        // Pas de flag maison ici : le filtre central (isShortItem,
        // durée ≤75 s) tranche. Le scraper HTML n'expose pas de dimensions.
      });
  });
  // Phase 3.1 — surcouche JSON-LD : complète ce que le DOM n'expose pas
  // (date de publication, vues, auteur) SANS jamais écraser une valeur réellement
  // présente dans la liste. Le DOM reste la source primaire, le JSON-LD le filet.
  try {
    const ld = parseJsonLd(html);
    if (ld.size > 0) {
      for (const it of items) {
        const patch = ld.get(urlKey(it.url)) || ld.get(urlKey(it.id));
        if (!patch) continue;
        if (it.publishedAt === undefined && patch.publishedAt) it.publishedAt = patch.publishedAt;
        if (it.views === undefined && patch.views) it.views = patch.views;
        if (it.duration === undefined && patch.duration) it.duration = patch.duration;
        if (it.thumbnail === undefined && patch.thumbnail) it.thumbnail = patch.thumbnail;
        if (it.channelId === undefined && patch.channelId) it.channelId = patch.channelId;
      }
    }
  } catch { /* la surcouche est un bonus, jamais un motif d'échec */ }
  return items;
}

/* --------------------------------- handler -------------------------------- */

const handler = {
  id: 'ru',
  label: 'Rumble',
  /**
   * @param {string} q
   * @param {{ limit: number, page?: number, sort?: string }} opts
   * @returns {Promise<Array<any>>}
   */
  async search(q, opts) {
    const { limit = 10, page = 1 } = opts || {};
    const perPage = Math.min(Math.max(1, Number(limit || 10)), 50);
    const pageNum = Math.max(1, Number(page || 1));
    const query = String(q || '').trim();
    if (!query) return [];

    // Phase 3.3 — short-circuit si l'échec vient d'être constaté.
    const cacheKey = negativeCacheKey(query, pageNum);
    if (isNegativelyCached(cacheKey)) {
      // Phase 3.4 — un échec est une ERREUR, pas un résultat vide : le front
      // peut ainsi afficher un bandeau au lieu d'un « aucun résultat » trompeur.
      throw Object.assign(new Error('rumble_cloudflare_challenge'), {
        code: 'rumble_cloudflare_challenge', rumbleChallenged: true,
      });
    }

    // --- Attempt 1: canonical search page (Node fetch, then python/curl_cffi) ---
    try {
      const params = new URLSearchParams({ q: query });
      if (pageNum > 1) params.set('page', String(pageNum));
      const r = await fetchHtml(`https://rumble.com/search/video?${params.toString()}`);
      if (r && !isChallenge(r.html)) {
        const items = parseSearchHtml(r.html, { limit: perPage });
        if (items.length > 0) return items;
      }
    } catch { /* next */ }

    // --- Attempt 2: search/all (all-types page, video facet included) ---
    try {
      const params = new URLSearchParams({ 'search-videos': '1', q: query });
      if (pageNum > 1) params.set('page', String(pageNum));
      const r = await fetchHtml(`https://rumble.com/search/all?${params.toString()}`);
      if (r && !isChallenge(r.html)) {
        const items = parseSearchHtml(r.html, { limit: perPage });
        if (items.length > 0) return items;
      }
    } catch { /* give up */ }

    // Phase 3.4 — on distingue « échec » de « vide ». Une recherche Rumble qui
    // renvoie 0 résultat à travers deux chemins est presque toujours un blocage
    // Cloudflare, pas une absence de contenu : on le remonte, on met en cache
    // négatif, et le groupe ne passe pas pour un recherche normale sans résultat.
    markNegative(cacheKey);
    throw Object.assign(new Error('rumble_unavailable'), {
      code: 'rumble_unavailable', rumbleChallenged: true,
    });
  },
};

export default handler;