// Parseur LaTeX pragmatique pour le corpus UQO : diapositives beamer (frames titrées,
// boîtes sémantiques tcolorbox) et documents article (sections). Travaille sur la SOURCE,
// ce qui garantit des numéros de diapositives fiables et des équations intactes.

export type ParsedFrame = {
  slideNumber: number; // numéro visible dans le PDF compilé (noframenumbering exclu)
  title: string;
  sectionTitle: string;
  content: string; // texte détexifié indexable
  boxTypes: string[];
};

export type ParsedSection = {
  title: string;
  path: string; // « Section > Sous-section »
  content: string;
};

const BOX_LABELS: Record<string, string> = {
  defbox: "Définition",
  definitionbox: "Définition",
  conceptbox: "Concept",
  importbox: "Important",
  exbox: "Exemple",
  notebox: "Note",
  quizbox: "Question éclair",
  infobox: "Information",
  alertbox: "Attention",
  attentionbox: "Attention",
  warnbox: "Attention",
  formbox: "Formule",
  formulebox: "Formule",
  calculbox: "Calcul",
  donneebox: "Données",
  donneesbox: "Données",
  enoncebox: "Énoncé",
  travailbox: "Travail demandé",
  resultatbox: "Résultat",
  reconbox: "Réconciliation",
  rappelbox: "Rappel",
  astucebox: "Astuce",
  conseilbox: "Conseil",
  tipbox: "Astuce",
};

/** Retire les commentaires LaTeX (% en fin de ligne, pas \%). */
export function stripComments(tex: string): string {
  return tex
    .split("\n")
    .map((line) => {
      let out = "";
      for (let i = 0; i < line.length; i++) {
        if (line[i] === "%" && line[i - 1] !== "\\") return out;
        out += line[i];
      }
      return out;
    })
    .join("\n");
}

/** Extrait le contenu d'un environnement balancé à partir d'un index (après \begin{env}). */
function findEnvEnd(tex: string, env: string, from: number): number {
  const begin = `\\begin{${env}}`;
  const end = `\\end{${env}}`;
  let depth = 1;
  let i = from;
  while (i < tex.length) {
    const nb = tex.indexOf(begin, i);
    const ne = tex.indexOf(end, i);
    if (ne === -1) return tex.length;
    if (nb !== -1 && nb < ne) {
      depth++;
      i = nb + begin.length;
    } else {
      depth--;
      if (depth === 0) return ne;
      i = ne + end.length;
    }
  }
  return tex.length;
}

/** Lit un groupe {…} balancé à partir d'une accolade ouvrante. */
function readGroup(tex: string, openBrace: number): { content: string; end: number } {
  let depth = 0;
  for (let i = openBrace; i < tex.length; i++) {
    if (tex[i] === "{" && tex[i - 1] !== "\\") depth++;
    else if (tex[i] === "}" && tex[i - 1] !== "\\") {
      depth--;
      if (depth === 0) return { content: tex.slice(openBrace + 1, i), end: i };
    }
  }
  return { content: tex.slice(openBrace + 1), end: tex.length };
}

/** Convertit un tabular en lignes « a | b | c ». */
function tabularToText(body: string): string {
  const noFormat = body
    .replace(/\\(top|mid|bottom)rule/g, "")
    .replace(/\\hline/g, "")
    .replace(/\\cline\{[^}]*\}/g, "")
    .replace(/\\rowcolor\{[^}]*\}/g, "")
    .replace(/\\arrayrulecolor\{[^}]*\}/g, "")
    .replace(/\\multicolumn\{\d+\}\{[^}]*\}/g, "")
    .replace(/\\multirow\{[^}]*\}\{[^}]*\}/g, "");
  return noFormat
    .split("\\\\")
    .map((row) =>
      row
        .split(/(?<!\\)&/)
        .map((c) => detexify(c).trim())
        .filter(Boolean)
        .join(" | ")
    )
    .map((r) => r.trim())
    .filter((r) => r.length > 1)
    .join("\n");
}

/** Détexification : LaTeX → texte lisible/indexable. Les segments mathématiques
 * ($…$ et \[…\]) sont protégés tels quels pour un rendu KaTeX fidèle. */
export function detexify(tex: string): string {
  // Maths affichées → $$…$$, puis mise à l'abri de tous les segments mathématiques
  let s = tex.replace(/\\\[/g, "$$$$").replace(/\\\]/g, "$$$$");
  const mathSegs: string[] = [];
  s = s.replace(/\$\$[\s\S]{1,800}?\$\$|\$[^$\n]{1,300}\$/g, (m) => {
    mathSegs.push(m);
    return `\u0001${mathSegs.length - 1}\u0001`;
  });
  s = detexifyText(s);
  s = s.replace(/\u0001(\d+)\u0001/g, (_m, i) => ` ${mathSegs[parseInt(i, 10)]} `);
  return s.replace(/[ \t]+/g, " ").trim();
}

function detexifyText(tex: string): string {
  let s = tex;

  // Environnements à aplatir spécialement
  s = s.replace(/\\begin\{(tikzpicture|axis|pgfplots)\}[\s\S]*?\\end\{\1\}/g, " [schéma] ");
  // tabular(x) → texte tabulaire
  for (const env of ["tabularx", "tabular", "longtable"]) {
    let idx = s.indexOf(`\\begin{${env}}`);
    while (idx !== -1) {
      // sauter les spécificateurs de colonnes {..}{..} et options [..]
      let cursor = idx + `\\begin{${env}}`.length;
      let skipped = 0;
      while (cursor < s.length && skipped < 2) {
        while (cursor < s.length && /\s/.test(s[cursor])) cursor++;
        if (s[cursor] === "[") cursor = s.indexOf("]", cursor) + 1;
        else if (s[cursor] === "{") {
          cursor = readGroup(s, cursor).end + 1;
          skipped++;
        } else break;
      }
      const end = findEnvEnd(s, env, cursor);
      const table = tabularToText(s.slice(cursor, end));
      s = s.slice(0, idx) + "\n" + table + "\n" + s.slice(end + `\\end{${env}}`.length);
      idx = s.indexOf(`\\begin{${env}}`);
    }
  }

  // Items
  s = s.replace(/\\item\s*/g, "\n• ");
  // Environnements structurels transparents
  s = s.replace(/\\(begin|end)\{(itemize|enumerate|description|center|columns|column|block|flushleft|flushright|minipage|small|footnotesize|scriptsize|frame)\}(\[[^\]]*\])?(\{[^}]*\})*/g, " ");
  // Espaces et sauts
  s = s.replace(/\\(vspace|hspace|vskip|hskip)\*?\{[^}]*\}/g, " ");
  s = s.replace(/\\(par|smallskip|medskip|bigskip|newline|linebreak|pause|centering|raggedright|noindent|footnotesize|scriptsize|small|large|Large|huge|Huge|normalsize|tiny)\b/g, " ");
  s = s.replace(/\\\\(\[[^\]]*\])?/g, "\n");
  // Guillemets français
  s = s.replace(/\\og\s*/g, "« ").replace(/\\fg\{?\}?/g, " »");
  // Commandes à un argument dont on garde le contenu
  for (let pass = 0; pass < 4; pass++) {
    s = s.replace(
      /\\(textbf|textit|emph|underline|texttt|textsc|textcolor\{[^}]*\}|colorbox\{[^}]*\}|mbox|text|textsuperscript|textsubscript|fbox|highlight|alert|structure|hl)\{([^{}]*)\}/g,
      "$2"
    );
  }
  // \href{url}{texte} → texte (url)
  s = s.replace(/\\href\{([^}]*)\}\{([^}]*)\}/g, "$2 ($1)");
  s = s.replace(/\\url\{([^}]*)\}/g, "$1");
  // Commutateurs de couleur : la commande ET son argument disparaissent
  s = s.replace(/\\(color|pagecolor|cellcolor|columncolor|arrayrulecolor)\{[^}]*\}/g, " ");
  // Notes de bas de page → parenthèses
  s = s.replace(/\\footnote\{([^{}]*)\}/g, " ($1)");
  // Citations bibliographiques
  s = s.replace(/\\(auto|text|paren|foot)?cite[tp]?\*?(\[[^\]]*\])*\{[^}]*\}/g, "");
  // Icônes et images
  s = s.replace(/\\(faIcon|includegraphics)(\[[^\]]*\])?\{[^}]*\}/g, " ");
  // Tirets TeX et espaces fines (hors mode math)
  s = s.replace(/(?<!\\)---/g, " — ").replace(/(?<![-\\])--(?!-)/g, "–");
  s = s.replace(/\\[,;:!]/g, " ");
  // Symboles usuels
  s = s
    .replace(/\\%/g, "%")
    .replace(/\\\$/g, "$$")
    .replace(/\\&/g, "&")
    .replace(/\\_/g, "_")
    .replace(/\\#/g, "#")
    .replace(/~/g, " ")
    .replace(/\\ldots|\\dots/g, "…")
    .replace(/\\rightarrow|\\to/g, "→")
    .replace(/\\leftarrow/g, "←")
    .replace(/\\Rightarrow/g, "⇒")
    .replace(/\\times/g, "×")
    .replace(/\\approx/g, "≈")
    .replace(/\\neq/g, "≠")
    .replace(/\\leq|\\le\b/g, "≤")
    .replace(/\\geq|\\ge\b/g, "≥");
  // Toute commande restante sans argument → retirer le backslash-nom, garder les args {} éventuels
  s = s.replace(/\\[a-zA-Z@]+\*?(\[[^\]]*\])?/g, " ");
  // Accolades restantes
  s = s.replace(/[{}]/g, " ");
  // Nettoyage espace
  s = s.replace(/[ \t]+/g, " ").replace(/ *\n */g, "\n").replace(/\n{3,}/g, "\n\n");
  return s.trim();
}

/** Extrait les boîtes sémantiques d'un frame et les remplace par un texte préfixé. */
function flattenBoxes(body: string, found: string[]): string {
  let s = body;
  for (const [env, label] of Object.entries(BOX_LABELS)) {
    let idx = s.indexOf(`\\begin{${env}}`);
    while (idx !== -1) {
      let cursor = idx + `\\begin{${env}}`.length;
      let boxTitle = "";
      if (s[cursor] === "[") {
        const close = s.indexOf("]", cursor);
        boxTitle = s.slice(cursor + 1, close);
        cursor = close + 1;
      }
      const end = findEnvEnd(s, env, cursor);
      const inner = s.slice(cursor, end);
      found.push(env);
      const replacement = `\n${label}${boxTitle ? ` — ${detexify(boxTitle)}` : ""} : ${inner}\n`;
      s = s.slice(0, idx) + replacement + s.slice(end + `\\end{${env}}`.length);
      idx = s.indexOf(`\\begin{${env}}`);
    }
  }
  return s;
}

/** Parse un document beamer en frames numérotées comme dans le PDF. */
export function parseBeamerFrames(rawTex: string): ParsedFrame[] {
  const tex = stripComments(rawTex);
  const frames: ParsedFrame[] = [];
  let slideNumber = 0;
  let currentSection = "";
  // Parcours linéaire : sections et frames dans l'ordre
  const tokens = [...tex.matchAll(/\\section\*?\{|\\begin\{frame\}/g)];
  for (const tok of tokens) {
    if (tok[0].startsWith("\\section")) {
      const { content } = readGroup(tex, tex.indexOf("{", tok.index));
      currentSection = detexify(content);
      continue;
    }
    const frameStart = tok.index + "\\begin{frame}".length;
    let cursor = frameStart;
    let options = "";
    if (tex[cursor] === "[") {
      const close = tex.indexOf("]", cursor);
      options = tex.slice(cursor + 1, close);
      cursor = close + 1;
    }
    let title = "";
    if (tex[cursor] === "{") {
      const g = readGroup(tex, cursor);
      title = detexify(g.content);
      cursor = g.end + 1;
    }
    // sous-titre optionnel {…}
    if (tex[cursor] === "{") {
      const g = readGroup(tex, cursor);
      cursor = g.end + 1;
    }
    const end = findEnvEnd(tex, "frame", cursor);
    const body = tex.slice(cursor, end);
    const unnumbered = /noframenumbering/.test(options);
    if (!unnumbered) slideNumber++;
    if (/\\titlepage|\\tableofcontents/.test(body) && !title) continue;
    const boxTypes: string[] = [];
    const flattened = flattenBoxes(body, boxTypes);
    const content = detexify(flattened);
    if (!content && !title) continue;
    frames.push({
      slideNumber: unnumbered ? Math.max(1, slideNumber) : slideNumber,
      title: title || "(sans titre)",
      sectionTitle: currentSection,
      content,
      boxTypes: [...new Set(boxTypes)],
    });
  }
  return frames;
}

/** Parse un document article en sections/sous-sections. */
export function parseArticleSections(rawTex: string): ParsedSection[] {
  const tex = stripComments(rawTex);
  const beginDoc = tex.indexOf("\\begin{document}");
  const body = beginDoc === -1 ? tex : tex.slice(beginDoc);
  const matches = [...body.matchAll(/\\(section|subsection|subsubsection)\*?\{/g)];
  const sections: ParsedSection[] = [];
  let currentSection = "";
  if (matches.length === 0) {
    const content = detexify(flattenBoxes(body.replace(/\\(begin|end)\{document\}/g, ""), []));
    if (content) sections.push({ title: "Document", path: "Document", content });
    return sections;
  }
  for (let i = 0; i < matches.length; i++) {
    const m = matches[i];
    const level = m[1];
    const g = readGroup(body, body.indexOf("{", m.index));
    const title = detexify(g.content);
    if (level === "section") currentSection = title;
    const start = g.end + 1;
    const end = i + 1 < matches.length ? matches[i + 1].index : body.indexOf("\\end{document}", start);
    const raw = body.slice(start, end === -1 ? undefined : end);
    const content = detexify(flattenBoxes(raw, []));
    if (!content) continue;
    sections.push({
      title,
      path: level === "section" ? title : `${currentSection} > ${title}`,
      content,
    });
  }
  return sections;
}

/** Redécoupe un texte long en morceaux ~maxLen en respectant les paragraphes. */
export function splitLong(text: string, maxLen = 1800, overlapSentences = 1): string[] {
  if (text.length <= maxLen) return [text];
  const paragraphs = text.split(/\n\n+/);
  const parts: string[] = [];
  let buf = "";
  for (const p of paragraphs) {
    if (buf.length + p.length + 2 > maxLen && buf) {
      parts.push(buf.trim());
      const sentences = buf.split(/(?<=[.!?…])\s+/);
      buf = sentences.slice(-overlapSentences).join(" ") + "\n\n" + p;
    } else {
      buf = buf ? buf + "\n\n" + p : p;
    }
  }
  if (buf.trim()) parts.push(buf.trim());
  return parts;
}