// ── Keuze-impact: transparante, voorzichtige verslaggeving ───────────────────
// De model-engine van Notary.AI is volledig DETERMINISTISCH: dezelfde kenmerken
// leveren altijd exact dezelfde keuzes en dezelfde tekst. Deze module legt, óók
// deterministisch, bloot wat die keuzes met het model doen — vooral: WELKE
// hypotheses/clausules worden geschrapt of weggelaten. Bedoeld om de
// (probabilistische) AI-agent via MCP voorzichtig bij te staan:
//
//  • Een variant/clausule wordt NOOIT geschrapt zonder een expliciet, traceerbaar
//    feit (override). Bij gebrek aan een feit blijven alle hypotheses staan ter
//    keuze van de notaris — nooit een blinde gok.
//  • Elke schrapping en elke weglating wordt UITDRUKKELIJK in het verslag vermeld,
//    met een waarschuwing, zodat een verkeerd feit van de agent zichtbaar blijft
//    en niet stilzwijgend een clausule verwijdert (dat kan zware gevolgen hebben).

import type { Modeldocument, Modelonderdeel } from "@/data/modeldocumenten";
import { pasKeuzesToe } from "@/data/modeldocumenten";
import type { OntwerpKeuze } from "@/lib/handoff";
import { GEEN_VARIANT } from "./kenmerken";

/** Eén hypothese (id + leesbare omschrijving). */
export interface HypotheseRef {
  id: string;
  hypothese: string;
}

/** Een onderdeel waarvan één hypothese werd gekozen en de overige geschrapt. */
export interface GekozenHypothese {
  onderdeelId: string;
  titel: string;
  /** De gekozen hypothese; null als enkel de basistekst behouden bleef (GEEN_VARIANT) of de id niet bestaat. */
  gekozen: HypotheseRef | null;
  /** De hypotheses die door deze keuze geschrapt zijn. */
  geschrapt: HypotheseRef[];
}

/** Een facultatief onderdeel dat niet werd opgenomen. */
export interface WeggelatenOnderdeel {
  onderdeelId: string;
  titel: string;
  conditie?: string;
  /** "feit" = bewust weggelaten op basis van een aangeleverd feit; "standaard" = facultatief en geen feit dat het activeerde. */
  reden: "feit" | "standaard";
}

/** Een onderdeel met meerdere hypotheses dat onaangeroerd ter keuze blijft staan. */
export interface BehoudenTerKeuze {
  onderdeelId: string;
  titel: string;
  aantalHypotheses: number;
}

/** Volledig, deterministisch impactverslag van de keuzes op een model. */
export interface KeuzeImpact {
  gekozenHypotheses: GekozenHypothese[];
  weggelatenOnderdelen: WeggelatenOnderdeel[];
  behoudenTerKeuze: BehoudenTerKeuze[];
  /** Uitdrukkelijke aandachtspunten/twijfels — altijd te tonen in de output. */
  waarschuwingen: string[];
}

/**
 * Analyseert deterministisch wat een set hypothesekeuzes (overrides) met een
 * model doet. Geeft per onderdeel weer welke hypothese gekozen en welke
 * geschrapt werd, welke facultatieve onderdelen wegvielen en welke onderdelen
 * onaangeroerd ter keuze blijven, met expliciete waarschuwingen bij elke
 * schrapping/weglating.
 */
export function analyseerKeuzeImpact(
  model: Modeldocument,
  onderdelen: Modelonderdeel[],
  overrides: OntwerpKeuze[]
): KeuzeImpact {
  const resultaat = pasKeuzesToe(model, overrides);
  // Welke onderdeel-id's werden expliciet door een feit aangestuurd.
  const expliciet = new Set(overrides.map((o) => o.onderdeelId));

  const gekozenHypotheses: GekozenHypothese[] = [];
  const weggelatenOnderdelen: WeggelatenOnderdeel[] = [];
  const behoudenTerKeuze: BehoudenTerKeuze[] = [];
  const waarschuwingen: string[] = [];

  model.structuur.forEach((item, i) => {
    const onderdeel = onderdelen.find((o) => o.id === item.onderdeelId);
    if (!onderdeel) return;
    const keuze = resultaat[i];

    // 1) Weglatingen: onderdeel niet opgenomen.
    if (!keuze.opnemen) {
      // Verplichte onderdelen worden nooit weggelaten door de engine; defensief.
      if (item.verplicht) {
        waarschuwingen.push(
          `Let op: het VERPLICHTE onderdeel "${onderdeel.titel}" is niet opgenomen — controleer dit, dit hoort er normaal in.`
        );
        return;
      }
      const reden: WeggelatenOnderdeel["reden"] = expliciet.has(item.onderdeelId) ? "feit" : "standaard";
      weggelatenOnderdelen.push({ onderdeelId: item.onderdeelId, titel: onderdeel.titel, conditie: item.conditie, reden });
      // Een facultatief onderdeel wordt standaard BEHOUDEN (veiligheid). Het valt
      // hier enkel weg omdat een uitdrukkelijk feit het op niet-toepasselijk zette
      // — net het soort schrapping dat we expliciet onder de aandacht brengen.
      if (reden === "feit") {
        waarschuwingen.push(
          `Clausule geschrapt: "${onderdeel.titel}" is weggelaten op basis van een aangeleverd feit${item.conditie ? ` (${item.conditie})` : ""}. Controleer dit feit — bij twijfel de clausule terugplaatsen.`
        );
      }
      return;
    }

    // 2) Hypothesekeuze binnen een opgenomen onderdeel.
    const meerdere = onderdeel.varianten.length > 1;
    const genarrowd = keuze.variantId !== "alle";
    if (!genarrowd) {
      if (meerdere) behoudenTerKeuze.push({ onderdeelId: item.onderdeelId, titel: onderdeel.titel, aantalHypotheses: onderdeel.varianten.length });
      return;
    }

    // Er is een specifieke variant gekozen → de overige zijn geschrapt.
    const gekozenVariant = onderdeel.varianten.find((v) => v.id === keuze.variantId) ?? null;
    const geschrapt = onderdeel.varianten.filter((v) => v.id !== keuze.variantId).map((v) => ({ id: v.id, hypothese: v.hypothese }));
    // Alleen rapporteren als er effectief iets te schrappen viel.
    if (onderdeel.varianten.length === 0) return;
    gekozenHypotheses.push({
      onderdeelId: item.onderdeelId,
      titel: onderdeel.titel,
      gekozen: gekozenVariant ? { id: gekozenVariant.id, hypothese: gekozenVariant.hypothese } : null,
      geschrapt,
    });
    if (geschrapt.length > 0) {
      const basis = keuze.variantId === GEEN_VARIANT || !gekozenVariant;
      const kop = basis
        ? `Bij "${onderdeel.titel}" is enkel de basistekst behouden; de ${geschrapt.length} hypothese(s) zijn geschrapt`
        : `Bij "${onderdeel.titel}" is de hypothese "${gekozenVariant!.hypothese}" gekozen; de ${geschrapt.length} andere hypothese(s) zijn geschrapt`;
      waarschuwingen.push(`${kop}. Controleer dit feit — bij twijfel de geschrapte hypotheses opnieuw bekijken.`);
    }
  });

  return { gekozenHypotheses, weggelatenOnderdelen, behoudenTerKeuze, waarschuwingen };
}