import assert from 'node:assert/strict';
import test from 'node:test';
import { parseMemoryV2HealthArgs, runMemoryV2HealthCli } from './check-memory-v2-health.mjs';

function writableBuffer() {
  let value = '';
  return {
    write(chunk) {
      value += String(chunk);
    },
    value() {
      return value;
    },
  };
}

test('parseMemoryV2HealthArgs parses release gate options', () => {
  assert.deepEqual(
    parseMemoryV2HealthArgs([
      '--require-enabled',
      '--expect-backend',
      'legacy',
      '--no-env-file',
      '--env-file',
      '.env.memory',
    ]),
    {
      requireEnabled: true,
      expectedBackend: 'legacy',
      envFile: '.env.memory',
    },
  );
});

test('runMemoryV2HealthCli passes with default legacy-safe runtime', async () => {
  const stdout = writableBuffer();
  const stderr = writableBuffer();
  const code = await runMemoryV2HealthCli({
    argv: ['--require-enabled', '--expect-backend', 'legacy', '--no-env-file'],
    env: {
      MEMORY_ENABLED: '1',
      MEMORY_BACKEND: 'legacy',
      MEMORY_FAIL_OPEN: '1',
    },
    stdout,
    stderr,
  });
  const report = JSON.parse(stdout.value());

  assert.equal(code, 0);
  assert.equal(report.ok, true);
  assert.equal(report.summary.backend, 'legacy');
  assert.equal(stderr.value(), '');
});

test('runMemoryV2HealthCli fails when enabled is required but disabled', async () => {
  const stdout = writableBuffer();
  const code = await runMemoryV2HealthCli({
    argv: ['--require-enabled', '--no-env-file'],
    env: {
      MEMORY_ENABLED: '0',
      MEMORY_BACKEND: 'legacy',
    },
    stdout,
    stderr: writableBuffer(),
  });
  const report = JSON.parse(stdout.value());

  assert.equal(code, 1);
  assert.equal(report.ok, false);
  assert.equal(report.checks.find((check) => check.name === 'memory_enabled').ok, false);
});

test('runMemoryV2HealthCli verifies pgvector resolve canary keeps legacy writes', async () => {
  const stdout = writableBuffer();
  let poolEnded = false;
  class FakePool {
    async query() {
      return { rows: [] };
    }

    async end() {
      poolEnded = true;
    }
  }

  const code = await runMemoryV2HealthCli({
    argv: ['--require-enabled', '--expect-backend', 'pgvector', '--no-env-file'],
    env: {
      MEMORY_ENABLED: '1',
      MEMORY_BACKEND: 'pgvector',
      MEMORY_VECTOR_ENABLED: '1',
      MEMORY_PGVECTOR_DATABASE_URL: 'postgresql://local/memory',
      MEMORY_PGVECTOR_EMBEDDING_MODULE: './fake-embed.mjs',
    },
    stdout,
    stderr: writableBuffer(),
    async importPg() {
      return { Pool: FakePool };
    },
    async importModule() {
      return {
        async embedQuery() {
          return [0.1, 0.2, 0.3];
        },
      };
    },
  });
  const report = JSON.parse(stdout.value());

  assert.equal(code, 0);
  assert.equal(poolEnded, true);
  assert.equal(report.summary.selectedBackend, 'pgvector');
  assert.equal(report.checks.find((check) => check.name === 'write_uses_legacy').ok, true);
  assert.equal(report.checks.find((check) => check.name === 'compact_uses_legacy').ok, true);
});