import fs from "node:fs";
import path from "node:path";

const cwd = process.cwd();
const mapPath = path.join(cwd, "cli.js.map");
const outputRoot = path.join(cwd, "claude_src");

function ensureInsideOutput(resolvedPath) {
  const relative = path.relative(outputRoot, resolvedPath);
  if (relative.startsWith("..") || path.isAbsolute(relative)) {
    throw new Error(`Refusing to write outside output directory: ${resolvedPath}`);
  }
}

function normalizeSourcePath(sourcePath, index) {
  const cleaned = sourcePath.replace(/\\/g, "/");
  const withoutPrefix = cleaned.replace(/^(\.\.\/)+/, "");
  const safePath = withoutPrefix || `unknown/source_${index}.txt`;
  return safePath;
}

function main() {
  if (!fs.existsSync(mapPath)) {
    throw new Error(`Source map not found: ${mapPath}`);
  }

  fs.mkdirSync(outputRoot, { recursive: true });

  const raw = fs.readFileSync(mapPath, "utf8");
  const map = JSON.parse(raw);
  const sources = Array.isArray(map.sources) ? map.sources : [];
  const contents = Array.isArray(map.sourcesContent) ? map.sourcesContent : [];

  let written = 0;
  let skipped = 0;

  for (let i = 0; i < sources.length; i += 1) {
    const sourcePath = sources[i];
    const sourceContent = contents[i];

    if (typeof sourcePath !== "string" || typeof sourceContent !== "string") {
      skipped += 1;
      continue;
    }

    const relativePath = normalizeSourcePath(sourcePath, i);
    const destination = path.resolve(outputRoot, relativePath);
    ensureInsideOutput(destination);

    fs.mkdirSync(path.dirname(destination), { recursive: true });
    fs.writeFileSync(destination, sourceContent, "utf8");
    written += 1;
  }

  const summaryPath = path.join(outputRoot, "_extraction_summary.txt");
  const summary = [
    `map: ${mapPath}`,
    `output: ${outputRoot}`,
    `sources: ${sources.length}`,
    `written: ${written}`,
    `skipped: ${skipped}`,
    "",
    "Top-level restored directories:",
    ...Array.from(
      new Set(
        sources
          .filter((entry) => typeof entry === "string")
          .map((entry, index) => normalizeSourcePath(entry, index).split("/")[0]),
      ),
    ).sort(),
    "",
  ].join("\n");

  fs.writeFileSync(summaryPath, summary, "utf8");

  process.stdout.write(
    [
      `Restored ${written} source files to ${outputRoot}`,
      `Skipped ${skipped} entries without inline content`,
      `Summary: ${summaryPath}`,
    ].join("\n"),
  );
}

main();