// repro.js
// Run: node repro.js
'use strict';

const { fork } = require('node:child_process');
const fs = require('node:fs');
const v8 = require('node:v8');
const { MessageChannel } = require('node:worker_threads');

if (process.argv[2] === 'inspect') {
  process.on('message', (value) => {
    process.send({
      isBuffer: Buffer.isBuffer(value),
      constructorName: value?.constructor?.name,
      keys: Object.keys(value),
      visible: value?.visible,
      bytes: ArrayBuffer.isView(value) ?
        Buffer.from(value.buffer, value.byteOffset, value.byteLength).toString('hex') :
        undefined,
    });
  });
} else if (process.argv[2] === 'bad-tag') {
  class BadTagSerializer extends v8.DefaultSerializer {
    _writeHostObject(value) {
      this.writeUint32(2); // old child_process codec only accepts 0 or 1
      return super._writeHostObject(value);
    }
  }

  const ser = new BadTagSerializer();
  ser.writeHeader();
  ser.writeValue(Buffer.from('x'));

  const payload = ser.releaseBuffer();
  const framed = Buffer.allocUnsafe(4 + payload.length);
  framed.writeUInt32BE(payload.length, 0);
  payload.copy(framed, 4);

  fs.writeSync(process.channel.fd, framed);
} else {
  main();
}

function inspect(value) {
  return new Promise((resolve) => {
    const child = fork(__filename, ['inspect'], {
      serialization: 'advanced',
      stdio: ['ignore', 'ignore', 'inherit', 'ipc'],
    });

    child.once('message', (message) => {
      child.disconnect();
      resolve({ ok: true, message });
    });

    child.once('exit', (code, signal) => {
      resolve({ ok: false, code, signal });
    });

    try {
      child.send(value);
    } catch (err) {
      child.disconnect();
      resolve({ ok: false, threw: err.message });
    }
  });
}

function sendBadTag() {
  return new Promise((resolve) => {
    const child = fork(__filename, ['bad-tag'], {
      serialization: 'advanced',
      stdio: ['ignore', 'ignore', 'inherit', 'ipc'],
    });

    function onUncaughtException(err) {
      process.removeListener('uncaughtException', onUncaughtException);
      resolve({ rejected: true, error: err.code || err.message });
    }

    process.once('uncaughtException', onUncaughtException);

    child.once('message', (value) => {
      process.removeListener('uncaughtException', onUncaughtException);
      resolve({
        accepted: true,
        isBuffer: Buffer.isBuffer(value),
        value: Buffer.isBuffer(value) ? value.toString() : value,
      });
    });
  });
}

function check(name, passed, details) {
  console.log(`${passed ? 'PASS' : 'FAIL'}: ${name}`);
  console.log(details);
  console.log();
  if (!passed) process.exitCode = 1;
}

async function main() {
  console.log('Expected on release/current Node: all PASS');
  console.log('Regression on PR build: one or more FAIL\n');

  const { port1, port2 } = new MessageChannel();
  port1.visible = 1;

  Object.defineProperty(Object.prototype, 'visible', {
    configurable: true,
    set() { throw new Error('setter called'); },
  });

  const setter = await inspect(port1);
  delete Object.prototype.visible;
  port1.close();
  port2.close();

  check(
    'host-object spread must not invoke inherited setters',
    setter.ok && setter.message.visible === 1 && setter.message.keys[0] === 'visible',
    setter.threw ? `regression: child.send() threw "${setter.threw}"` :
      `result: ${JSON.stringify(setter)}`,
  );

  const buf = Buffer.from('abc');
  buf.constructor = Uint8Array;
  const bufResult = await inspect(buf);

  check(
    'Buffer with constructor = Uint8Array keeps old classification',
    bufResult.ok && bufResult.message.isBuffer === false,
    `expected Buffer.isBuffer(received) === false\nresult: ${JSON.stringify(bufResult)}`,
  );

  const uint8 = new Uint8Array([1, 2, 3]);
  uint8.constructor = Buffer;
  const uint8Result = await inspect(uint8);

  check(
    'Uint8Array with constructor = Buffer keeps old classification',
    uint8Result.ok && uint8Result.message.isBuffer === true,
    `expected Buffer.isBuffer(received) === true\nresult: ${JSON.stringify(uint8Result)}`,
  );

  const badTag = await sendBadTag();

  check(
    'invalid child_process host-object tag is rejected',
    badTag.rejected === true,
    badTag.rejected ? `rejected with: ${badTag.error}` :
      `regression: malformed tag accepted: ${JSON.stringify(badTag)}`,
  );
}