import { describe, expect, it } from "@effect/vitest";

import { createExecutor, ProviderItemId, ProviderKey, type CredentialProvider } from "./promise";
import { definePlugin, tool } from "./plugin";
import type { ToolDef } from "./tool";
import { IntegrationSlug, ToolName } from "./ids";
import { Effect, Schema } from "effect";

// A minimal static-tool plugin built on the Effect surface, consumed
// through the Promise façade. Exercises the proxy's ability to promisify
// nested methods (executor.execute) and plugin extensions.
//
// v2: static plugin tools are invoked by their fqid through `executor.execute`
// (the per-connection `tools.<int>.<owner>.<conn>.<tool>` catalog is separate).
const echoPlugin = definePlugin(() => ({
  id: "echo" as const,
  storage: () => ({}),
  staticIntegrations: () => [
    {
      id: "echo.ctl",
      kind: "control" as const,
      name: "Echo Ctl",
      tools: [
        tool({
          name: "say",
          description: "Echo the input",
          inputSchema: Schema.toStandardSchemaV1(
            Schema.toStandardJSONSchemaV1(Schema.Struct({ message: Schema.String })),
          ),
          execute: (input) => Effect.succeed(input.message),
        }),
      ],
    },
  ],
  extension: () => ({
    greet: (name: string) => Effect.succeed(`hello, ${name}`) as Effect.Effect<string, never>,
  }),
}));

describe("promise/createExecutor", () => {
  it("returns Promise-shaped executor and invokes static tools", async () => {
    const plugins = [echoPlugin()] as const;
    const executor = await createExecutor({
      plugins,
      onElicitation: "accept-all",
    });

    const out = await executor.execute("echo.ctl.say", { message: "hi" });
    expect(out).toBe("hi");

    await executor.close();
  });

  it("promisifies plugin extension methods", async () => {
    const plugins = [echoPlugin()] as const;
    const executor = await createExecutor({
      plugins,
      onElicitation: "accept-all",
    });

    const greeting = await executor.echo.greet("world");
    expect(greeting).toBe("hello, world");

    await executor.close();
  });

  it("per-invoke onElicitation override wins over the executor-level default", async () => {
    // Build a tool that requires approval — the elicitation goes through
    // `enforceApproval` (outside wrapInvocationError), so a decline
    // surfaces as a typed `ElicitationDeclinedError` rather than a
    // wrapped invocation error.
    const approvedPlugin = definePlugin(() => ({
      id: "ap" as const,
      storage: () => ({}),
      staticIntegrations: () => [
        {
          id: "ap.ctl",
          kind: "control" as const,
          name: "Ap Ctl",
          tools: [
            tool({
              name: "go",
              description: "Requires approval",
              annotations: { requiresApproval: true } as const,
              inputSchema: Schema.toStandardSchemaV1(
                Schema.toStandardJSONSchemaV1(Schema.Struct({})),
              ),
              execute: () => Effect.succeed("ran"),
            }),
          ],
        },
      ],
    }));

    const plugins = [approvedPlugin()] as const;
    const executor = await createExecutor({
      plugins,
      onElicitation: "accept-all", // default → auto-approve
    });

    // No override → executor-level accept-all → tool runs.
    const ran = await executor.execute("ap.ctl.go", {});
    expect(ran).toBe("ran");

    // Override with a declining handler -> rejects with ElicitationDeclinedError.
    await expect(
      executor.execute(
        "ap.ctl.go",
        {},
        {
          onElicitation: async () => ({ action: "decline" as const }),
        },
      ),
    ).rejects.toMatchObject({
      name: expect.stringMatching(/ElicitationDeclinedError/),
    });

    await executor.close();
  });

  it("threads config `providers` so inline connection values produce tools", async () => {
    // A plugin that registers an integration and produces two tools per
    // connection. The writable credential store is supplied via the Promise
    // façade's `providers` config (not the plugin) — proving createExecutor
    // threads `config.providers` into the Effect executor so the default
    // writable provider exists for `connections.create({ value })`.
    const inventoryPlugin = definePlugin(() => ({
      id: "inventory" as const,
      storage: () => ({}),
      resolveTools: () =>
        Effect.succeed({
          tools: [
            { name: ToolName.make("listItems"), description: "list" } satisfies ToolDef,
            { name: ToolName.make("getItem"), description: "get" } satisfies ToolDef,
          ],
        }),
      extension: (ctx) => ({
        seed: () =>
          ctx.core.integrations.register({
            slug: IntegrationSlug.make("inventory"),
            description: "Inventory API",
            config: {},
          }) as Effect.Effect<void, never>,
      }),
    }));

    const store = new Map<string, string>();
    const memoryProvider: CredentialProvider = {
      key: ProviderKey.make("memory"),
      writable: true,
      get: (id: ProviderItemId) => Effect.sync(() => store.get(String(id)) ?? null),
      set: (id: ProviderItemId, value: string) =>
        Effect.sync(() => {
          store.set(String(id), value);
        }),
    };

    const plugins = [inventoryPlugin()] as const;
    const executor = await createExecutor({
      plugins,
      providers: [memoryProvider],
      onElicitation: "accept-all",
    });

    await executor.inventory.seed();

    const connection = await executor.connections.create({
      owner: "org",
      name: "default",
      integration: "inventory",
      template: "apiKey",
      value: "inventory-api-key",
    });
    expect(String(connection.provider)).toBe("memory");
    // The inline value was written to the config-supplied provider.
    expect([...store.values()]).toContain("inventory-api-key");

    const tools = await executor.tools.list({ integration: "inventory" });
    expect(tools.map((t) => String(t.name)).sort()).toEqual(["getItem", "listItems"]);

    await executor.close();
  });
});