import { beforeEach, describe, expect } from "bun:test"
import { Effect } from "effect"
import { Credential } from "@opencode-ai/core/credential"
import { Integration } from "@opencode-ai/core/integration"
import { WebSearchExa } from "@opencode-ai/core/plugin/websearch/exa"
import { WebSearchParallel } from "@opencode-ai/core/plugin/websearch/parallel"
import { host, integrationHost } from "./host"
import { requests, resetWebSearchFixture, webSearchIntegrationTest } from "./websearch-fixture"

beforeEach(() => {
  resetWebSearchFixture(
    `event: message\ndata: ${JSON.stringify({
      jsonrpc: "2.0",
      id: 1,
      result: { content: [{ type: "text", text: "search results", _meta: { searchTime: 123 } }] },
    })}\n\n`,
  )
})

const it = webSearchIntegrationTest

describe("built-in web search integrations", () => {
  it.effect("registers and disposes an atomic web search integration", () =>
    Effect.gen(function* () {
      const integrations = yield* Integration.Service
      const registration = yield* integrationHost(integrations).register({
        id: "test-websearch",
        name: "Test Web Search",
        methods: [{ type: "key", label: "API key" }],
        websearch: {
          connection: "required",
          execute: (input) => Effect.succeed({ text: input.query }),
        },
      })

      expect(yield* integrations.get(Integration.ID.make("test-websearch"))).toMatchObject({
        name: "Test Web Search",
        methods: [{ type: "key", label: "API key" }],
        websearch: { connection: "required" },
      })
      yield* registration.dispose
      expect(yield* integrations.get(Integration.ID.make("test-websearch"))).toBeUndefined()
    }),
  )

  it.effect("registers Exa with its MCP schema", () =>
    Effect.gen(function* () {
      const integrations = yield* Integration.Service
      yield* WebSearchExa.Plugin.effect(host({ integration: integrationHost(integrations) }))

      const info = yield* integrations.get(Integration.ID.make("exa"))
      expect(info).toMatchObject({
        id: "exa",
        name: "Exa",
        methods: [{ type: "key" }, { type: "env", names: ["EXA_API_KEY"] }],
        websearch: { connection: "optional" },
      })
      const provider = yield* integrations.websearch.get(Integration.ID.make("exa"))
      if (!provider) return yield* Effect.die("Expected Exa web search provider")
      expect(
        yield* provider.execute(
          { query: "effect typescript" },
          { credential: Credential.Key.make({ type: "key", key: "exa secret" }) },
        ),
      ).toEqual({ text: "search results", metadata: { searchTime: 123 } })
      expect(requests).toEqual([
        {
          url: `${WebSearchExa.endpoint}?exaApiKey=exa+secret`,
          headers: expect.any(Object),
          body: {
            jsonrpc: "2.0",
            id: 1,
            method: "tools/call",
            params: {
              name: "web_search_exa",
              arguments: { query: "effect typescript", numResults: 8 },
            },
          },
        },
      ])
    }),
  )

  it.effect("registers Parallel and keeps its credential in the authorization header", () =>
    Effect.gen(function* () {
      resetWebSearchFixture(
        JSON.stringify({
          jsonrpc: "2.0",
          id: 1,
          result: {
            content: [{ type: "text", text: "search results" }],
            structuredContent: {
              search_id: "search_1",
              results: [
                {
                  url: "https://effect.website",
                  title: "Effect",
                  publish_date: null,
                  excerpts: ["Effect documentation"],
                },
              ],
              warnings: null,
              usage: [{ name: "sku_search", count: 1 }],
              session_id: "ses_parallel",
            },
          },
        }),
      )
      const integrations = yield* Integration.Service
      yield* WebSearchParallel.Plugin.effect(host({ integration: integrationHost(integrations) }))
      const provider = yield* integrations.websearch.get(Integration.ID.make("parallel"))
      if (!provider) return yield* Effect.die("Expected Parallel web search provider")

      const output = yield* provider.execute(
        { query: "effect layers" },
        {
          sessionID: "ses_parallel",
          credential: Credential.Key.make({ type: "key", key: "parallel-secret" }),
        },
      )
      expect(output).toEqual({
        text: "search results",
        metadata: {
          search_id: "search_1",
          results: [
            {
              url: "https://effect.website",
              title: "Effect",
              publish_date: null,
              excerpts: ["Effect documentation"],
            },
          ],
          warnings: null,
          usage: [{ name: "sku_search", count: 1 }],
          session_id: "ses_parallel",
        },
      })
      expect(requests[0]).toMatchObject({
        url: WebSearchParallel.endpoint,
        headers: { authorization: "Bearer parallel-secret" },
        body: {
          jsonrpc: "2.0",
          id: 1,
          method: "tools/call",
          params: {
            name: "web_search",
            arguments: {
              objective: "effect layers",
              search_queries: ["effect layers"],
              session_id: "ses_parallel",
            },
          },
        },
      })
      expect(JSON.stringify(output)).not.toContain("parallel-secret")
    }),
  )
})