import { spawnSync } from 'node:child_process';
import * as fs from 'node:fs';
import * as os from 'node:os';
import * as path from 'node:path';

import JavaScriptObfuscator from 'javascript-obfuscator';

const ITERATIONS = parseInt(process.argv[2] ?? '200', 10);

const OBFUSCATION_OPTIONS = {
  compact: true,
  controlFlowFlattening: true,
  controlFlowFlatteningThreshold: 1.0,
  deadCodeInjection: true,
  deadCodeInjectionThreshold: 1.0,
  identifierNamesGenerator: 'hexadecimal',
  log: false,
  numbersToExpressions: true,
  selfDefending: false,
  simplify: false,
  splitStrings: true,
  splitStringsChunkLength: 5,
  stringArray: true,
  stringArrayCallsTransformThreshold: 1.0,
  stringArrayEncoding: ['base64'],
  stringArrayIndexShift: true,
  stringArrayRotate: true,
  stringArrayShuffle: true,
  stringArrayThreshold: 1,
  stringArrayWrappersChainedCalls: true,
  stringArrayWrappersCount: 5,
  target: 'node',
  unicodeEscapeSequence: true,
};

const SOURCE = `
// Shape 1: captured outer-scope variable called via \`?.()\` inside a
// nested closure. This is the shape that reliably reproduces the bug.
export function shape1() {
  const captured = undefined;
  const wrap = (msg) => {
    captured?.(msg);
    return 'ok';
  };
  return wrap('payload');
}

export function shape2() {
  const obj = {};
  obj.handler?.('arg');
  return 'ok';
}

export async function shape3() {
  const cb = undefined;
  await cb?.();
  return 'ok';
}

export class Foo { run() { this.cb?.('arg'); return 'ok'; } }
export function shape4Run() { return new Foo().run(); }

export function shape5() {
  const obj = { inner: undefined };
  obj.inner?.handler?.();
  return 'ok';
}

// Padding so controlFlowFlattening has enough basic blocks to do
// non-trivial rewiring. Tiny inputs sometimes don't trigger the
// miscompile because the dispatch table CFF builds is too small.
function noise(n) {
  let acc = 0;
  for (let i = 0; i < n; i++) {
    if (i % 2 === 0) acc += i;
    else if (i % 3 === 0) acc -= i;
    else acc ^= i;
    if (acc > 1000000) acc = 0;
  }
  return acc;
}
function processItems(items) {
  const out = [];
  for (const item of items) {
    const tag = item.tag ?? 'untagged';
    const value = item.value ?? 0;
    if (tag === 'a') out.push(value * 2);
    else if (tag === 'b') out.push(value + 10);
    else out.push(value);
  }
  return out;
}
class Store {
  constructor() { this.data = new Map(); }
  set(k, v) { this.data.set(k, v); }
  get(k) { return this.data.get(k); }
  has(k) { return this.data.has(k); }
  *values() { for (const v of this.data.values()) yield v; }
}
export function exercisePadding() {
  noise(100);
  processItems([{ tag: 'a', value: 1 }, { tag: 'b', value: 2 }, { value: 3 }]);
  const s = new Store();
  s.set('x', 1);
  return s.has('x');
}
`;

const HARNESS_TEMPLATE = `
import { shape1, shape2, shape3, shape4Run, shape5, exercisePadding } from './SOURCE_PLACEHOLDER';
async function main() {
  exercisePadding();
  const results = { shape1: 'unset', shape2: 'unset', shape3: 'unset', shape4: 'unset', shape5: 'unset' };
  try { results.shape1 = shape1(); } catch (e) { results.shape1 = 'THROW: ' + e.message; }
  try { results.shape2 = shape2(); } catch (e) { results.shape2 = 'THROW: ' + e.message; }
  try { results.shape3 = await shape3(); } catch (e) { results.shape3 = 'THROW: ' + e.message; }
  try { results.shape4 = shape4Run(); } catch (e) { results.shape4 = 'THROW: ' + e.message; }
  try { results.shape5 = shape5(); } catch (e) { results.shape5 = 'THROW: ' + e.message; }
  console.log(JSON.stringify(results));
}
main();
`;

const tmpDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), 'obf-repro-'));
console.log(`workdir: ${tmpDir}`);
console.log(`node: ${process.version}`);

const SHAPES = ['shape1', 'shape2', 'shape3', 'shape4', 'shape5'];
const failsByShape = Object.fromEntries(SHAPES.map((s) => [s, 0]));
let runsWithAnyFail = 0;
const examples = {};

for (let i = 1; i <= ITERATIONS; i++) {
  const obfPath = path.join(tmpDir, `source.${i}.mjs`);
  const harnessPath = path.join(tmpDir, `harness.${i}.mjs`);
  const obfuscated = JavaScriptObfuscator.obfuscate(SOURCE, OBFUSCATION_OPTIONS).getObfuscatedCode();
  await fs.promises.writeFile(obfPath, obfuscated);
  const harness = HARNESS_TEMPLATE.replace('SOURCE_PLACEHOLDER', `./source.${i}.mjs`);
  await fs.promises.writeFile(harnessPath, harness);

  const proc = spawnSync(process.execPath, [harnessPath], { encoding: 'utf-8', timeout: 10_000 });
  let results;
  try { results = JSON.parse(proc.stdout?.trim() ?? ''); }
  catch {
    runsWithAnyFail++;
    console.log(`[${i}/${ITERATIONS}] FAIL (no JSON) stderr=${(proc.stderr ?? '').slice(0, 200)}`);
    continue;
  }
  const failed = SHAPES.filter((s) => results[s] !== 'ok');
  if (failed.length > 0) {
    runsWithAnyFail++;
    for (const s of failed) {
      failsByShape[s]++;
      examples[s] ??= results[s];
    }
    console.log(`[${i}/${ITERATIONS}] FAIL ${failed.join(',')}`);
  } else {
    console.log(`[${i}/${ITERATIONS}] PASS`);
    await fs.promises.unlink(obfPath);
    await fs.promises.unlink(harnessPath);
  }
}

console.log(`\n=== Summary over ${ITERATIONS} iterations ===`);
console.log(`runs with any failure: ${runsWithAnyFail}/${ITERATIONS} (${((runsWithAnyFail / ITERATIONS) * 100).toFixed(1)}%)`);
for (const s of SHAPES) {
  const n = failsByShape[s];
  console.log(`  ${s}: ${n}/${ITERATIONS} fail (${((n / ITERATIONS) * 100).toFixed(1)}%)${n > 0 ? ` — example: ${examples[s].slice(0, 120)}` : ''}`);
}
console.log(`\nbroken artifacts (if any) kept in: ${tmpDir}`);

(f === null || f === void 0) ? void 0 : f.call(undefined, arg)