import { describe, expect, it } from "vitest";
import { z } from "zod/v4";
import { ui } from "../tree/tree";
import {
  ColineAppDefinitionError,
  defineApp,
  defineFileType,
  defineTool,
} from "./define";
import { extractManifestInput, extractToolMetadata } from "./extraction";

const createContact = defineTool({
  name: "crm.create_contact",
  description: "Create a contact in the CRM.",
  input: z.object({
    name: z.string(),
    email: z.string().optional(),
  }),
  effect: "write",
  execute: (input) => ({ output: { created: input.name } }),
});

const contactFileType = defineFileType({
  metadata: {
    typeKey: "crm.contact",
    name: "Contact",
    surfaces: {
      preview: { tier: "tree" },
      inline: { tier: "tree" },
    },
  },
  runtime: {
    renderPreview: () => ui.text("preview"),
    renderInline: () => ui.text("inline"),
    index: {
      title: (document) => String(document.name ?? "Contact"),
      body: (document) => String(document.email ?? ""),
    },
  },
});

describe("extractToolMetadata", () => {
  it("produces the manifest artifact and strips execute", () => {
    const metadata = extractToolMetadata(createContact);
    expect(metadata).toEqual({
      name: "crm.create_contact",
      description: "Create a contact in the CRM.",
      inputSchema: expect.objectContaining({ type: "object" }),
      effect: "write",
    });
    expect("execute" in metadata).toBe(false);
    const properties = metadata.inputSchema.properties as Record<string, unknown>;
    expect(Object.keys(properties)).toEqual(["name", "email"]);
  });

  it("is deterministic", () => {
    expect(extractToolMetadata(createContact)).toEqual(
      extractToolMetadata(createContact),
    );
  });
});

describe("defineApp", () => {
  it("builds a validated manifest artifact and a runtime artifact", () => {
    const app = defineApp({
      key: "crm",
      name: "CRM",
      permissions: ["files.read", "files.write", "ai.tools", "storage.app"],
      surfaces: { home: { tier: "tree" } },
      files: [contactFileType],
      tools: [createContact],
      handlers: { renderHome: () => ui.text("home") },
    });

    expect(app.manifest.key).toBe("crm");
    expect(app.manifest.tools).toHaveLength(1);
    expect(app.manifest.tools[0]?.effect).toBe("write");
    expect(app.runtime.tools.get("crm.create_contact")).toBe(createContact);
    expect(app.runtime.fileTypes.get("crm.contact")?.renderPreview).toBeDefined();
    expect(app.runtime.renderHome).not.toBeNull();
  });

  it("round-trips: extraction input parses to the same manifest", () => {
    const config = {
      key: "crm",
      name: "CRM",
      permissions: ["ai.tools" as const],
      tools: [createContact],
    };
    const first = extractManifestInput({ ...config, tools: [createContact] });
    const second = extractManifestInput({ ...config, tools: [createContact] });
    expect(first).toEqual(second);
  });

  it("throws with readable issues on an invalid manifest", () => {
    expect(() =>
      defineApp({
        key: "crm",
        name: "CRM",
        tools: [createContact],
      }),
    ).toThrowError(ColineAppDefinitionError);
    try {
      defineApp({ key: "crm", name: "CRM", tools: [createContact] });
    } catch (error) {
      expect((error as ColineAppDefinitionError).issues.join("\n")).toContain(
        "ai.tools",
      );
    }
  });

  it("enforces runtime completeness for tree surfaces", () => {
    expect(() =>
      defineApp({
        key: "crm",
        name: "CRM",
        surfaces: { home: { tier: "tree" } },
      }),
    ).toThrowError(/renderHome/);

    expect(() =>
      defineApp({
        key: "crm",
        name: "CRM",
        files: [
          defineFileType({
            metadata: {
              typeKey: "crm.contact",
              name: "Contact",
              surfaces: { preview: { tier: "tree" } },
            },
          }),
        ],
      }),
    ).toThrowError(/renderPreview/);
  });

  it("requires index extractors for indexable stored file types", () => {
    expect(() =>
      defineApp({
        key: "crm",
        name: "CRM",
        files: [
          defineFileType({
            metadata: { typeKey: "crm.contact", name: "Contact" },
          }),
        ],
      }),
    ).toThrowError(/index extractors/);

    expect(() =>
      defineApp({
        key: "crm",
        name: "CRM",
        files: [
          defineFileType({
            metadata: { typeKey: "crm.contact", name: "Contact", indexable: false },
          }),
        ],
      }),
    ).not.toThrow();
  });
});