// ── Kantooraanpassingen op de kennisbank — gedragstests ──────────────────────
// De seed blijft onaangeroerd; aanpassingen worden er zuiver overheen gelegd.

import { describe, expect, it } from "vitest";
import {
  isGevalideerd,
  signalenNaarTekst,
  stelKennisbankSamen,
  tekstNaarSignalen,
  valideerControlepunt,
  type KennisbankAanpassing,
} from "./aanpassingen";
import type { Controlepunt } from "./types";

const SEED: Controlepunt[] = [
  {
    id: "seed-a",
    categorie: "essentieel",
    doel: "vereist",
    akteTypes: "alle",
    titel: "Seed A",
    uitleg: "uitleg a",
    signalen: [["alpha"]],
    voorstel: "clausule a",
  },
  {
    id: "seed-b",
    categorie: "te-vermijden",
    doel: "verdacht",
    akteTypes: ["verkoopakte"],
    titel: "Seed B",
    uitleg: "uitleg b",
    signalen: [["beta"]],
    vervanging: "vervang b",
  },
];

describe("stelKennisbankSamen", () => {
  it("laat de seed ongemoeid zonder aanpassingen", () => {
    expect(stelKennisbankSamen(SEED, [])).toEqual(SEED);
  });

  it("vervangt een seed-punt door de override op dezelfde plaats", () => {
    const override: Controlepunt = { ...SEED[0], titel: "Aangepast A" };
    const aanpassingen: KennisbankAanpassing[] = [{ id: "seed-a", punt: override, aangepast: "x" }];
    const uit = stelKennisbankSamen(SEED, aanpassingen);
    expect(uit[0].titel).toBe("Aangepast A");
    expect(uit).toHaveLength(2);
  });

  it("laat een geschrapt seed-punt wegvallen", () => {
    const uit = stelKennisbankSamen(SEED, [{ id: "seed-b", geschrapt: true, aangepast: "x" }]);
    expect(uit.map((p) => p.id)).toEqual(["seed-a"]);
  });

  it("voegt een kantooreigen punt achteraan toe", () => {
    const eigen: Controlepunt = {
      id: "kantoor-x",
      categorie: "belangrijk",
      doel: "vereist",
      akteTypes: "alle",
      titel: "Eigen",
      uitleg: "u",
      signalen: [["x"]],
      voorstel: "c",
    };
    const uit = stelKennisbankSamen(SEED, [{ id: "kantoor-x", punt: eigen, aangepast: "x" }]);
    expect(uit).toHaveLength(3);
    expect(uit[2].id).toBe("kantoor-x");
  });

  it("negeert een geschrapt kantoorpunt (bestaat niet in de seed)", () => {
    const uit = stelKennisbankSamen(SEED, [{ id: "kantoor-weg", geschrapt: true, aangepast: "x" }]);
    expect(uit).toHaveLength(2);
  });
});

describe("isGevalideerd", () => {
  it("is false zonder validatiestand (AI-opgesteld)", () => {
    expect(isGevalideerd(SEED[0])).toBe(false);
  });
  it("is true na validatie", () => {
    expect(isGevalideerd({ ...SEED[0], validatie: { status: "gevalideerd" } })).toBe(true);
  });
});

describe("valideerControlepunt", () => {
  const geldig: Controlepunt = {
    id: "kantoor-test",
    categorie: "belangrijk",
    doel: "vereist",
    akteTypes: ["verkoopakte"],
    titel: "Titel",
    uitleg: "Uitleg",
    signalen: [["woord"]],
    voorstel: "Clausule",
  };

  it("keurt een correct punt goed", () => {
    expect(valideerControlepunt(geldig)).toEqual([]);
  });

  it("eist een voorstel bij een aanwezigheidseis", () => {
    expect(valideerControlepunt({ ...geldig, voorstel: "" })).toContain(
      "Een aanwezigheidseis heeft een in te voegen clausuletekst (voorstel) nodig."
    );
  });

  it("verbiedt de combinatie te-vermijden + vereist", () => {
    const fout = valideerControlepunt({ ...geldig, categorie: "te-vermijden" });
    expect(fout.some((f) => f.includes("verbodseis"))).toBe(true);
  });

  it("weigert een onbekend akteType", () => {
    const fout = valideerControlepunt({ ...geldig, akteTypes: ["bestaat-niet"] as never });
    expect(fout.some((f) => f.includes("Onbekend akteType"))).toBe(true);
  });

  it("eist minstens één signaalgroep", () => {
    expect(valideerControlepunt({ ...geldig, signalen: [] })).toContain(
      "Minstens één signaalgroep met niet-lege trefwoorden is vereist."
    );
  });
});

describe("signalen ↔ tekst (UI-editor)", () => {
  it("gaat heen en weer zonder verlies", () => {
    const signalen = [["a"], ["b", "c"]];
    expect(tekstNaarSignalen(signalenNaarTekst(signalen))).toEqual(signalen);
  });

  it("parseert EN-groepen op ' + ' en negeert lege regels", () => {
    expect(tekstNaarSignalen("voorschot + verkoper\n\n bodemattest ")).toEqual([
      ["voorschot", "verkoper"],
      ["bodemattest"],
    ]);
  });
});