// ── /api/kennisbank — publieke REST-API voor AI-agenten ─────────────────────
// GET  → raadpleeg de kennisbank (seed + opgeslagen items samengevoegd),
//        standaard enkel de door de notaris gevalideerde kennis.
// POST → dien een kennisitem in als VOORSTEL: het item krijgt altijd status
//        "te_valideren" en verschijnt in de Kennisbank-UI waar de notaris het
//        goedkeurt of afwijst. Een agent wijzigt de gedeelde kennis dus nooit
//        rechtstreeks (zelfde regime als de modelbibliotheek).
// Bevat uitsluitend generieke kantoorkennis — nooit persoonsgegevens.

import { NextResponse } from "next/server";
import { maakServiceClient } from "@/lib/supabase/server";
import {
  combineerKennisbank,
  sorteerKennis,
  zoekKennis,
  valideerKennisOntwerp,
  bouwKennisVoorstel,
  KENNIS_CATEGORIEEN,
  KENNIS_STATUSSEN,
  type KennisItem,
  type KennisOntwerp,
  type KennisCategorie,
  type KennisStatus,
} from "@/data/kennisbank";

async function haalOpgeslagenItems(): Promise<KennisItem[]> {
  const sb = maakServiceClient();
  if (!sb) return [];
  const { data, error } = await sb.from("kennisbank_items").select("data").order("aangepast");
  if (error) throw new Error(`Supabase kennisbank: ${error.message}`);
  return (data ?? []).map((r: { data: unknown }) => r.data as KennisItem);
}

export async function GET(request: Request) {
  const params = new URL(request.url).searchParams;
  const status = params.get("status") ?? "gevalideerd";
  const categorie = params.get("categorie");
  const zoek = params.get("zoek");

  if (status !== "alle" && !KENNIS_STATUSSEN.includes(status as KennisStatus)) {
    return NextResponse.json(
      { fout: `Ongeldige status "${status}". Toegelaten: ${KENNIS_STATUSSEN.join(", ")}, alle.` },
      { status: 400 }
    );
  }
  if (categorie && !KENNIS_CATEGORIEEN.includes(categorie as KennisCategorie)) {
    return NextResponse.json(
      { fout: `Ongeldige categorie "${categorie}". Toegelaten: ${KENNIS_CATEGORIEEN.join(", ")}.` },
      { status: 400 }
    );
  }

  let opgeslagen: KennisItem[] = [];
  try {
    opgeslagen = await haalOpgeslagenItems();
  } catch (e) {
    return NextResponse.json({ fout: (e as Error).message }, { status: 500 });
  }

  let items = combineerKennisbank(opgeslagen);
  if (status !== "alle") items = items.filter((i) => i.status === status);
  if (categorie) items = items.filter((i) => i.categorie === categorie);
  if (zoek) items = zoekKennis(items, zoek);

  return NextResponse.json({
    aantal: items.length,
    items: sorteerKennis(items),
    nota:
      "Gedeelde kantoorkennis van het notariskantoor (werkwijzen, juridische " +
      "aandachtspunten, kantoorgebruiken). Standaard enkel de door de notaris " +
      "gevalideerde items; gebruik status=alle voor alles. Pas deze kennis toe " +
      "bij het samenstellen van dossiers. Nieuwe of verbeterde kennis dien je " +
      "in via POST (voegKennisVoorstelToe) — het voorstel wordt pas gedeelde " +
      "kennis nadat de notaris het in de UI heeft goedgekeurd.",
  });
}

/** Aanvaardt zowel een array als een komma-gescheiden string (MCP-tools sturen flat strings). */
function naarLijst(waarde: unknown): string[] | undefined {
  if (Array.isArray(waarde)) return waarde.map(String);
  if (typeof waarde === "string") {
    return waarde.split(",").map((s) => s.trim()).filter(Boolean);
  }
  return undefined;
}

export async function POST(request: Request) {
  let ontwerp: KennisOntwerp;
  try {
    const body = (await request.json()) as Record<string, unknown>;
    ontwerp = {
      ...(body as unknown as KennisOntwerp),
      themas: naarLijst(body.themas),
      bronnen: naarLijst(body.bronnen),
    };
  } catch {
    return NextResponse.json({ fout: "Ongeldige JSON." }, { status: 400 });
  }

  const fouten = valideerKennisOntwerp(ontwerp);
  if (fouten.length > 0) {
    return NextResponse.json({ fout: fouten.join(" ") }, { status: 400 });
  }

  const sb = maakServiceClient();
  if (!sb) {
    return NextResponse.json(
      { fout: "Geen persistente opslag geconfigureerd — het voorstel kan nu niet worden bewaard. Meld dit aan de notaris." },
      { status: 503 }
    );
  }

  const voorstel = bouwKennisVoorstel(ontwerp, new Date().toISOString());
  const { error } = await sb
    .from("kennisbank_items")
    .upsert({ id: voorstel.id, data: voorstel, aangepast: voorstel.aangepast });
  if (error) return NextResponse.json({ fout: error.message }, { status: 500 });

  return NextResponse.json({
    voorstel,
    nota:
      "Het kennisvoorstel staat klaar met status 'te_valideren'. De notaris " +
      "keurt het goed of wijst het af in de module Kennisbank; pas daarna " +
      "maakt het deel uit van de gevalideerde kantoorkennis.",
  });
}