import assert from "node:assert/strict";
import test from "node:test";
import { env } from "../src/env.js";
import { searchBrave } from "../src/search/brave.js";

test("searchBrave authenticates, builds filters, and normalizes web results", async () => {
  const originalFetch = globalThis.fetch;
  const originalApiKey = env.BRAVE_SEARCH_API_KEY;
  const fetchCalls: Array<{ input: RequestInfo | URL; init?: RequestInit }> = [];
  env.BRAVE_SEARCH_API_KEY = "test-brave-key";
  globalThis.fetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
    fetchCalls.push({ input, init });
    return new Response(
      JSON.stringify({
        web: {
          results: [
            {
              title: " Brave result ",
              url: "https://docs.example.com/article",
              description: "Main\n snippet",
              extra_snippets: ["Extra snippet one", "Extra snippet two"],
              page_age: "2026-07-18T12:00:00Z",
              profile: { name: "Example Docs" },
            },
            {
              title: "Excluded result",
              url: "https://blocked.example.com/article",
              description: "Should be filtered",
            },
          ],
        },
      }),
      {
        status: 200,
        headers: {
          "content-type": "application/json; charset=utf-8",
          "x-request-id": "brave-request-1",
        },
      }
    );
  }) as typeof fetch;

  try {
    const response = await searchBrave("latest docs", {
      numResults: 5,
      includeDomains: ["https://example.com/path"],
      excludeDomains: ["blocked.example.com"],
    });

    assert.equal(fetchCalls.length, 1);
    const requestUrl = new URL(String(fetchCalls[0]?.input));
    assert.equal(requestUrl.origin + requestUrl.pathname, "https://api.search.brave.com/res/v1/web/search");
    assert.equal(requestUrl.searchParams.get("q"), "latest docs site:example.com -site:blocked.example.com");
    assert.equal(requestUrl.searchParams.get("count"), "5");
    assert.equal(requestUrl.searchParams.get("safesearch"), "moderate");
    assert.equal(requestUrl.searchParams.get("result_filter"), "web");
    assert.equal(requestUrl.searchParams.get("text_decorations"), "false");
    assert.equal(requestUrl.searchParams.get("extra_snippets"), "true");
    assert.equal((fetchCalls[0]?.init?.headers as Record<string, string>)["X-Subscription-Token"], "test-brave-key");

    assert.deepEqual(response, {
      query: "latest docs",
      requestId: "brave-request-1",
      results: [
        {
          title: "Brave result",
          url: "https://docs.example.com/article",
          publishedDate: "2026-07-18T12:00:00Z",
          author: "Example Docs",
          summary: "Main snippet",
          text: "Main snippet\n\nExtra snippet one\n\nExtra snippet two",
          highlights: ["Main snippet", "Extra snippet one", "Extra snippet two"],
        },
      ],
    });
  } finally {
    globalThis.fetch = originalFetch;
    env.BRAVE_SEARCH_API_KEY = originalApiKey;
  }
});

test("searchBrave rejects requests without an API key", async () => {
  const originalApiKey = env.BRAVE_SEARCH_API_KEY;
  env.BRAVE_SEARCH_API_KEY = undefined;
  try {
    await assert.rejects(() => searchBrave("test", { numResults: 1 }), /BRAVE_SEARCH_API_KEY not set/);
  } finally {
    env.BRAVE_SEARCH_API_KEY = originalApiKey;
  }
});

test("searchBrave reports non-JSON responses", async () => {
  const originalFetch = globalThis.fetch;
  const originalApiKey = env.BRAVE_SEARCH_API_KEY;
  env.BRAVE_SEARCH_API_KEY = "test-brave-key";
  globalThis.fetch = (async () =>
    new Response("upstream error", {
      status: 200,
      headers: { "content-type": "text/plain" },
    })) as typeof fetch;

  try {
    await assert.rejects(
      () => searchBrave("test", { numResults: 1 }),
      /Brave Search API returned text\/plain/
    );
  } finally {
    globalThis.fetch = originalFetch;
    env.BRAVE_SEARCH_API_KEY = originalApiKey;
  }
});