import { useEffect, useState } from 'react';

import {
  begriffssucheBauen,
  GLOSSAR_LEER,
  type Begriffssuche,
  type Glossar,
} from '../../../shared/glossar';
import { lernBruecke } from '../lernen/bruecke';

export interface GlossarZustand {
  readonly laedt: boolean;
  readonly glossar: Glossar | null;
  /** Vorbereitete Suche; findet nichts, solange nichts geladen ist. */
  readonly suche: Begriffssuche;
}

/**
 * Einmal geladen, für die ganze Sitzung gültig – wie die Erklärungen.
 *
 * Zusätzlich wird die Begriffssuche einmalig vorbereitet: Ihre regulären
 * Ausdrücke je Eintrag zu bauen kostet Zeit, und sie ändern sich nie.
 */
let laufend: Promise<Glossar | null> | null = null;

function holen(): Promise<Glossar | null> {
  laufend ??= (async () => {
    const lesen = lernBruecke()?.glossarLaden;
    if (!lesen) {
      return null;
    }
    try {
      return await lesen();
    } catch {
      /* Das Glossar ist eine Hilfe, keine Voraussetzung. Fehlt es, lernt man
         ohne – eine Fehlermeldung wäre lauter als der Verlust. */
      return null;
    }
  })();
  return laufend;
}

/** Gegenstück für Tests: leert den Zwischenspeicher. */
export function glossarZwischenspeicherLeeren(): void {
  laufend = null;
}

const LEERE_SUCHE = begriffssucheBauen(GLOSSAR_LEER);

export function useGlossar(): GlossarZustand {
  const [daten, setzeDaten] = useState<Glossar | null>(null);
  const [suche, setzeSuche] = useState<Begriffssuche>(LEERE_SUCHE);
  const [laedt, setzeLaedt] = useState(true);

  useEffect(() => {
    let abgebrochen = false;

    void holen().then((ergebnis) => {
      if (abgebrochen) {
        return;
      }
      setzeDaten(ergebnis);
      setzeSuche(ergebnis === null ? LEERE_SUCHE : begriffssucheBauen(ergebnis));
      setzeLaedt(false);
    });

    return () => {
      abgebrochen = true;
    };
  }, []);

  return { laedt, glossar: daten, suche };
}
