import assert from 'node:assert/strict';
import test from 'node:test';
import { inspectMemoryV2Backend } from './memory-v2-backend-contract.mjs';
import { createLangGraphHttpClient, createLangGraphMemoryBackend } from './memory-v2-langgraph.mjs';
import { createNeo4jHttpClient, createNeo4jMemoryBackend } from './memory-v2-neo4j.mjs';
import {
  createRedisStreamsClient,
  createRedisStreamsMemoryBackend,
} from './memory-v2-redis-streams.mjs';
import { createWeaviateHttpClient, createWeaviateMemoryBackend } from './memory-v2-weaviate.mjs';

test('weaviate backend is disabled by default and delegates only with client plus embedding', async () => {
  const disabled = createWeaviateMemoryBackend();
  assert.equal(disabled.name, 'weaviate');
  assert.equal(disabled.category, 'semantic');
  assert.equal(disabled.role, 'knowledge-graph-fusion');
  assert.equal(disabled.flag, 'MEMORY_WEAVIATE_ENABLED');
  assert.equal(disabled.isAvailable(), false);
  assert.equal(disabled.getUnavailableReason(), 'not_configured');
  assert.equal(inspectMemoryV2Backend(disabled).ok, true);

  const backend = createWeaviateMemoryBackend({
    enabled: true,
    url: 'https://weaviate.local',
    collection: 'MemindMemory',
    async embedQuery(query) {
      assert.equal(query, 'memory-chain');
      return [0.1, 0.2];
    },
    client: {
      async search(input) {
        assert.equal(input.collection, 'MemindMemory');
        assert.deepEqual(input.vector, [0.1, 0.2]);
        return [{ id: 'w1', type: 'semantic', content: 'weaviate memory', score: 0.8 }];
      },
    },
  });
  const result = await backend.resolve({ userId: 'u1', query: 'memory-chain' });

  assert.equal(backend.isAvailable(), true);
  assert.deepEqual(result.semanticMemories, ['weaviate memory']);
});

test('weaviate backend validates url and collection', () => {
  assert.throws(
    () => createWeaviateMemoryBackend({ enabled: true, url: 'ftp://weaviate.local' }),
    /Invalid MEMORY_WEAVIATE_URL/,
  );
  assert.throws(
    () => createWeaviateMemoryBackend({ collection: 'bad collection' }),
    /Invalid MEMORY_WEAVIATE_COLLECTION/,
  );
});

test('weaviate HTTP client performs GraphQL vector search', async () => {
  const client = createWeaviateHttpClient({
    url: 'https://weaviate.local',
    apiKey: 'secret',
    async fetchImpl(url, options) {
      const body = JSON.parse(options.body);
      assert.equal(url, 'https://weaviate.local/v1/graphql');
      assert.equal(options.headers.authorization, 'Bearer secret');
      assert.deepEqual(body.variables.where, {
        path: ['user_id'],
        operator: 'Equal',
        valueText: 'u1',
      });
      assert.match(body.query, /limit:\s*2/);
      return {
        ok: true,
        async json() {
          return {
            data: {
              Get: {
                MemindMemory: [{
                  content: 'weaviate memory',
                  type: 'semantic',
                  _additional: { id: 'w1', certainty: 0.91 },
                }],
              },
            },
          };
        },
      };
    },
  });

  const result = await client.search({
    collection: 'MemindMemory',
    vector: [0.1, 0.2],
    userId: 'u1',
    limit: 2,
  });

  assert.deepEqual(result, [{
    id: 'w1',
    label: 'semantic',
    text: 'weaviate memory',
    score: 0.91,
    createdAt: undefined,
  }]);
});

test('neo4j backend is disabled by default and delegates only with explicit client', async () => {
  const disabled = createNeo4jMemoryBackend();
  assert.equal(disabled.name, 'neo4j');
  assert.equal(disabled.category, 'behavior');
  assert.equal(disabled.role, 'behavior-graph');
  assert.equal(disabled.flag, 'MEMORY_NEO4J_ENABLED');
  assert.equal(disabled.isAvailable(), false);
  assert.equal(disabled.getUnavailableReason(), 'not_configured');
  assert.equal(inspectMemoryV2Backend(disabled).ok, true);

  const backend = createNeo4jMemoryBackend({
    enabled: true,
    uri: 'neo4j://localhost:7687',
    username: 'neo4j',
    password: 'secret',
    client: {
      async resolve() {
        return { behaviorSummary: 'prefers careful rollouts' };
      },
      async write() {
        return { saved: 1, analyzed: 0, memories: 0 };
      },
    },
  });

  assert.equal(backend.isAvailable(), true);
  assert.equal((await backend.resolve({ userId: 'u1' })).behaviorSummary, 'prefers careful rollouts');
  assert.deepEqual(await backend.write({ userId: 'u1' }), { saved: 1, analyzed: 0, memories: 0 });
});

test('neo4j HTTP client writes and resolves through transactional endpoint', async () => {
  const calls = [];
  const client = createNeo4jHttpClient({
    httpUrl: 'http://neo4j.local:7474',
    username: 'neo4j',
    password: 'secret',
    async fetchImpl(url, options) {
      calls.push({ url, body: JSON.parse(options.body), headers: options.headers });
      return {
        ok: true,
        async json() {
          if (calls.length === 1) return { results: [{ data: [{ row: [1] }] }] };
          return { results: [{ data: [{ row: ['prefers careful rollouts'] }] }] };
        },
      };
    },
  });

  assert.deepEqual(await client.write({
    userId: 'u1',
    sessionId: 's1',
    messages: [{ text: 'hello' }],
  }), { saved: 1, analyzed: 0, memories: 0 });
  assert.equal((await client.resolve({ userId: 'u1' })).behaviorSummary, 'prefers careful rollouts');
  assert.equal(calls[0].url, 'http://neo4j.local:7474/db/neo4j/tx/commit');
  assert.match(calls[0].headers.authorization, /^Basic /);
  assert.match(calls[0].body.statements[0].statement, /CREATE \(e:MemoryEvent/);
});

test('redis-streams backend is write-only and client-injected', async () => {
  const disabled = createRedisStreamsMemoryBackend();
  assert.equal(disabled.name, 'redis-streams');
  assert.equal(disabled.category, 'behavior');
  assert.equal(disabled.role, 'event-tracking');
  assert.equal(disabled.flag, 'MEMORY_REDIS_STREAMS_ENABLED');
  assert.equal(disabled.isAvailable(), false);
  assert.equal(disabled.getUnavailableReason(), 'not_configured');
  assert.equal(inspectMemoryV2Backend(disabled).ok, true);
  assert.equal(typeof disabled.resolve, 'undefined');

  const backend = createRedisStreamsMemoryBackend({
    enabled: true,
    url: 'redis://localhost:6379',
    stream: 'memind:memory-events',
    client: {
      async write(input) {
        assert.equal(input.stream, 'memind:memory-events');
        return { saved: 1, analyzed: 0, memories: 0 };
      },
    },
  });

  assert.equal(backend.isAvailable(), true);
  assert.deepEqual(await backend.write({ userId: 'u1' }), { saved: 1, analyzed: 0, memories: 0 });
});

test('redis streams client connects lazily, xadds event, and closes', async () => {
  const calls = [];
  const client = await createRedisStreamsClient({
    url: 'redis://localhost:6379',
    async importRedis() {
      return {
        createClient(options) {
          calls.push(['createClient', options.url]);
          return {
            async connect() {
              calls.push(['connect']);
            },
            async xAdd(stream, id, fields) {
              calls.push(['xAdd', stream, id, fields.user_id]);
            },
            async quit() {
              calls.push(['quit']);
            },
          };
        },
      };
    },
  });

  assert.deepEqual(await client.write({ userId: 'u1', sessionId: 's1', messages: [] }), {
    saved: 1,
    analyzed: 0,
    memories: 0,
  });
  await client.close();
  assert.deepEqual(calls.map((call) => call.slice(0, 3)), [
    ['createClient', 'redis://localhost:6379'],
    ['connect'],
    ['xAdd', 'memind:memory-events', '*'],
    ['quit'],
  ]);
});

test('langgraph backend is disabled by default and delegates policy resolve only with client', async () => {
  const disabled = createLangGraphMemoryBackend();
  assert.equal(disabled.name, 'langgraph');
  assert.equal(disabled.category, 'policy');
  assert.equal(disabled.role, 'routing-reasoning-policy');
  assert.equal(disabled.flag, 'MEMORY_LANGGRAPH_ENABLED');
  assert.equal(disabled.isAvailable(), false);
  assert.equal(disabled.getUnavailableReason(), 'not_configured');
  assert.equal(inspectMemoryV2Backend(disabled).ok, true);

  const backend = createLangGraphMemoryBackend({
    enabled: true,
    policyId: 'memory_policy',
    client: {
      async resolve(input) {
        assert.equal(input.policyId, 'memory_policy');
        return { activeGoals: ['route-memory'] };
      },
    },
  });

  assert.equal(backend.isAvailable(), true);
  assert.deepEqual((await backend.resolve({ userId: 'u1' })).activeGoals, ['route-memory']);
});

test('langgraph HTTP client posts resolve payload', async () => {
  const client = createLangGraphHttpClient({
    baseUrl: 'https://langgraph.local',
    apiKey: 'secret',
    modelProviderKeyId: 'key_langgraph',
    model: 'gpt-4.1-nano',
    modelApiType: 'response',
    async fetchImpl(url, options) {
      assert.equal(url, 'https://langgraph.local/memory/resolve');
      assert.equal(options.headers.authorization, 'Bearer secret');
      assert.deepEqual(JSON.parse(options.body), {
        user_id: 'u1',
        session_id: 's1',
        query: 'hello',
        policy_id: 'memory_policy',
        limit: 3,
        model_provider_key_id: 'key_langgraph',
        model: 'gpt-4.1-nano',
        model_api_type: 'response',
      });
      return {
        ok: true,
        async json() {
          return { activeGoals: ['route-memory'] };
        },
      };
    },
  });

  assert.deepEqual(await client.resolve({
    userId: 'u1',
    sessionId: 's1',
    query: 'hello',
    policyId: 'memory_policy',
    limit: 3,
  }), { activeGoals: ['route-memory'] });
});

test('external adapter skeletons validate unsafe config values', () => {
  assert.throws(
    () => createNeo4jMemoryBackend({ uri: 'http://localhost:7474' }),
    /Invalid MEMORY_NEO4J_URI/,
  );
  assert.throws(
    () => createRedisStreamsMemoryBackend({ url: 'http://localhost:6379' }),
    /Invalid MEMORY_REDIS_STREAMS_URL/,
  );
  assert.throws(
    () => createRedisStreamsMemoryBackend({ stream: 'bad stream' }),
    /Invalid MEMORY_REDIS_STREAMS_STREAM/,
  );
  assert.throws(
    () => createLangGraphMemoryBackend({ policyId: 'bad policy id' }),
    /Invalid MEMORY_LANGGRAPH_POLICY_ID/,
  );
});