import { afterEach, beforeEach, describe, expect, it } from "bun:test";
import { mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";

import { ResultReferenceResolver } from "../../src/results/resolver.js";
import {
  RESULT_REFERENCE_KIND,
  RESULT_REFERENCE_SOURCE,
  ResultReferenceStore,
} from "../../src/results/store.js";

describe("ResultReferenceResolver", () => {
  let tempDir: string;
  let store: ResultReferenceStore;
  let resolver: ResultReferenceResolver;

  beforeEach(async () => {
    tempDir = await mkdtemp(join(tmpdir(), "tjwater-result-ref-"));
    store = new ResultReferenceStore(tempDir, 60_000);
    resolver = new ResultReferenceResolver(store);
    await store.initialize();
  });

  afterEach(async () => {
    await rm(tempDir, { force: true, recursive: true });
  });

  it("stores metadata for server API result refs and resolves them", async () => {
    const record = await resolver.register({
      actorKey: "actor-1",
      clientSessionId: "client-1",
      data: {
        data: [{ asset_id: "asset-1", value: 1.23 }],
        meta: { rows: 1 },
      },
      kind: RESULT_REFERENCE_KIND.serverApiPayload,
      projectId: "project-1",
      projectKey: "project-key-1",
      schemaVersion: 1,
      sessionId: "session-1",
      source: RESULT_REFERENCE_SOURCE.serverApi,
      traceId: "trace-1",
    });

    expect(record.kind).toBe(RESULT_REFERENCE_KIND.serverApiPayload);
    expect(record.schemaVersion).toBe(1);
    expect(record.source).toBe(RESULT_REFERENCE_SOURCE.serverApi);

    const result = await resolver.getFullAuthorized(
      record.resultRef,
      {
        actorKey: "actor-1",
        projectId: "project-1",
      },
    );

    expect(result).not.toBeNull();
    expect(result?.kind).toBe(RESULT_REFERENCE_KIND.serverApiPayload);
    expect(result?.schema_version).toBe(1);
    expect(result?.source).toBe(RESULT_REFERENCE_SOURCE.serverApi);
    expect(result?.data).toEqual({
      data: [{ asset_id: "asset-1", value: 1.23 }],
      meta: { rows: 1 },
    });
  });

  it("rejects malformed refs and auth mismatches", async () => {
    const malformedRef = "res-bbbbbbbbbbbbbbbb";
    await writeFile(
      join(tempDir, `${malformedRef}.json`),
      JSON.stringify(
        {
          resultRef: malformedRef,
          createdAt: "2026-05-21T00:00:00.000Z",
          data: { value: 1 },
          preview: {
            count: 1,
            fields: ["value"],
            sample: { value: 1 },
            summary: "object<1 fields>",
          },
          projectId: "project-1",
          projectKey: "project-key-1",
          sessionId: "session-1",
          sizeBytes: 10,
          traceId: "trace-1",
        },
        null,
        2,
      ),
      "utf8",
    );

    const malformed = await store.getAuthorizedRecord(malformedRef, {
      actorKey: "actor-1",
      projectId: "project-1",
    });
    expect(malformed).toBeNull();

    const serverRecord = await resolver.register({
      actorKey: "actor-2",
      clientSessionId: "client-2",
      data: { data: [{ asset_id: "asset-2" }] },
      kind: RESULT_REFERENCE_KIND.serverApiPayload,
      projectId: "project-2",
      projectKey: "project-key-2",
      schemaVersion: 1,
      sessionId: "session-2",
      source: RESULT_REFERENCE_SOURCE.serverApi,
      traceId: "trace-2",
    });

    const wrongActor = await resolver.getFullAuthorized(serverRecord.resultRef, {
      actorKey: "actor-other",
      projectId: "project-2",
    });
    expect(wrongActor).toBeNull();
  });
});