import { describe, it, expect } from "vitest";
import { parseSearchParams } from "@/lib/search/parse-params";
import type { FacetDef } from "@/lib/search/types";

const TANK = "11111111-1111-1111-1111-111111111111";
const ALLRAD = "22222222-2222-2222-2222-222222222222";
const PUMPE = "33333333-3333-3333-3333-333333333333";
const UNKNOWN = "99999999-9999-9999-9999-999999999999";

const facets: FacetDef[] = [
  { merkmalId: TANK, name: "Löschwassertank", typ: "number", einheit: "l", min: 0, max: 14000 },
  { merkmalId: ALLRAD, name: "Allradantrieb", typ: "boolean", einheit: null },
  {
    merkmalId: PUMPE,
    name: "Feuerlöschpumpe",
    typ: "enum",
    einheit: null,
    optionen: [
      { wert: "fpn1000", label: "FPN 10-1000" },
      { wert: "fpn2000", label: "FPN 10-2000" },
    ],
  },
];

describe("parseSearchParams", () => {
  it("parst number-Range lo..hi, boolean ja, bereit=1", () => {
    const r = parseSearchParams(
      { [`f.${TANK}`]: "2000..4000", [`f.${ALLRAD}`]: "ja", bereit: "1" },
      facets,
    );
    expect(r.nurEinsatzbereit).toBe(true);
    expect(r.filter).toContainEqual({ typ: "number", merkmalId: TANK, gte: 2000, lte: 4000 });
    expect(r.filter).toContainEqual({ typ: "boolean", merkmalId: ALLRAD, eq: true });
  });

  it("parst enum als CSV (nur bekannte Optionen)", () => {
    const r = parseSearchParams({ [`f.${PUMPE}`]: "fpn2000,unbekannt,fpn1000" }, facets);
    expect(r.filter).toContainEqual({ typ: "enum", merkmalId: PUMPE, in: ["fpn2000", "fpn1000"] });
  });

  it("parst offene Range lo.. (nur gte)", () => {
    const r = parseSearchParams({ [`f.${TANK}`]: "2000.." }, facets);
    expect(r.filter).toContainEqual({ typ: "number", merkmalId: TANK, gte: 2000 });
  });

  it("parst offene Range ..hi (nur lte)", () => {
    const r = parseSearchParams({ [`f.${TANK}`]: "..4000" }, facets);
    expect(r.filter).toContainEqual({ typ: "number", merkmalId: TANK, lte: 4000 });
  });

  it("parst boolean nein als eq=false", () => {
    const r = parseSearchParams({ [`f.${ALLRAD}`]: "nein" }, facets);
    expect(r.filter).toContainEqual({ typ: "boolean", merkmalId: ALLRAD, eq: false });
  });

  it("verwirft unbekannte merkmalId still", () => {
    const r = parseSearchParams({ [`f.${UNKNOWN}`]: "foo" }, facets);
    expect(r.filter).toEqual([]);
  });

  it("verwirft Nicht-uuid-Keys und Ungültiges still", () => {
    const r = parseSearchParams(
      { "f.nichtuuid": "1..2", [`f.${TANK}`]: "abc..def", [`f.${ALLRAD}`]: "vielleicht" },
      facets,
    );
    expect(r.filter).toEqual([]);
  });

  it("verwirft enum ohne gültige Optionen still", () => {
    const r = parseSearchParams({ [`f.${PUMPE}`]: "nixda,auchnicht" }, facets);
    expect(r.filter).toEqual([]);
  });

  it("übernimmt q getrimmt, leeres q -> undefined", () => {
    expect(parseSearchParams({ q: "  HLF 3 " }, facets).q).toBe("HLF 3");
    expect(parseSearchParams({ q: "   " }, facets).q).toBeUndefined();
  });

  it("bereit !== '1' -> nurEinsatzbereit false", () => {
    expect(parseSearchParams({}, facets).nurEinsatzbereit).toBe(false);
    expect(parseSearchParams({ bereit: "0" }, facets).nurEinsatzbereit).toBe(false);
  });

  it("akzeptiert string[]-Werte (Next searchParams) und nimmt den ersten", () => {
    const r = parseSearchParams({ q: ["a", "b"], bereit: ["1"] }, facets);
    expect(r.q).toBe("a");
    expect(r.nurEinsatzbereit).toBe(true);
  });
});
