import assert from 'node:assert/strict';
import test from 'node:test';
import vm from 'node:vm';
import {
  normalizeMemoryV2AdapterScaffoldOptions,
  renderMemoryV2AdapterScaffold,
} from './memory-v2-adapter-scaffold.mjs';
import { inspectMemoryV2Backend } from './memory-v2-backend-contract.mjs';

async function loadGeneratedBackend(source, factoryName) {
  const transformed = `${source.replace(/export function /, 'function ')}\n${factoryName};`;
  const script = new vm.Script(transformed);
  const factory = script.runInNewContext({});
  return factory();
}

test('normalizeMemoryV2AdapterScaffoldOptions normalizes names, flags, and capabilities', () => {
  assert.deepEqual(
    normalizeMemoryV2AdapterScaffoldOptions({
      name: 'Qdrant Store',
      category: 'semantic',
      role: 'Scale Out Vector Store',
      capabilities: ['resolve', 'resolve'],
    }),
    {
      name: 'qdrant-store',
      factoryName: 'createQdrantStoreMemoryBackend',
      category: 'semantic',
      role: 'scale-out-vector-store',
      capabilities: ['resolve'],
      flag: 'MEMORY_QDRANT_STORE_ENABLED',
    },
  );
});

test('normalizeMemoryV2AdapterScaffoldOptions rejects invalid category and capability', () => {
  assert.throws(
    () => normalizeMemoryV2AdapterScaffoldOptions({
      name: 'bad',
      category: 'unknown',
      capabilities: ['resolve'],
    }),
    /Adapter category/,
  );
  assert.throws(
    () => normalizeMemoryV2AdapterScaffoldOptions({
      name: 'bad',
      category: 'semantic',
      capabilities: ['delete'],
    }),
    /Unsupported Memory V2 capability/,
  );
});

test('renderMemoryV2AdapterScaffold generates disabled backend that passes contract gate', async () => {
  const options = normalizeMemoryV2AdapterScaffoldOptions({
    name: 'qdrant',
    category: 'semantic',
    role: 'scale-out-vector-store',
    capabilities: ['resolve'],
    flag: 'MEMORY_QDRANT_ENABLED',
  });
  const source = renderMemoryV2AdapterScaffold(options);
  const backend = await loadGeneratedBackend(source, options.factoryName);
  const report = inspectMemoryV2Backend(backend);

  assert.match(source, /export function createQdrantMemoryBackend/);
  assert.equal(backend.isAvailable(), false);
  assert.equal(backend.getUnavailableReason(), 'not_configured');
  assert.equal(report.ok, true);
  assert.deepEqual(report.supports, {
    resolve: true,
    write: false,
    compact: false,
  });
});

test('renderMemoryV2AdapterScaffold can include write and compact operations', async () => {
  const options = normalizeMemoryV2AdapterScaffoldOptions({
    name: 'mem0',
    category: 'extraction',
    capabilities: ['write', 'compact'],
  });
  const backend = await loadGeneratedBackend(
    renderMemoryV2AdapterScaffold(options),
    options.factoryName,
  );

  assert.deepEqual(JSON.parse(JSON.stringify(await backend.write({}))), {
    saved: 0,
    analyzed: 0,
    memories: 0,
  });
  assert.deepEqual(JSON.parse(JSON.stringify(await backend.compact({}))), {
    analyzed: 0,
    memories: 0,
  });
  assert.equal(inspectMemoryV2Backend(backend).ok, true);
});