import { describe, expect, test } from "bun:test";
import { limitSearchResults, readSearchResponse, searchInputSchema, searchOutputSchema } from "../server/utils/search";
import { readSearchSources, readSearchWarnings } from "../app/utils/tool-rendering";

const site = { title: "Example", url: "https://example.com", content: "Example content" };

describe("search invocation count", () => {
    test("requires a positive integer on every invocation", () => {
        expect(searchInputSchema.safeParse({ query: "example" }).success).toBe(false);
        for (const results of [0, -1, 1.5, "2"]) {
            expect(searchInputSchema.safeParse({ query: "example", results }).success).toBe(false);
        }
        expect(searchInputSchema.safeParse({ query: "example", results: 2 }).success).toBe(true);
    });

    test("slices ranked search results without dropping warnings", () => {
        const output = {
            results: [
                { title: "First", link: "https://first.example", snippet: "" },
                { title: "Second", link: "https://second.example", snippet: "" },
            ],
            warnings: [{ engine: "google", reason: "CAPTCHA" }],
        };
        expect(limitSearchResults(output, 1)).toEqual({
            results: [output.results[0]],
            warnings: output.warnings,
        });
        expect(limitSearchResults(output, 3)).toEqual(output);
    });
});

describe("search engine failures", () => {
    test("returns an error when empty results accompany engine failures", () => {
        const result = readSearchResponse({
            results: [],
            unresponsive_engines: [["google", "Too many requests"], ["bing", "Suspended: Too many requests"]],
        });
        expect(result.ok).toBe(false);
        if (!result.ok) {
            expect(result.error).toContain("google: Too many requests");
            expect(result.error).toContain("bing: Suspended: Too many requests");
        }
    });

    test("keeps partial results successful with renderable warnings", () => {
        const result = readSearchResponse({ results: [site], unresponsive_engines: [["google", "CAPTCHA"]] });
        expect(result.ok).toBe(true);
        if (result.ok) {
            expect(searchOutputSchema.safeParse(result.data).success).toBe(true);
            expect(readSearchSources(result.data)?.[0]?.url).toBe(site.url + "/");
            expect(readSearchWarnings(result.data)).toEqual([{ engine: "google", reason: "CAPTCHA" }]);
        }
    });

    test("accepts genuinely empty results without engine failures", () => {
        const result = readSearchResponse({ results: [] });
        expect(result.ok).toBe(true);
        if (result.ok) {
            expect(result.data).toEqual({ results: [], warnings: [] });
        }
    });

    test("accepts results without snippets or failures", () => {
        const result = readSearchResponse({ results: [{ title: site.title, url: site.url }] });
        expect(result.ok).toBe(true);
        if (result.ok) {
            expect(result.data.results[0]?.snippet).toBe("");
            expect(result.data.warnings).toEqual([]);
        }
    });

    test("rejects malformed responses", () => {
        expect(readSearchResponse({ error: "Invalid query" }).ok).toBe(false);
    });

    test("still renders legacy arrays and ignores malformed warnings", () => {
        const legacy = [{ title: site.title, link: site.url, snippet: site.content }];
        expect(readSearchSources(legacy)).toEqual(readSearchSources({ results: legacy }));
        expect(readSearchWarnings(legacy)).toEqual([]);
        expect(readSearchWarnings({ warnings: [null, {}, { engine: "google", reason: 429 }] })).toEqual([]);
    });
});