// C2-03a: library.sync on the bus and the bus host's 60-second timer, with made-up local data.
import test from 'node:test';
import assert from 'node:assert/strict';
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { createServer } from 'node:net';
import { spawn } from 'node:child_process';
import { fileURLToPath } from 'node:url';
import { Store } from '../src/store.mjs';
import { Broker, LIBRARY_VERBS } from '../src/broker.mjs';
import { startBroker } from '../src/runtime.mjs';
import { gitEnv } from '../../seat/src/checkout.mjs';
import { mappingEntry, repo } from '../../library/tests/helpers.mjs';
import * as library from '../../library/src/index.mjs';

const TOKEN = 'fixture-token-9b2e-made-up-0043';
const STATE = { version: 1, branch: 'main', served: 'a'.repeat(40), lastFetch: '2026-10-21T12:00:00.000Z', lastError: null, diverged: null, problems: [] };

function world(t, adapter) {
  const root = mkdtempSync(join(tmpdir(), 'bus-library-sync-')), store = new Store(root);
  t.after(() => { store.close(); rmSync(root, { recursive: true, force: true }); });
  const business = { id: 'acme', human: 'jason', vars: { 'bus.tester': true },
    projects: { books: { ...mappingEntry(), user: 'books-bot' } }, arbiters: { technical: 'chief', delivery: 'chief' }, roles: {chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery'], crossRole: [] } },  coder: { authority: { withinRole: [], crossRole: [] } } } };
  const broker = new Broker({ store, businesses: { acme: business }, library: adapter });
  const human = broker.bindHuman({ business: 'acme', human: 'jason', via: 'cli', outsideAgent: true });
  const agent = broker.bindLaunch({ business: 'acme', role: 'coder', run: 'library-sync-agent', harness: 'pi' });
  const reader = broker.bindReader({ business: 'acme' }), tester = broker.bindTester({ business: 'acme' });
  const call = (cap, verb, args = {}) => Promise.resolve().then(() => broker.request(cap, { verb, args }));
  const refusals = () => store.all("SELECT body FROM events WHERE kind='action.refused'").map(row => JSON.parse(row.body).code);
  return { store, broker, human, agent, reader, tester, call, refusals };
}

const adapter = (sync) => ({ readFile: () => {}, status: () => {}, sync, LibraryError: library.LibraryError });

test('C2-03a library.sync: every agent, the tester and a reader are refused before the adapter runs', async t => {
  let touched = 0;
  const f = world(t, adapter(async () => { touched++; return { state: STATE, code: null }; }));
  await assert.rejects(f.call(f.agent, 'library.sync', { project: 'books' }), { code: 'human-required' });
  await assert.rejects(f.call(f.tester, 'library.sync', { project: 'books' }), { code: 'human-required' });
  await assert.rejects(f.call(f.reader, 'library.sync', { project: 'books' }), { code: 'read-only' });
  assert.equal(touched, 0);
  assert.ok(LIBRARY_VERBS.includes('library.sync'), 'the server awaits it like the other library verbs');
});

test('C2-03a library.sync: the human fetches, accept passes through, and a held sync is a recorded refusal', async t => {
  const seen = [];
  let code = null;
  const f = world(t, adapter(async (context, options) => { seen.push({ context, options }); return { state: STATE, code }; }));
  assert.deepEqual(await f.call(f.human, 'library.sync', { project: 'books' }), { project: 'books', ...STATE });
  assert.equal(seen[0].context.business.id, 'acme');
  assert.equal(seen[0].context.project, 'books');
  assert.deepEqual(seen[0].options, { accept: null });
  await f.call(f.human, 'library.sync', { project: 'books', accept: 'b'.repeat(40) });
  assert.deepEqual(seen[1].options, { accept: 'b'.repeat(40) });
  for (const held of ['library-diverged', 'library-fetch-failed', 'library-credential-missing']) {
    code = held;
    await assert.rejects(f.call(f.human, 'library.sync', { project: 'books' }), { code: held });
  }
  assert.deepEqual(f.refusals(), ['library-diverged', 'library-fetch-failed', 'library-credential-missing']);
  for (const args of [{}, { project: 'books', extra: 1 }, { project: 'books', commit: 'b'.repeat(40) }])
    await assert.rejects(f.call(f.human, 'library.sync', args), { code: 'invalid-request' });
});

test('C2-03a library.sync: a LibraryError keeps its code and a host without sync is not configured', async t => {
  const f = world(t, adapter(async () => { throw new library.LibraryError('library-accept-stale', 'made up'); }));
  await assert.rejects(f.call(f.human, 'library.sync', { project: 'books', accept: 'c'.repeat(40) }), { code: 'library-accept-stale' });
  const none = world(t, adapter(undefined));
  await assert.rejects(none.call(none.human, 'library.sync', { project: 'books' }), { code: 'project-not-configured' });
});

test('C2-03a runtime: a librarySync from a boot config, with no function, is refused', async t => {
  const root = mkdtempSync(join(tmpdir(), 'bus-library-boot-'));
  t.after(() => rmSync(root, { recursive: true, force: true }));
  for (const librarySync of [{}, { intervalMs: 1 }, { command: 'git' }, { command: () => {}, intervalMs: 0 }, { command: () => {}, configDir: 7 }])
    await assert.rejects(startBroker({ dataRoot: root, businesses: {}, librarySync }), { code: 'invalid-host-request' });
});

test('C2-03a runtime: the timer syncs each entry with a user at start and on each tick, logs codes only, and stops on close', { timeout: 20000 }, async t => {
  const f = repo(t), dataRoot = join(f.root, 'data'), configDir = join(f.root, 'config');
  mkdirSync(dataRoot, { mode: 0o700 });
  mkdirSync(join(configDir, 'secrets', 'acme'), { recursive: true, mode: 0o700 });
  writeFileSync(join(configDir, 'secrets', 'acme', library.SLOT), TOKEN + '\n', { mode: 0o600 });
  const business = { id: 'acme', human: 'jason', arbiters: { technical: 'chief', delivery: 'chief' }, roles: {chief: { definition: 'chief-of-staff', authority: { withinRole: ['decision.resolve.technical', 'decision.resolve.delivery'], crossRole: [] } },  coder: { authority: { withinRole: [], crossRole: [] } } },
    projects: { books: { ...mappingEntry(), user: 'books-bot' }, quiet: mappingEntry() } };
  const calls = [];
  // A git that succeeds without fetching: the remote-tracking ref stays absent, so each pass fails.
  const command = (kind, url, opts) => { calls.push({ kind, url, opts }); return { argv: ['--version'], env: gitEnv() }; };
  const lines = [], write = process.stderr.write;
  process.stderr.write = function (chunk, ...rest) {
    if (String(chunk).startsWith('library: ')) { lines.push(String(chunk)); return true; }
    return write.call(this, chunk, ...rest);
  };
  t.after(() => { process.stderr.write = write; });
  const runtime = await startBroker({ dataRoot, businesses: { acme: business }, librarySync: { command, intervalMs: 50, configDir } });
  const deadline = Date.now() + 10000;
  while (calls.length < 2 && Date.now() < deadline) await new Promise(r => setTimeout(r, 10));
  await runtime.close();
  const after = calls.length;
  assert.ok(after >= 2, 'a pass at start and at least one tick');
  assert.ok(calls.every(c => c.kind === 'fetch' && c.opts.slot === join(configDir, 'secrets', 'acme', library.SLOT) && c.opts.user === 'books-bot'));
  assert.equal(new Set(calls.map(c => c.opts.mirror)).size, 1, 'the entry with no user is never synced');
  await new Promise(r => setTimeout(r, 200));
  assert.equal(calls.length, after, 'no pass after close');
  assert.ok(lines.length >= 1);
  for (const line of lines) {
    assert.deepEqual(JSON.parse(line.slice('library: '.length)), { event: 'library-sync-held', business: 'acme', project: 'books', code: 'library-fetch-failed' });
    assert.equal(line.includes(TOKEN), false);
  }
  const mirror = library.mirrorPath({ business, project: 'books', dataRoot });
  assert.equal((await library.readSyncState(mirror, { branch: 'main' })).lastError.code, 'library-fetch-failed');
});

// Row 254 (#1759): the human transport waits past the server's 120 s library hold for library.sync
// only. A stand-in bus answers each request after 6 s, past the 5 s default every other verb keeps.
test('row 254 human-cli: library.sync outlasts the 5 s client default, and library.status does not', { timeout: 20000 }, async t => {
  const root = mkdtempSync(join(tmpdir(), 'bus-library-cli-'));
  const socket = join(root, 'bus.sock'), timers = new Set();
  const server = createServer(conn => {
    let input = '';
    conn.on('error', () => {});
    conn.on('data', b => {
      input += b;
      if (!input.includes('\n')) return;
      const { verb } = JSON.parse(input);
      timers.add(setTimeout(() => { if (!conn.destroyed) conn.end(JSON.stringify({ ok: true, result: { verb } }) + '\n'); }, 6000));
    });
  });
  await new Promise(r => server.listen(socket, r));
  t.after(() => { for (const timer of timers) clearTimeout(timer); server.close(); rmSync(root, { recursive: true, force: true }); });
  const cli = fileURLToPath(new URL('../src/human-cli.mjs', import.meta.url));
  const run = verb => new Promise(resolve => {
    const child = spawn(process.execPath, [cli, socket], { stdio: ['pipe', 'pipe', 'pipe'] });
    let out = '', err = '';
    child.stdout.on('data', b => { out += b; });
    child.stderr.on('data', b => { err += b; });
    child.on('close', status => resolve({ status, out, err }));
    child.stdin.end(JSON.stringify({ business: 'acme', verb, args: { project: 'books' } }) + '\n');
  });
  const [sync, status] = await Promise.all([run('library.sync'), run('library.status')]);
  assert.equal(sync.status, 0, sync.err);
  assert.deepEqual(JSON.parse(sync.out), { verb: 'library.sync' });
  assert.equal(status.status, 2);
  assert.equal(status.err.trim(), 'outcome-unknown');
});