import assert from 'node:assert/strict';
import test from 'node:test';
import { createLegacyMemoryBackend } from './memory-v2.mjs';
import { createMemoryV2PluginBackends } from './memory-v2-plugin-backends.mjs';
import { createPgvectorMemoryBackend } from './memory-v2-pgvector.mjs';
import {
  inspectMemoryV2Backend,
  validateMemoryV2BackendSet,
} from './memory-v2-backend-contract.mjs';

function legacyService() {
  return {
    async listMemories() {
      return [];
    },
    async saveAndAnalyze() {
      return { saved: 0, analyzed: 0, memories: 0 };
    },
    async analyzeUser() {
      return { analyzed: 0, memories: 0 };
    },
  };
}

test('inspectMemoryV2Backend accepts legacy backend contract', () => {
  const report = inspectMemoryV2Backend(createLegacyMemoryBackend(legacyService()));

  assert.equal(report.ok, true);
  assert.equal(report.name, 'legacy-conversation-memory');
  assert.equal(report.available, true);
  assert.deepEqual(report.supports, {
    resolve: true,
    write: true,
    compact: true,
  });
});

test('inspectMemoryV2Backend rejects malformed backend contracts', () => {
  const report = inspectMemoryV2Backend({
    name: 'Bad Backend',
    category: 'mystery',
    flag: 'bad-flag',
    isAvailable() {
      return false;
    },
  });

  assert.equal(report.ok, false);
  assert.equal(report.checks.find((check) => check.name === 'name_format').ok, false);
  assert.equal(report.checks.find((check) => check.name === 'has_operation').ok, false);
  assert.equal(report.checks.find((check) => check.name === 'unavailable_reason').ok, false);
  assert.equal(report.checks.find((check) => check.name === 'category_known').ok, false);
  assert.equal(report.checks.find((check) => check.name === 'flag_format').ok, false);
});

test('validateMemoryV2BackendSet verifies default backend registry', () => {
  const report = validateMemoryV2BackendSet([
    createLegacyMemoryBackend(legacyService()),
    ...createMemoryV2PluginBackends(),
  ]);

  assert.equal(report.ok, true);
  assert.equal(report.summary.backendCount, 9);
  assert.deepEqual(report.summary.availableBackends, ['legacy-conversation-memory']);
  assert.equal(report.summary.operationSupport.resolve.includes('qdrant'), true);
  assert.equal(report.summary.operationSupport.write.includes('mem0'), true);
  assert.equal(report.summary.operationSupport.compact.includes('letta'), true);
});

test('validateMemoryV2BackendSet rejects duplicate backend names and missing legacy', () => {
  const report = validateMemoryV2BackendSet([
    { name: 'qdrant', unavailableReason: 'not_configured', isAvailable: () => false, resolve() {} },
    { name: 'qdrant', unavailableReason: 'not_configured', isAvailable: () => false, resolve() {} },
  ]);

  assert.equal(report.ok, false);
  assert.equal(report.checks.find((check) => check.name === 'backend_names_unique').ok, false);
  assert.equal(report.checks.find((check) => check.name === 'legacy_backend_present').ok, false);
});

test('validateMemoryV2BackendSet accepts real disabled pgvector adapter replacing placeholder', () => {
  const report = validateMemoryV2BackendSet([
    createLegacyMemoryBackend(legacyService()),
    createPgvectorMemoryBackend({ enabled: false }),
    ...createMemoryV2PluginBackends({ exclude: ['pgvector'] }),
  ]);

  assert.equal(report.ok, true);
  assert.equal(report.backends.find((backend) => backend.name === 'pgvector').available, false);
  assert.equal(
    report.backends.find((backend) => backend.name === 'pgvector')
      .checks.find((check) => check.name === 'unavailable_reason').ok,
    true,
  );
});