import { createHash } from "node:crypto";
import { mkdirSync, rmSync, writeFileSync } from "node:fs";
import { get } from "node:https";
import { dirname, join } from "node:path";
import { gunzipSync } from "node:zlib";
import { createRequire } from "node:module";
const resources = createRequire(import.meta.url)(join(process.cwd(), "static/reader-resources.js"));

const output = process.argv[2] || "static/vendor";
const foliateOutputArgument = process.argv.indexOf("--foliate-output");
if (foliateOutputArgument >= 0 && !process.argv[foliateOutputArgument + 1])
  throw new Error("--foliate-output requires a directory");
const foliateOutput = foliateOutputArgument >= 0
  ? process.argv[foliateOutputArgument + 1]
  : process.argv.includes("--refresh-foliate")
    ? join(process.cwd(), "static/foliate-reader/vendor") : null;
mkdirSync(output, { recursive: true });
function download(url, redirects = 0) {
  return new Promise((resolve, reject) => {
    const request = get(url, (response) => {
    if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location && redirects < 5) {
      response.resume();
      return download(new URL(response.headers.location, url), redirects + 1).then(resolve, reject);
    }
    if (response.statusCode !== 200) {
      response.resume();
      return reject(new Error(`${url}: HTTP ${response.statusCode}`));
    }
    const chunks = [];
    response.on("data", (chunk) => chunks.push(chunk));
    response.on("end", () => resolve(Buffer.concat(chunks)));
    response.on("error", reject);
    });
    request.setTimeout(180000, () => request.destroy(new Error(`${url}: request timed out`)));
    request.on("error", reject);
  });
}

async function downloadWithRetry(url) {
  let lastError;
  for (let attempt = 0; attempt < 4; attempt++) {
    try { return await download(url); }
    catch (error) {
      lastError = error;
      if (attempt < 3) await new Promise((resolve) => setTimeout(resolve, 1000 * (2 ** attempt)));
    }
  }
  throw lastError;
}

async function main() {
  const pdfArchive = await downloadWithRetry(resources.pdfArchive.url);
const pdfArchiveHash = createHash("sha256").update(pdfArchive).digest("hex");
if (pdfArchiveHash !== resources.pdfArchive.sha256) throw new Error(`pdfjs-dist archive SHA-256 ${pdfArchiveHash} does not match`);
const tar = gunzipSync(pdfArchive);
for (let offset = 0; offset + 512 <= tar.length;) {
  const header = tar.subarray(offset, offset + 512), name = header.subarray(0, 100).toString().replace(/\0.*$/, "");
  if (!name) break;
  const size = parseInt(header.subarray(124, 136).toString().replace(/\0.*$/, "").trim() || "0", 8);
  const relative = name.replace(/^package\//, "");
  if ((relative.startsWith("cmaps/") || relative.startsWith("standard_fonts/") || relative.startsWith("wasm/")) && !relative.endsWith("/")) {
    const target = join(output, relative);
    mkdirSync(dirname(target), { recursive: true });
    writeFileSync(target, tar.subarray(offset + 512, offset + 512 + size));
    if (foliateOutput) {
      const foliateTarget = join(foliateOutput, "pdfjs", relative);
      mkdirSync(dirname(foliateTarget), { recursive: true });
      writeFileSync(foliateTarget, tar.subarray(offset + 512, offset + 512 + size));
    }
  }
  offset += 512 + Math.ceil(size / 512) * 512;
}
for (const [name, {url, file: target, sha256: expected, path}] of Object.entries(resources.vendors)) {
  const bytes = await downloadWithRetry(url);
  const actual = createHash("sha256").update(bytes).digest("hex");
  if (actual !== expected) throw new Error(`${url}: SHA-256 ${actual} does not match ${expected}`);
  mkdirSync(dirname(join(output, target)), { recursive: true });
  const versioned = path.slice("vendor/".length);
  mkdirSync(dirname(join(output, versioned)), { recursive: true });
  writeFileSync(join(output, versioned), bytes);
  if (foliateOutput && (name === "pdf" || name === "pdfWorker")) {
    const filename = name === "pdf" ? "pdf.mjs" : "pdf.worker.mjs";
    mkdirSync(join(foliateOutput, "pdfjs"), { recursive: true });
    writeFileSync(join(foliateOutput, "pdfjs", filename), bytes);
    rmSync(join(foliateOutput, "pdfjs", filename + ".map"), { force: true });
  }
}
if (foliateOutput) for (const {url, file, sha256: expected} of Object.values(resources.foliateVendors)) {
  const bytes = await downloadWithRetry(url);
  const actual = createHash("sha256").update(bytes).digest("hex");
  if (actual !== expected) throw new Error(`${url}: SHA-256 ${actual} does not match ${expected}`);
  const target = join(foliateOutput, file);
  mkdirSync(dirname(target), { recursive: true });
  writeFileSync(target, bytes);
}
}

main().catch((error) => { console.error(error); process.exitCode = 1; });