import fs from "node:fs/promises";
import os from "node:os";
import path from "node:path";
import { setTimeout as sleep } from "node:timers/promises";
import type { OpenClawConfig } from "openclaw/plugin-sdk/memory-core-host-engine-foundation";
import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
import "./test-runtime-mocks.js";
import type { MemoryIndexManager } from "./index.js";

type MemoryIndexModule = typeof import("./index.js");
type ManagerModule = typeof import("./manager.js");

const hoisted = vi.hoisted(() => ({
  providerCreateCalls: 0,
  providerDelayMs: 0,
}));

vi.mock("./embeddings.js", () => ({
  createEmbeddingProvider: async () => {
    hoisted.providerCreateCalls += 1;
    if (hoisted.providerDelayMs > 0) {
      await sleep(hoisted.providerDelayMs);
    }
    return {
      requestedProvider: "openai",
      provider: {
        id: "mock",
        model: "mock-embed",
        maxInputTokens: 8192,
        embedQuery: async () => [0, 1, 0],
        embedBatch: async (texts: string[]) => texts.map(() => [0, 1, 0]),
      },
    };
  },
}));

let getMemorySearchManager: MemoryIndexModule["getMemorySearchManager"];
let closeAllMemorySearchManagers: MemoryIndexModule["closeAllMemorySearchManagers"];
let closeAllMemoryIndexManagers: ManagerModule["closeAllMemoryIndexManagers"];
let RawMemoryIndexManager: ManagerModule["MemoryIndexManager"];

describe("memory manager cache hydration", () => {
  let workspaceDir = "";

  beforeAll(async () => {
    ({ getMemorySearchManager, closeAllMemorySearchManagers } = await import("./index.js"));
    ({ closeAllMemoryIndexManagers, MemoryIndexManager: RawMemoryIndexManager } =
      await import("./manager.js"));
  });

  beforeEach(async () => {
    await closeAllMemoryIndexManagers();
    vi.clearAllMocks();
    workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "openclaw-mem-concurrent-"));
    await fs.mkdir(path.join(workspaceDir, "memory"), { recursive: true });
    await fs.writeFile(path.join(workspaceDir, "MEMORY.md"), "Hello memory.");
    hoisted.providerCreateCalls = 0;
    hoisted.providerDelayMs = 50;
  });

  afterEach(async () => {
    await closeAllMemorySearchManagers();
    await fs.rm(workspaceDir, { recursive: true, force: true });
  });

  function createMemoryConcurrencyConfig(indexPath: string): OpenClawConfig {
    return {
      agents: {
        defaults: {
          workspace: workspaceDir,
          memorySearch: {
            provider: "openai",
            model: "mock-embed",
            store: { path: indexPath, vector: { enabled: false } },
            sync: { watch: false, onSessionStart: false, onSearch: false },
          },
        },
        list: [{ id: "main", default: true }],
      },
    } as OpenClawConfig;
  }

  it("deduplicates concurrent manager creation for the same cache key", async () => {
    const indexPath = path.join(workspaceDir, "index.sqlite");
    const cfg = createMemoryConcurrencyConfig(indexPath);

    const results = await Promise.all(
      Array.from(
        { length: 12 },
        async () => await getMemorySearchManager({ cfg, agentId: "main" }),
      ),
    );
    const managers = results
      .map((result) => result.manager)
      .filter((manager): manager is MemoryIndexManager => Boolean(manager));

    expect(managers).toHaveLength(12);
    expect(new Set(managers).size).toBe(1);
    expect(hoisted.providerCreateCalls).toBe(0);

    await managers[0].close();
  });

  it("evicts cached managers during global teardown", async () => {
    const indexPath = path.join(workspaceDir, "index.sqlite");
    const cfg = createMemoryConcurrencyConfig(indexPath);

    const pendingResult = RawMemoryIndexManager.get({ cfg, agentId: "main" });
    await closeAllMemoryIndexManagers();
    const firstManager = await pendingResult;

    const secondManager = await RawMemoryIndexManager.get({ cfg, agentId: "main" });

    expect(firstManager).toBeTruthy();
    expect(secondManager).toBeTruthy();
    expect(Object.is(secondManager, firstManager)).toBe(false);
    expect(hoisted.providerCreateCalls).toBe(0);

    await secondManager?.close?.();
  });

  it("does not identity-cache status-only managers", async () => {
    const indexPath = path.join(workspaceDir, "index.sqlite");
    const cfg = createMemoryConcurrencyConfig(indexPath);

    const first = await RawMemoryIndexManager.get({ cfg, agentId: "main", purpose: "status" });
    const second = await RawMemoryIndexManager.get({ cfg, agentId: "main", purpose: "status" });

    expect(first).toBeTruthy();
    expect(second).toBeTruthy();
    expect(Object.is(second, first)).toBe(false);
    expect(hoisted.providerCreateCalls).toBe(0);

    await first?.close?.();
    await second?.close?.();
  });
});