import assert from 'node:assert/strict';
import test from 'node:test';
import { evaluateMemoryV2Health } from './memory-v2-health.mjs';

function healthyStatus(overrides = {}) {
  return {
    enabled: true,
    backend: 'legacy',
    selectedBackend: 'legacy-conversation-memory',
    profileEnabled: true,
    eventLogEnabled: true,
    vectorEnabled: false,
    failOpen: true,
    backends: [
      {
        name: 'legacy-conversation-memory',
        available: true,
        supports: {
          resolve: true,
          write: true,
          compact: true,
        },
      },
      {
        name: 'pgvector',
        available: false,
        supports: {
          resolve: true,
          write: false,
          compact: false,
        },
        reason: 'not_configured',
      },
    ],
    ...overrides,
  };
}

test('evaluateMemoryV2Health passes for legacy-safe status', () => {
  const report = evaluateMemoryV2Health({
    status: healthyStatus(),
    writeResult: { source: 'legacy-conversation-memory' },
    compactResult: { source: 'legacy-conversation-memory' },
    requireEnabled: true,
    expectedBackend: 'legacy',
  });

  assert.equal(report.ok, true);
  assert.equal(report.summary.selectedBackend, 'legacy-conversation-memory');
  assert.equal(report.checks.every((check) => check.ok), true);
});

test('evaluateMemoryV2Health fails when status contract and fail-open are broken', () => {
  const report = evaluateMemoryV2Health({
    status: {
      enabled: true,
      backend: 'legacy',
      selectedBackend: null,
      failOpen: false,
      backends: [],
    },
    requireEnabled: true,
  });

  assert.equal(report.ok, false);
  assert.equal(report.checks.find((check) => check.name === 'status_contract').ok, false);
  assert.equal(report.checks.find((check) => check.name === 'fail_open').ok, false);
  assert.equal(report.checks.find((check) => check.name === 'legacy_available').ok, false);
});

test('evaluateMemoryV2Health allows pgvector resolve canary while requiring legacy write and compact', () => {
  const report = evaluateMemoryV2Health({
    status: healthyStatus({
      backend: 'pgvector',
      selectedBackend: 'pgvector',
      vectorEnabled: true,
      backends: [
        healthyStatus().backends[0],
        {
          name: 'pgvector',
          available: true,
          supports: {
            resolve: true,
            write: false,
            compact: false,
          },
        },
      ],
    }),
    writeResult: { source: 'legacy-conversation-memory' },
    compactResult: { source: 'legacy-conversation-memory' },
    expectedBackend: 'pgvector',
  });

  assert.equal(report.ok, true);
  assert.equal(report.checks.find((check) => check.name === 'pgvector_canary_available').ok, true);
});

test('evaluateMemoryV2Health fails when semantic canary captures writes', () => {
  const report = evaluateMemoryV2Health({
    status: healthyStatus({
      backend: 'pgvector',
      selectedBackend: 'pgvector',
      vectorEnabled: true,
    }),
    writeResult: { source: 'pgvector' },
    compactResult: { source: 'legacy-conversation-memory' },
  });

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