import '../common/index.mjs';
import assert from 'node:assert';
import repl from 'node:repl';
import { startNewREPLServer } from '../common/repl.js';

const testingReplPrompt = '_REPL_TESTING_PROMPT_>';

// Feed a block of source into the REPL one line at a time, awaiting each line
// so the asynchronous evaluator settles before the next line is written.
// Blank/whitespace-only and comment-only lines produce no evaluation output
// and are skipped (the previous synchronous REPL coalesced the whole block in
// a single write, so a trailing comment line evaluated to `undefined`; feeding
// line by line we simply omit it to keep output deterministic).
async function feed(run, block) {
  for (const line of block.split('\n')) {
    const trimmed = line.trim();
    if (trimmed === '' || trimmed.startsWith('//')) continue;
    await run(`${line}\n`);
  }
}

await testSloppyMode();
await testStrictMode();
await testResetContext();
await testResetContextGlobal();
await testError();

async function testSloppyMode() {
  const { replServer, output, run } = startNewREPLServer({
    prompt: testingReplPrompt,
    mode: repl.REPL_MODE_SLOPPY,
  });

  // Cannot use `let` in sloppy mode
  await feed(run, `_;          // initial value undefined
          var x = 10;  // evaluates to undefined
          _;           // still undefined
          y = 10;      // evaluates to 10
          _;           // 10 from last eval
          _ = 20;      // explicitly set to 20
          _;           // 20 from user input
          _ = 30;      // make sure we can set it twice and no prompt
          _;           // 30 from user input
          y = 40;      // make sure eval doesn't change _
          _;           // remains 30 from user input
          `);

  assertOutput(output, [
    'undefined',
    'undefined',
    'undefined',
    '10',
    '10',
    'Expression assignment to _ now disabled.',
    '20',
    '20',
    '30',
    '30',
    '40',
    '30',
  ]);

  replServer.close();
}

async function testStrictMode() {
  const { replServer, output, run } = startNewREPLServer({
    prompt: testingReplPrompt,
    mode: repl.REPL_MODE_STRICT,
  });

  await feed(run, `_;          // initial value undefined
          var x = 10;  // evaluates to undefined
          _;           // still undefined
          let _ = 20;  // use 'let' only in strict mode - evals to undefined
          _;           // 20 from user input
          _ = 30;      // make sure we can set it twice and no prompt
          _;           // 30 from user input
          var y = 40;  // make sure eval doesn't change _
          _;           // remains 30 from user input
          function f() { let _ = 50; } // undefined
          f();         // undefined
          _;           // remains 30 from user input
          `);

  assertOutput(output, [
    'undefined',
    'undefined',
    'undefined',
    'undefined',
    '20',
    '30',
    '30',
    'undefined',
    '30',
    'undefined',
    'undefined',
    '30',
  ]);

  replServer.close();
}

async function testResetContext() {
  const { replServer, output, run } = startNewREPLServer({
    prompt: testingReplPrompt,
  });

  await feed(run, `_ = 10;     // explicitly set to 10
          _;           // 10 from user input
          .clear       // Clearing context...
          _;           // remains 10
          x = 20;      // but behavior reverts to last eval
          _;           // expect 20
          `);

  assertOutput(output, [
    'Expression assignment to _ now disabled.',
    '10',
    '10',
    'Clearing context...',
    '10',
    '20',
    '20',
  ]);

  replServer.close();
}

async function testResetContextGlobal() {
  const { replServer, output, run } = startNewREPLServer({
    prompt: testingReplPrompt,
    useGlobal: true,
  });

  await feed(run, `_ = 10;     // explicitly set to 10
          _;           // 10 from user input
          .clear       // No output because useGlobal is true
          _;           // remains 10
          `);

  assertOutput(output, [
    'Expression assignment to _ now disabled.',
    '10',
    '10',
    '10',
  ]);

  replServer.close();

  // Delete globals leaked by REPL when `useGlobal` is `true`
  delete globalThis.module;
  delete globalThis.require;
}

async function testError() {
  const { replServer, output, run } = startNewREPLServer({
    prompt: testingReplPrompt,
    replMode: repl.REPL_MODE_STRICT,
    preview: false,
  });

  await feed(run, `_error;                                // initial value undefined
           throw new Error('foo');                // throws error
           _error;                                // shows error
           fs.readdirSync('/nonexistent?');       // throws error, sync
           _error.code;                           // shows error code
           _error.syscall;                        // shows error syscall
           setImmediate(() => { throw new Error('baz'); }); undefined;
                                                  // throws error, async
           `);

  const lines = output.accumulator.trim().split('\n').filter(
    (line) => !line.includes(testingReplPrompt) || line.includes('Uncaught Error')
  );
  const expectedLines = [
    'undefined',

    // The error, both from the original throw and the `_error` echo. The
    // inspector-based evaluator returns the real Error object, so both the
    // thrown report and the echo now include a stack trace rather than the
    // compact `[Error: foo]` form produced by the previous vm-based REPL.
    'Uncaught Error: foo',
    /^ +at REPL\d+:/,
    'Error: foo',
    /^ +at REPL\d+:/,

    // The sync error, with individual property echoes. The thrown report now
    // includes stack frames before the property listing.
    /^Uncaught Error: ENOENT: no such file or directory, scandir '.*nonexistent\?'/,
    /Object\.readdirSync/,
    /^ +at REPL\d+:.*\{$/,
    /^ {2}errno: -(2|4058),$/,
    "  code: 'ENOENT',",
    "  syscall: 'scandir',",
    /^ {2}path: '*'/,
    '}',
    "'ENOENT'",
    "'scandir'",

    // 'undefined' from the explicit silencer on the setImmediate line.
    'undefined',

    // The message from the asynchronously thrown error.
    /Uncaught Error: baz/,
  ];
  for (const line of lines) {
    const expected = expectedLines.shift();
    if (typeof expected === 'string')
      assert.strictEqual(line, expected);
    else
      assert.match(line, expected);
  }
  assert.strictEqual(expectedLines.length, 0);

  // Reset output, check that '_error' is the asynchronously caught error.
  // Because input is now fed one line at a time and the accumulator is reset
  // mid-stream, the first line's echo is no longer preceded by a prompt and so
  // survives the prompt filter; ignore that leading echo. The thrown error also
  // now reports a stack frame.
  output.accumulator = '';
  await feed(run, `_error.message                 // show the message
             _error = 0;                    // disable auto-assignment
             throw new Error('quux');       // new error
             _error;                        // should not see the new error
             `);

  const errorLines = output.accumulator.trim().split('\n')
    .filter((line) => !line.includes(testingReplPrompt) &&
                      !line.includes('_error.message') &&
                      !/^ +at REPL\d+:/.test(line));
  assert.deepStrictEqual(errorLines, [
    "'baz'",
    'Expression assignment to _error now disabled.',
    '0',
    'Uncaught Error: quux',
    '0',
  ]);

  replServer.close();
}

function assertOutput(output, expected) {
  const lines = output.accumulator.trim().split('\n').filter((line) => !line.includes(testingReplPrompt));
  assert.deepStrictEqual(lines, expected);
}