import { describe, expect, it } from "vitest";
import { z } from "zod/v4";
import { defineApp, defineTool } from "../define/define";
import { ui } from "../tree/tree";
import { createColineToolHandler } from "./app-server";
import {
  buildSignedProtocolRequest,
  type ColineProtocolEnvelope,
} from "./protocol";
import { TOOL_INVOKE_KIND, type ToolInvokePayload } from "./tool-invoke";

const SECRET = "delivery-secret-of-sufficient-length";

const createContact = defineTool({
  name: "crm.create_contact",
  description: "Create a contact.",
  input: z.object({ name: z.string() }),
  effect: "write",
  execute: async (input, context) => {
    const file = await context.coline.files.create({
      typeKey: "crm.contact",
      name: input.name,
    });
    return {
      output: { fileId: file.fileId },
      card: ui.stack([ui.text(`Created ${input.name}`)]),
    };
  },
});

const badCardTool = defineTool({
  name: "crm.bad_card",
  description: "Returns a disallowed card.",
  input: z.object({}),
  effect: "read",
  execute: () => ({
    card: ui.input({ name: "nope" }),
  }),
});

const app = defineApp({
  key: "crm",
  name: "CRM",
  permissions: ["files.read", "files.write", "ai.tools"],
  tools: [createContact, badCardTool],
});

function buildEnvelope(payload: ToolInvokePayload): ColineProtocolEnvelope {
  return {
    protocol: 2,
    deliveryId: "dlv_0123456789",
    sentAt: new Date().toISOString(),
    workspace: { workspaceId: "ws_1", workspaceSlug: "acme" },
    app: { appKey: "crm", installId: "inst_1" },
    actor: { kind: "user", userId: "user_1" },
    kind: TOOL_INVOKE_KIND,
    payload,
  };
}

async function invoke(payload: ToolInvokePayload, options?: { secret?: string }) {
  const signed = await buildSignedProtocolRequest({
    secret: options?.secret ?? SECRET,
    envelope: buildEnvelope(payload),
  });
  const handler = createColineToolHandler({ app, secret: SECRET });
  const response = await handler(
    new Request("https://crm.example.com/coline/tools", {
      method: "POST",
      headers: signed.headers,
      body: signed.body,
    }),
  );
  return { status: response.status, body: (await response.json()) as Record<string, unknown> };
}

const capabilities = { url: "https://coline.test/api/v1/apps/capability", token: "tok_0123456789abcdef" };

describe("createColineToolHandler", () => {
  it("executes a tool with capability-backed context and returns output + card", async () => {
    const originalFetch = globalThis.fetch;
    globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
      const body = JSON.parse(String(init?.body)) as { operation: string; args: unknown[] };
      expect(String(input)).toBe(capabilities.url);
      expect(body.operation).toBe("files.create");
      expect((init?.headers as Record<string, string>).authorization).toBe(
        `Bearer ${capabilities.token}`,
      );
      return new Response(
        JSON.stringify({ data: { fileId: "file_9", name: "Sarah", typeKey: "crm.contact" } }),
        { headers: { "content-type": "application/json" } },
      );
    }) as typeof fetch;

    try {
      const { status, body } = await invoke({
        tool: "crm.create_contact",
        input: { name: "Sarah" },
        capabilities,
      });
      expect(status).toBe(200);
      const result = body.result as { output: { fileId: string }; card: unknown };
      expect(result.output.fileId).toBe("file_9");
      expect(result.card).toBeDefined();
    } finally {
      globalThis.fetch = originalFetch;
    }
  });

  it("rejects bad signatures", async () => {
    const { status, body } = await invoke(
      { tool: "crm.create_contact", input: { name: "Sarah" }, capabilities },
      { secret: "the-wrong-secret-of-sufficient-length" },
    );
    expect(status).toBe(401);
    expect((body.error as { code: string }).code).toBe("invalid_signature");
  });

  it("rejects unknown tools", async () => {
    const { status, body } = await invoke({
      tool: "crm.nonexistent",
      input: {},
      capabilities,
    });
    expect(status).toBe(404);
    expect((body.error as { code: string }).code).toBe("unknown_tool");
  });

  it("rejects invalid input with issue detail", async () => {
    const { status, body } = await invoke({
      tool: "crm.create_contact",
      input: { name: 42 },
      capabilities,
    });
    expect(status).toBe(400);
    expect((body.error as { code: string }).code).toBe("invalid_input");
  });

  it("rejects cards outside the chat subset", async () => {
    const { status, body } = await invoke({
      tool: "crm.bad_card",
      input: {},
      capabilities,
    });
    expect(status).toBe(400);
    expect((body.error as { code: string }).code).toBe("invalid_card");
  });
});