import assert from 'node:assert/strict';
import test from 'node:test';
import {
  parseMemoryV2AppCanaryArgs,
  runMemoryV2AppCanaryCli,
} from './check-memory-v2-app-canary.mjs';

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

test('parseMemoryV2AppCanaryArgs maps app-level gate options', () => {
  assert.deepEqual(
    parseMemoryV2AppCanaryArgs([
      '--base-url',
      'http://127.0.0.1:18081/',
      '--require-enabled',
      '--require-target-healthy',
      '--expect-backend',
      'pgvector',
      '--expect-selected-backend',
      'pgvector',
      '--timeout-ms',
      '1000',
    ]),
    {
      baseUrl: 'http://127.0.0.1:18081',
      requireEnabled: true,
      requireTargetHealthy: true,
      expectedBackend: 'pgvector',
      expectedSelectedBackend: 'pgvector',
      timeoutMs: 1000,
      help: false,
    },
  );
});

test('runMemoryV2AppCanaryCli passes against a pgvector-enabled runtime status', async () => {
  const stdout = writableBuffer();
  const code = await runMemoryV2AppCanaryCli({
    argv: [
      '--base-url',
      'http://app.local',
      '--require-enabled',
      '--require-target-healthy',
      '--expect-backend',
      'pgvector',
      '--expect-selected-backend',
      'pgvector',
    ],
    stdout,
    async fetchImpl(url) {
      if (url.endsWith('/api/runtime/status')) {
        return {
          ok: true,
          status: 200,
          async text() {
            return JSON.stringify({
              ok: true,
              memory: {
                enabled: true,
                backend: 'pgvector',
                selectedBackend: 'pgvector',
                failOpen: true,
                vectorEnabled: true,
              },
              targets: [{ target: 'https://127.0.0.1:18006', healthy: true }],
            });
          },
        };
      }
      if (url.endsWith('/api/status')) {
        return { ok: true, status: 200, async text() { return 'ok'; } };
      }
      if (url.endsWith('/auth/status')) {
        return {
          ok: true,
          status: 200,
          async text() {
            return JSON.stringify({ authenticated: false, mode: 'user' });
          },
        };
      }
      throw new Error(`unexpected url ${url}`);
    },
  });
  const report = JSON.parse(stdout.value());

  assert.equal(code, 0);
  assert.equal(report.ok, true);
  assert.equal(report.summary.memory.selectedBackend, 'pgvector');
  assert.equal(report.summary.targets.healthy, 1);
});

test('runMemoryV2AppCanaryCli fails when selected backend does not match', async () => {
  const stdout = writableBuffer();
  const code = await runMemoryV2AppCanaryCli({
    argv: ['--expect-selected-backend', 'pgvector'],
    stdout,
    async fetchImpl(url) {
      if (url.endsWith('/api/runtime/status')) {
        return {
          ok: true,
          status: 200,
          async text() {
            return JSON.stringify({
              ok: true,
              memory: { enabled: true, backend: 'pgvector', selectedBackend: 'legacy-conversation-memory' },
              targets: [],
            });
          },
        };
      }
      return { ok: true, status: 200, async text() { return '{}'; } };
    },
  });
  const report = JSON.parse(stdout.value());

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