import { test } from "node:test";
import assert from "node:assert/strict";
import { mkdtemp, readFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";

import { useBroker } from "@novox/mesh-sdk/messaging";
import { emit, on } from "@novox/mesh-sdk/events";
import { record } from "../audit.ts";

test("audit-logger records every event to the trail as one line each", async () => {
  const broker = memBroker();
  useBroker(() => broker);
  const dir = await mkdtemp(join(tmpdir(), "audit-"));
  const path = join(dir, "audit.log");

  // The audit-logger's whole behaviour: consume everything, record it.
  await on("**", async (event) => record(event, path));

  process.env.MESH_MODULE = "umami";
  process.env.MESH_NODE = "anchor";
  await emit("site.created", { domain: "my-app" });
  await emit("node.anchor.joined", { role: "worker" }); // a node event, not a module one

  const lines = (await readFile(path, "utf8")).trim().split("\n").map((l) => JSON.parse(l));
  assert.equal(lines.length, 2);
  assert.deepEqual(lines.map((l) => l.type), ["umami.site.created", "node.anchor.joined"]);
  assert.equal(lines[0].source, "umami");
  assert.equal(lines[0].node, "anchor");
  assert.equal(lines[0].body.domain, "my-app");

  delete process.env.MESH_MODULE;
  delete process.env.MESH_NODE;
});

function memBroker() {
  const subs: { pattern: string; handler: (env: { key: string; node: string; body: unknown }) => Promise<void> }[] = [];
  return {
    async request() {
      throw new Error("unused");
    },
    async handle() {
      return () => {};
    },
    async publish<T>(env: { key: string; node: string; body: T }): Promise<void> {
      for (const s of subs) if (match(s.pattern, env.key)) await s.handler(env);
    },
    async subscribe<T>(pattern: string, handler: (env: { key: string; node: string; body: T }) => Promise<void>): Promise<() => void> {
      subs.push({ pattern, handler: handler as (env: { key: string; node: string; body: unknown }) => Promise<void> });
      return () => {};
    },
    async close() {},
  };
}

function match(pattern: string, key: string): boolean {
  return pattern === "#" || pattern === key;
}