#!/usr/bin/env node
/* eslint-disable no-console */
import { createHash } from "node:crypto";
import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { markFailedBaselineGates } from "./baseline-gate-exit.mjs";
import { spawn } from "node:child_process";

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const repoRoot = path.resolve(__dirname, "..");
export const reportPath = path.join(repoRoot, ".tc/baselines/import-boundary/baseline-health.md");

const ignoredDirectoryNames = new Set([".git", "node_modules", "build", "dist", "coverage", ".react-router", ".turbo", ".next", ".cache", ".vite", "generated"]);

export const importInventoryScanRoots = ["apps/web/app/routes", "apps/api/src", "apps/worker/src", "packages/db/src", "packages/exports/src", "packages/queue/src", "packages/storage/src", "prisma/schema"];

export const importInventoryPatterns = [
  { id: "import-format-term", pattern: /\b(?:csv|json|xlsx|excel|spreadsheet|text\/csv|application\/json|application\/vnd\.openxmlformats-officedocument\.spreadsheetml\.sheet)\b/gi },
  { id: "import-job-model-reference", pattern: /\b(?:import|imports|importJob|ImportJob|import_job|IMPORT_|model\s+Import|job|status|ImportStatus)\b/g },
  { id: "parser-mapping-reference", pattern: /\b(?:parser|parse|parsed|mapping|mapper|columnMap|fieldMap|header|row|normalize|transform)\b/gi },
  { id: "dry-run-validation-reference", pattern: /\b(?:dryRun|dry-run|preview|validate|validation|schema|duplicate|dedupe|errorReport|error-report|ImportError|rejected)\b/g },
  { id: "queue-worker-import-wiring", pattern: /\b(?:queue|job|worker|producer|consumer|enqueue|processImport|importJob|IMPORT_)\b/g },
  { id: "scan-quarantine-reference", pattern: /\b(?:clamav|clamAV|virus|malware|scan|scanner|quarantine|infected|clean|threat)\b/g },
  { id: "tenant-permission-audit-marker", pattern: /\b(?:tenantId|workspaceId|actorId|userId|permission|permissions|authorize|authorized|audit|auditable|policy)\b/g },
  { id: "generated-client-reference", pattern: /\b(?:packages\/db\/generated|@toolctrl\/db\/generated|generated\/prisma|PrismaClient|client\/models\/(?:ImportJob|ImportError|FileObject)|client\/enums\/(?:ImportStatus|JobStatus))\b/g },
];

export const gates = [
  { id: "typecheck", command: "pnpm", args: ["run", "typecheck"] },
  { id: "lint", command: "pnpm", args: ["run", "lint"] },
  { id: "vitest-export-formats", command: "pnpm", args: ["exec", "vitest", "run", "packages/exports/src/index.test.ts", "packages/exports/src/csv/index.test.ts", "packages/exports/src/json/index.test.ts", "packages/exports/src/xlsx/index.test.ts"] },
  { id: "vitest-import-infrastructure", command: "pnpm", args: ["exec", "vitest", "run", "packages/storage/src/scan/index.test.ts", "packages/queue/src/producers.test.ts", "apps/worker/src/handlers.test.ts"] },
  { id: "import-inventory", type: "import-inventory" },
];

function shellCommand(gate) {
  if (gate.type === "import-inventory") return "read-only import inventory";
  return [gate.command, ...gate.args].join(" ");
}

function outputFingerprint(output) {
  const normalized = output.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-40).join("\n");
  return { hash: createHash("sha256").update(output).digest("hex").slice(0, 12), excerpt: normalized.slice(0, 1200) || "(no output)" };
}

function parseNumber(value) {
  const parsed = Number.parseInt(value, 10);
  return Number.isFinite(parsed) ? parsed : 0;
}

function conservativeFailureCount(count, output) {
  return count > 0 ? count : output.trim() ? 1 : 0;
}

function countVitestFailures(output) {
  const failedTests = output.match(/Tests\s+(\d+)\s+failed/i);
  if (failedTests) return parseNumber(failedTests[1]);
  const failedFiles = output.match(/Test Files\s+(\d+)\s+failed/i);
  return failedFiles ? parseNumber(failedFiles[1]) : 0;
}

export function failureCount(gateId, stdout, stderr, exitCode = 1) {
  if (exitCode === 0 || gateId === "import-inventory") return 0;
  const output = `${stdout}\n${stderr}`;
  if (gateId === "typecheck") return conservativeFailureCount((output.match(/error TS\d+/g) ?? []).length, output);
  if (gateId === "lint") {
    const problemsMatch = output.match(/✖\s+(\d+)\s+problems?\s+\((\d+)\s+errors?/i);
    const compactMatch = output.match(/(\d+)\s+errors?/i);
    return conservativeFailureCount(problemsMatch ? parseNumber(problemsMatch[2]) : compactMatch ? parseNumber(compactMatch[1]) : 0, output);
  }
  if (gateId === "vitest-export-formats" || gateId === "vitest-import-infrastructure") return conservativeFailureCount(countVitestFailures(output), output);
  return output.trim() ? 1 : 0;
}

function runShellGate(gate) {
  return new Promise((resolve) => {
    const startedAt = Date.now();
    const child = spawn(gate.command, gate.args, { cwd: repoRoot, env: { ...process.env, CI: "1" }, shell: false });
    let stdout = "";
    let stderr = "";
    child.stdout.on("data", (chunk) => { stdout += chunk; });
    child.stderr.on("data", (chunk) => { stderr += chunk; });
    child.on("error", (error) => { stderr += `\n${error.message}`; });
    child.on("close", (code) => {
      const output = `${stdout}\n${stderr}`;
      resolve({ id: gate.id, command: shellCommand(gate), exitCode: code ?? 1, durationMs: Date.now() - startedAt, failureCount: failureCount(gate.id, stdout, stderr, code ?? 1), fingerprint: outputFingerprint(output) });
    });
  });
}

function isIgnoredDirectory(name, relativePath) {
  return ignoredDirectoryNames.has(name) || name.endsWith(".cache") || relativePath === "packages/db/generated" || relativePath.startsWith("packages/db/generated/");
}

async function rootExists(root, rootRelativePath) {
  try {
    await stat(path.join(root, rootRelativePath));
    return true;
  } catch (error) {
    if (error?.code === "ENOENT") return false;
    throw error;
  }
}

async function collectFiles(root, rootRelativePath) {
  const absoluteRoot = path.join(root, rootRelativePath);
  const files = [];
  async function walk(directory) {
    const entries = await readdir(directory, { withFileTypes: true });
    for (const entry of entries) {
      const absolutePath = path.join(directory, entry.name);
      const relativePath = path.relative(root, absolutePath).split(path.sep).join("/");
      if (entry.isDirectory()) {
        if (isIgnoredDirectory(entry.name, relativePath)) continue;
        await walk(absolutePath);
      } else if (entry.isFile() && /\.(?:ts|tsx|js|jsx|mjs|cjs|prisma|sql)$/.test(entry.name) && !entry.name.endsWith(".generated.ts") && !entry.name.endsWith(".generated.tsx")) {
        files.push(absolutePath);
      }
    }
  }
  await walk(absoluteRoot);
  return files;
}

export async function runImportInventory(root = repoRoot) {
  const existingRoots = [];
  for (const rootRelativePath of importInventoryScanRoots) if (await rootExists(root, rootRelativePath)) existingRoots.push(rootRelativePath);
  const files = (await Promise.all(existingRoots.map((rootRelativePath) => collectFiles(root, rootRelativePath)))).flat();
  const counts = new Map(importInventoryPatterns.map(({ id }) => [id, 0]));
  const matches = [];
  for (const file of files) {
    const relativeFile = path.relative(root, file).split(path.sep).join("/");
    const lines = (await readFile(file, "utf8")).split(/\r?\n/);
    lines.forEach((line, index) => {
      for (const { id, pattern } of importInventoryPatterns) {
        pattern.lastIndex = 0;
        const found = line.match(pattern);
        if (!found) continue;
        counts.set(id, (counts.get(id) ?? 0) + found.length);
        matches.push(`${relativeFile}:${index + 1}: [${id}] ${line.trim()}`);
      }
    });
  }
  return { roots: existingRoots, counts: Object.fromEntries(counts.entries()), totalMatches: matches.length, matches };
}

async function runImportInventoryGate(gate) {
  const startedAt = Date.now();
  const inventory = await runImportInventory(repoRoot);
  const outputLines = [`Import inventory scanned roots: ${inventory.roots.join(", ")}`, ...Object.entries(inventory.counts).map(([id, count]) => `${id}: ${count}`), `total matches: ${inventory.totalMatches}`, ...inventory.matches.slice(0, 240)];
  if (inventory.matches.length > 240) outputLines.push(`... ${inventory.matches.length - 240} additional matches omitted`);
  const output = outputLines.join("\n");
  return { id: gate.id, command: shellCommand(gate), exitCode: 0, durationMs: Date.now() - startedAt, failureCount: 0, fingerprint: outputFingerprint(output) };
}

async function runGate(gate) {
  if (gate.type === "import-inventory") return runImportInventoryGate(gate);
  return runShellGate(gate);
}

export function renderReport(results) {
  const lines = [
    "# Import Boundary Baseline Health",
    "",
    `Generated: ${new Date().toISOString()}`,
    "",
    "This report captures non-E2E baseline gates for Import Boundary baseline. The runner exits 0 when every gate was executed and this report was written, even if individual gates fail.",
    "The import inventory gate is read-only and fingerprints CSV/JSON/XLSX format terms, import job/model/parser/mapping/dry-run/validation/duplicate/error-report markers, queue/worker wiring, ClamAV scan/quarantine markers, tenant/permission/audit markers, and accidental generated Prisma client references while skipping generated folders such as packages/db/generated.",
    "",
  ];
  for (const result of results) lines.push(`## ${result.id}`, "", `- Command: \`${result.command}\``, `- Exitcode: ${result.exitCode}`, `- Failure Count: ${result.failureCount}`, `- Duration: ${result.durationMs}ms`, `- Output Fingerprint: ${result.fingerprint.hash}`, "", "```text", result.fingerprint.excerpt, "```", "");
  return `${lines.join("\n")}\n`;
}

async function writeFailureReport(error) {
  await mkdir(path.dirname(reportPath), { recursive: true });
  const output = error?.stack ?? String(error);
  await writeFile(reportPath, renderReport([{ id: "runner-error", command: "node scripts/verify-import-boundary-baseline.mjs", exitCode: 1, durationMs: 0, failureCount: 1, fingerprint: outputFingerprint(output) }]), "utf8");
}

async function main() {
  const results = [];
  for (const gate of gates) {
    console.log(`Running ${gate.id}: ${shellCommand(gate)}`);
    results.push(await runGate(gate));
  }
  await mkdir(path.dirname(reportPath), { recursive: true });
  await writeFile(reportPath, renderReport(results), "utf8");
  console.log(`Wrote ${path.relative(repoRoot, reportPath)}`);
  markFailedBaselineGates(results);
}

if (process.argv[1] === fileURLToPath(import.meta.url)) {
  main().catch(async (error) => {
    console.error(error);
    try {
      await writeFailureReport(error);
    } finally {
      process.exit(1);
    }
  });
}