import { describe, expect, it } from "vitest";
import type { LspClient } from "./client.js";
import { createDiagnosticsTool, createFixTool, createStatusTool } from "./tools.js";

function fakeManager(clients: LspClient[] = []) {
  return {
    getClients: async () => clients,
    status: () => clients.map((c) => ({ id: c.serverID, root: c.root, status: "connected" as const })),
    request: async <T>() => null as T | null,
  } as any;
}

function fakeCtx() {
  return { cwd: "/tmp", ui: { setStatus: () => {} }, isProjectTrusted: () => true } as any;
}

describe("createDiagnosticsTool", () => {
  it("formats diagnostics from the manager into the result", async () => {
    const client = {
      serverID: "typescript",
      root: "/tmp",
      diagnostics: new Map([
        [
          "/tmp/a.ts",
          [
            {
              range: { start: { line: 0, character: 0 }, end: { line: 0, character: 5 } },
              severity: 1,
              message: "boom",
            },
          ],
        ],
      ]),
      touchFile: async () => 0,
      waitForDiagnostics: async () => {},
      request: async () => null,
      shutdown: async () => {},
    } as unknown as LspClient;
    const tool = createDiagnosticsTool(() => fakeManager([client]));
    const result = await tool.execute("call-1", { paths: ["/tmp/a.ts"] }, undefined, undefined, fakeCtx());
    const text = (result.content?.[0] as { text?: string } | undefined)?.text ?? "";
    expect(text).toContain("typescript");
    expect(text).toContain("boom");
  });

  it("reports unavailable servers instead of silent zeros", async () => {
    const manager = {
      getClients: async () => [],
      status: () => [{ id: "typescript", root: "/tmp", status: "error" as const }],
      request: async <T>() => null as T | null,
    } as any;
    const tool = createDiagnosticsTool(() => manager);
    const result = await tool.execute("call-1", { paths: ["/tmp/a.ts"] }, undefined, undefined, fakeCtx());
    const text = (result.content?.[0] as { text?: string } | undefined)?.text ?? "";
    expect(text).toContain("No LSP server available for /tmp/a.ts");
    expect(text).toContain("typescript");
  });

  it("resolves relative paths against the workspace root", async () => {
    const client = {
      serverID: "typescript",
      root: "/tmp",
      diagnostics: new Map([
        [
          "/tmp/a.ts",
          [
            {
              range: { start: { line: 0, character: 0 }, end: { line: 0, character: 5 } },
              severity: 1,
              message: "boom",
            },
          ],
        ],
      ]),
      touchFile: async () => 0,
      waitForDiagnostics: async () => {},
      request: async () => null,
      shutdown: async () => {},
    } as unknown as LspClient;
    const tool = createDiagnosticsTool(() => fakeManager([client]));
    const result = await tool.execute("call-1", { paths: ["a.ts"] }, undefined, undefined, fakeCtx());
    const text = (result.content?.[0] as { text?: string } | undefined)?.text ?? "";
    expect(text).toContain("boom");
  });
});

describe("prompt guidelines", () => {
  const cases: Array<[string, () => any]> = [
    ["lsp_diagnostics", () => createDiagnosticsTool(() => fakeManager())],
    ["lsp_status", () => createStatusTool(() => fakeManager())],
    ["lsp_fix", () => createFixTool(() => fakeManager())],
  ];

  it.each(cases)("%s defines promptGuidelines that name the tool", (_name, make) => {
    const tool = make();
    expect(tool.promptGuidelines?.length ?? 0).toBeGreaterThan(0);
    for (const guideline of tool.promptGuidelines ?? []) {
      expect(guideline).toContain(_name);
    }
  });

  it("diagnostics guidelines teach the cold-start wait:full behavior", () => {
    const tool = createDiagnosticsTool(() => fakeManager());
    expect(tool.promptGuidelines?.some((g) => g.includes("wait: \"full\""))).toBe(true);
  });

  it("fix guidelines teach the preview (non-writing) default", () => {
    const tool = createFixTool(() => fakeManager());
    expect(tool.promptGuidelines?.some((g) => g.includes("never writes"))).toBe(true);
  });
});

describe("createStatusTool", () => {
  it("lists connected clients and roots", async () => {
    const client = {
      serverID: "kotlin",
      root: "/tmp/proj",
      diagnostics: new Map(),
      touchFile: async () => 0,
      waitForDiagnostics: async () => {},
      request: async () => null,
      shutdown: async () => {},
    } as unknown as LspClient;
    const tool = createStatusTool(() => fakeManager([client]));
    const result = await tool.execute("call-1", {}, undefined, undefined, fakeCtx());
    const text = (result.content?.[0] as { text?: string } | undefined)?.text ?? "";
    expect(text).toContain("kotlin");
    expect(text).toContain("/tmp/proj");
  });
});