/**
 * HTML -> clean markdown extraction, with lazy + graceful dependency loading.
 *
 * The heavy deps (@mozilla/readability, jsdom, turndown) are imported on first
 * use so the extension loads instantly and degrades to a clear "run npm
 * install" message when they're absent.
 */

// Types derived from the real modules (kept loose where the libs ship `any`).
type ReadabilityCtor = (typeof import("@mozilla/readability"))["Readability"];
type JSDOMCtor = (typeof import("jsdom"))["JSDOM"];
// turndown's default export is the service class; the instance has .turndown().
interface TurndownService {
  turndown(html: string): string;
  remove(tags: string[]): void;
}

export interface Extractor {
  Readability: ReadabilityCtor;
  JSDOM: JSDOMCtor;
  turndown: TurndownService;
}

export const DEP_SPECS = ["@mozilla/readability", "jsdom", "turndown"] as const;

// ---------------------------------------------------------------------------
// JSDOM silent VirtualConsole (suppresses CSS-parse warnings etc.)
// ---------------------------------------------------------------------------
let _silentVc: import("jsdom").VirtualConsole | undefined;

async function getSilentVirtualConsole(): Promise<import("jsdom").VirtualConsole> {
  if (!_silentVc) {
    const jsdom = await import("jsdom");
    _silentVc = new jsdom.VirtualConsole();
    // Swallow everything — we only care about actual errors, not noisy
    // warnings from malformed <style> tags in fetched HTML.
    _silentVc.on("error", () => {});
    _silentVc.on("warn", () => {});
  }
  return _silentVc;
}

let extractorPromise: Promise<Extractor> | undefined;

export function loadExtractor(): Promise<Extractor> {
  if (!extractorPromise) {
    extractorPromise = (async () => {
      const [readability, jsdom, turndownMod] = await Promise.all([
        import("@mozilla/readability"),
        import("jsdom"),
        import("turndown"),
      ]);
      const Turndown = (turndownMod as { default?: unknown }).default ?? turndownMod;
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
      const td = new (Turndown as any)({ headingStyle: "atx", codeBlockStyle: "fenced", bulletListMarker: "-" });
      td.remove(["script", "style", "noscript"]);
      return { Readability: readability.Readability, JSDOM: jsdom.JSDOM, turndown: td as TurndownService };
    })().catch((err) => {
      extractorPromise = undefined; // allow retry after install
      throw err;
    });
  }
  return extractorPromise;
}

export function isModuleNotFound(err: unknown): boolean {
  const e = err as { code?: string; message?: string };
  return (
    e?.code === "ERR_MODULE_NOT_FOUND" ||
    e?.code === "MODULE_NOT_FOUND" ||
    /cannot find (module|package)/i.test(e?.message ?? "")
  );
}

export async function missingDep(): Promise<string | undefined> {
  for (const spec of DEP_SPECS) {
    try {
      await import(spec);
    } catch (err) {
      if (isModuleNotFound(err)) return spec;
    }
  }
  return undefined;
}

export async function toMarkdown(
  extractor: Extractor,
  html: string,
  url: string,
  maxChars: number,
): Promise<{ title: string; markdown: string; truncated: boolean }> {
  const dom = new extractor.JSDOM(html, { url, virtualConsole: await getSilentVirtualConsole() });
  const doc = dom.window.document;
  let title = doc.title || url;
  let md = "";
  try {
    const article = new extractor.Readability(doc).parse();
    if (article) {
      title = article.title || title;
      if (article.content) md = extractor.turndown.turndown(article.content);
    }
  } catch {
    // fall through to text fallback
  }
  if (!md.trim()) md = (doc.body?.textContent ?? "").trim();
  md = md.replace(/\n{3,}/g, "\n\n").trim();
  let truncated = false;
  if (md.length > maxChars) {
    md = md.slice(0, maxChars);
    truncated = true;
  }
  return { title, markdown: md, truncated };
}