import { assert, beforeEach, it, vi } from "vite-plus/test";
import type { EnvironmentId } from "@t3tools/contracts";
import { AtomRegistry } from "effect/unstable/reactivity";

import {
  type ComposerPathSearchClient,
  createComposerPathSearchManager,
  EMPTY_COMPOSER_PATH_SEARCH_STATE,
  getComposerPathSearchTargetKey,
} from "./composerPathSearchState.ts";

let registry = AtomRegistry.make();

const noop = () => undefined;

beforeEach(() => {
  registry.dispose();
  registry = AtomRegistry.make();
});

function flushAsyncWork(): Promise<void> {
  return Promise.resolve().then(() => undefined);
}

const TARGET = {
  environmentId: "env-local" as EnvironmentId,
  cwd: "/repo",
  query: "src",
};

it("derives null keys for inactive path searches", () => {
  assert.strictEqual(getComposerPathSearchTargetKey({ ...TARGET, query: "" }), null);
  assert.strictEqual(getComposerPathSearchTargetKey({ ...TARGET, cwd: null }), null);
  assert.strictEqual(getComposerPathSearchTargetKey({ ...TARGET, environmentId: null }), null);
});

it("stores path search results in atom state", async () => {
  const manager = createComposerPathSearchManager({
    getRegistry: () => registry,
    debounceMs: 0,
    getClient: () => ({
      searchEntries: async () => ({
        entries: [
          { path: "src/index.ts", kind: "file" },
          { path: "src/components", kind: "directory" },
        ],
        truncated: false,
      }),
    }),
  });

  manager.search(TARGET);
  await flushAsyncWork();

  assert.deepStrictEqual(manager.getSnapshot(TARGET), {
    entries: [
      { path: "src/index.ts", kind: "file" },
      { path: "src/components", kind: "directory" },
    ],
    isPending: false,
    error: null,
  });
});

it("reuses fresh cached path search results", async () => {
  const searchEntries = vi.fn(async () => ({
    entries: [{ path: "src/index.ts", kind: "file" as const }],
    truncated: false,
  }));
  const manager = createComposerPathSearchManager({
    getRegistry: () => registry,
    debounceMs: 0,
    staleTimeMs: 15_000,
    getClient: () => ({ searchEntries }),
  });

  manager.search(TARGET);
  await flushAsyncWork();
  manager.search(TARGET);
  await flushAsyncWork();

  assert.strictEqual(searchEntries.mock.calls.length, 1);
  assert.deepStrictEqual(manager.getSnapshot(TARGET), {
    entries: [{ path: "src/index.ts", kind: "file" }],
    isPending: false,
    error: null,
  });
});

it("invalidates watched path searches and refreshes without clearing entries", async () => {
  type SearchResult = Awaited<ReturnType<ComposerPathSearchClient["searchEntries"]>>;

  let resolveSecond: (value: SearchResult) => void = noop;
  let callCount = 0;
  const searchEntries = vi.fn((() => {
    callCount += 1;
    if (callCount === 1) {
      return Promise.resolve({
        entries: [{ path: "src/old.ts", kind: "file" as const }],
        truncated: false,
      });
    }
    return new Promise((resolve) => {
      resolveSecond = resolve;
    });
  }) satisfies ComposerPathSearchClient["searchEntries"]);
  const manager = createComposerPathSearchManager({
    getRegistry: () => registry,
    debounceMs: 0,
    staleTimeMs: 15_000,
    getClient: () => ({ searchEntries }),
  });

  const unwatch = manager.watch(TARGET);
  await flushAsyncWork();
  manager.invalidate();

  assert.deepStrictEqual(manager.getSnapshot(TARGET), {
    entries: [{ path: "src/old.ts", kind: "file" }],
    isPending: true,
    error: null,
  });

  resolveSecond({
    entries: [{ path: "src/new.ts", kind: "file" }],
    truncated: false,
  });
  await flushAsyncWork();

  assert.deepStrictEqual(manager.getSnapshot(TARGET), {
    entries: [{ path: "src/new.ts", kind: "file" }],
    isPending: false,
    error: null,
  });
  assert.strictEqual(searchEntries.mock.calls.length, 2);
  unwatch();
});

it("ignores stale path search results after a newer request starts", async () => {
  let resolveFirst: (value: {
    entries: ReadonlyArray<{ path: string; kind: "file" | "directory" }>;
    truncated: boolean;
  }) => void = noop;
  const manager = createComposerPathSearchManager({
    getRegistry: () => registry,
    debounceMs: 0,
    getClient: () => ({
      searchEntries: (input: Parameters<ComposerPathSearchClient["searchEntries"]>[0]) => {
        if (input.query === "first") {
          return new Promise((resolve) => {
            resolveFirst = resolve;
          });
        }
        return Promise.resolve({
          entries: [{ path: "second.ts", kind: "file" }],
          truncated: false,
        });
      },
    }),
  });

  manager.search({ ...TARGET, query: "first" });
  manager.search({ ...TARGET, query: "second" });
  await flushAsyncWork();
  resolveFirst({ entries: [{ path: "first.ts", kind: "file" }], truncated: false });
  await flushAsyncWork();

  assert.deepStrictEqual(manager.getSnapshot({ ...TARGET, query: "second" }), {
    entries: [{ path: "second.ts", kind: "file" }],
    isPending: false,
    error: null,
  });
});

it("returns the empty snapshot for inactive targets", () => {
  const manager = createComposerPathSearchManager({
    getRegistry: () => registry,
    getClient: () => null,
  });

  assert.deepStrictEqual(
    manager.getSnapshot({ environmentId: null, cwd: null, query: null }),
    EMPTY_COMPOSER_PATH_SEARCH_STATE,
  );
});