ttrpg-tools/src/components/journal/completions.ts

/**
 * Journal completions — client-side loader for /__COMPLETIONS.json
 *
 * In CLI mode, fetches the pre-computed index. In dev/browser mode, falls
 * back to scanning the in-memory file index for dice expressions and headings.
 *
 * The fetch runs eagerly on module import. Call `useJournalCompletions()`
 * from any Solid component to reactively read the state.
 */

import { createSignal } from "solid-js";
import Slugger from "github-slugger";
import { extractHeadings } from "../../data-loader/toc";
import {
  getPathsByExtension,
  getIndexedData,
} from "../../data-loader/file-index";

// ------------------- Types (mirrors CLI) -------------------

export interface DiceCompletion {
  label: string;
  notation: string;
  source: string;
}

export interface LinkCompletion {
  path: string;
  label: string;
  section: string | null;
}

export interface SparkTableCompletion {
  label: string;
  notation: string;
  slug: string;
  filePath: string;
  headers: string[];
}

/** A single stat definition parsed from a ```stat YAML block */
export interface StatDef {
  key: string;
  label: string;
  type: "number" | "string" | "enum" | "modifier" | "derived";
  scope: "player" | "global";
  default?: string;
  target?: string;
  options?: string[];
  roll?: string;
  formula?: string;
  source: string;
}

export interface JournalCompletions {
  dice: DiceCompletion[];
  links: LinkCompletion[];
  sparkTables: SparkTableCompletion[];
  stats: StatDef[];
}

export type CompletionsState =
  | { status: "loading" }
  | { status: "loaded"; data: JournalCompletions }
  | { status: "empty" }
  | { status: "error"; message: string };

// ------------------- Reactive state (module-level signal) -------------------

const [completionsState, setCompletionsState] = createSignal<CompletionsState>({
  status: "loading",
});

// ------------------- Fetch (CLI mode) -------------------

async function tryServer(): Promise<JournalCompletions | null> {
  try {
    const resp = await fetch("/__COMPLETIONS.json");
    if (!resp.ok) return null;
    const data = await resp.json();
    return {
      dice: Array.isArray(data.dice) ? data.dice : [],
      links: Array.isArray(data.links) ? data.links : [],
      sparkTables: Array.isArray(data.sparkTables) ? data.sparkTables : [],
      stats: Array.isArray(data.stats) ? data.stats : [],
    };
  } catch {
    return null;
  }
}

// ------------------- Client-side fallback scan -------------------

async function scanClientSide(): Promise<JournalCompletions> {
  const paths = await getPathsByExtension("md");
  const dice: DiceCompletion[] = [];
  const links: LinkCompletion[] = [];
  const sparkTables: SparkTableCompletion[] = [];
  const stats: StatDef[] = [];
  const tagRegex = /<md-dice[^>]*>\s*([\s\S]*?)\s*<\/md-dice>/gi;
  const statBlockRegex = /```yaml\s+role=stat\s*\n([\s\S]*?)```/gi;
  const statCsvRegex = /```csv\s+role=stat\s*\n([\s\S]*?)```/gi;

  for (const filePath of paths) {
    const content = await getIndexedData(filePath);
    if (!content) continue;

    // Fresh slugger per file so duplicate headers across files don't
    // pollute each other.
    const slugger = new Slugger();

    // Dice scan
    let match: RegExpExecArray | null;
    tagRegex.lastIndex = 0;
    while ((match = tagRegex.exec(content)) !== null) {
      const raw = match[1].trim();
      if (!raw || raw.length > 80) continue;
      if (!/^\d*d\d+/i.test(raw) && !/^[+-]/.test(raw)) continue;
      dice.push({ label: raw, notation: raw, source: filePath });
    }

    // Link scan (headings)
    const basePath = filePath.replace(/\.md$/, "");
    const fileName = basePath.split("/").filter(Boolean).pop() || basePath;
    links.push({ path: basePath, label: fileName, section: null });
    for (const heading of extractHeadings(content)) {
      links.push({
        path: basePath,
        label: `${fileName} § ${heading.title}`,
        section: heading.id ?? null,
      });
    }

    // Spark table scan
    const sparkLines = content.split(/\r?\n/);
    for (let i = 0; i < sparkLines.length; i++) {
      const headerCells = splitTableRow(sparkLines[i]);
      if (!headerCells || headerCells.length < 2) continue;
      if (!/^d\d+$/i.test(headerCells[0])) continue;

      if (i + 1 >= sparkLines.length) continue;
      const sepCells = splitTableRow(sparkLines[i + 1]);
      if (!sepCells || !sepCells.every((c) => /^:?-{3,}:?$/.test(c))) continue;

      let j = i + 2;
      while (j < sparkLines.length && splitTableRow(sparkLines[j])) j++;
      if (j <= i + 2) continue;

      const dataHeaders = headerCells.slice(1);
      const stSlug = dataHeaders
        .map((h) => slugger.slug(h.toLowerCase()))
        .join("-");

      // Combined key: pageName-columnSlug
      const combinedSlug = `${fileName}-${stSlug}`;

      sparkTables.push({
        label: `${fileName} § ${stSlug}`,
        notation: headerCells[0],
        slug: combinedSlug,
        filePath: basePath,
        headers: dataHeaders,
      });

      i = j - 1;
    }

    // Stat block scan (YAML)
    statBlockRegex.lastIndex = 0;
    let statMatch: RegExpExecArray | null;
    while ((statMatch = statBlockRegex.exec(content)) !== null) {
      const yaml = statMatch[1];
      const parsed = parseStatYaml(yaml, filePath);
      stats.push(...parsed);
    }

    // Stat block scan (CSV)
    statCsvRegex.lastIndex = 0;
    while ((statMatch = statCsvRegex.exec(content)) !== null) {
      const csv = statMatch[1];
      const parsed = parseStatCsv(csv, filePath);
      stats.push(...parsed);
    }
  }

  return { dice, links, sparkTables, stats };
}

function splitTableRow(line: string): string[] | null {
  const trimmed = line.trim();
  if (!trimmed.includes("|")) return null;
  let inner = trimmed;
  if (inner.startsWith("|")) inner = inner.slice(1);
  if (inner.endsWith("|")) inner = inner.slice(0, -1);
  return inner.split("|").map((c) => c.trim());
}

// ---------------------------------------------------------------------------
// Stat YAML parser
// ---------------------------------------------------------------------------

/**
 * Parse a ```yaml role=stat block into StatDef entries.
 * Handles a minimal YAML subset: list of objects with key/value pairs.
 */
function parseStatYaml(yaml: string, source: string): StatDef[] {
  const defs: StatDef[] = [];
  const lines = yaml.split(/\r?\n/);

  let current: Record<string, string> | null = null;
  let collectingOptions = false;
  let options: string[] = [];

  function flushCurrent() {
    if (!current || !current.key) return;
    const type = (current.type || "number") as StatDef["type"];
    const scope = (current.scope || "global") as StatDef["scope"];
    defs.push({
      key: current.key,
      label: current.label || current.key,
      type,
      scope,
      default: current.default,
      target: current.target,
      options:
        type === "enum" && options.length > 0
          ? [...options]
          : current.options
            ? current.options
                .split(",")
                .map((s) => s.trim())
                .filter(Boolean)
            : undefined,
      roll: current.roll,
      formula: current.formula,
      source,
    });
    current = null;
    options = [];
    collectingOptions = false;
  }

  for (const line of lines) {
    const trimmed = line.trim();

    // Skip empty lines and comments
    if (!trimmed || trimmed.startsWith("#")) continue;

    // New entry: "- key: value"
    if (trimmed.startsWith("- ")) {
      flushCurrent();
      current = {};
      collectingOptions = false;
      const rest = trimmed.slice(2);
      const colonIdx = rest.indexOf(":");
      if (colonIdx === -1) continue;
      const k = rest.slice(0, colonIdx).trim();
      const v = rest.slice(colonIdx + 1).trim();
      current[k] = v;
      continue;
    }

    // Continuation of current entry: "  key: value"
    if (current && trimmed.match(/^\w/)) {
      const colonIdx = trimmed.indexOf(":");
      if (colonIdx === -1) continue;
      const k = trimmed.slice(0, colonIdx).trim();
      const v = trimmed.slice(colonIdx + 1).trim();

      if (k === "options") {
        // Inline options: options: [a, b, c]
        if (v.startsWith("[") && v.endsWith("]")) {
          current[k] = v.slice(1, -1);
        } else {
          // Multi-line options list
          collectingOptions = true;
          options = [];
        }
      } else {
        current[k] = v;
      }
      continue;
    }

    // Options list item: "  - value"
    if (collectingOptions && trimmed.startsWith("- ")) {
      options.push(trimmed.slice(2).trim());
      continue;
    }
  }

  flushCurrent();
  return defs;
}

// ---------------------------------------------------------------------------
// Stat CSV parser
// ---------------------------------------------------------------------------

/**
 * Parse a ```csv role=stat block into StatDef entries.
 *
 * Columns: key, label, type, scope, default, roll, target, formula, options
 * Only `key` is required. `type` defaults to "number", `scope` to "player".
 * `options` column uses pipe-separated values: "a|b|c".
 */
function parseStatCsv(csv: string, source: string): StatDef[] {
  const lines = csv.trim().split(/\r?\n/);
  if (lines.length === 0) return [];

  // Parse header
  const headers = lines[0].split(",").map((h) => h.trim().toLowerCase());
  const idx = (name: string) => {
    const i = headers.indexOf(name);
    return i === -1 ? null : i;
  };

  const defs: StatDef[] = [];

  for (let i = 1; i < lines.length; i++) {
    const row = lines[i].trim();
    if (!row || row.startsWith("#")) continue;
    const cols = splitCsvRow(row);
    if (cols.length === 0) continue;

    const get = (name: string) => {
      const colIdx = idx(name);
      if (colIdx === null || colIdx >= cols.length) return undefined;
      return cols[colIdx].trim() || undefined;
    };

    const key = get("key");
    if (!key) continue;

    const type = (get("type") || "number") as StatDef["type"];
    const scope = (get("scope") || "player") as StatDef["scope"];

    let options: string[] | undefined;
    const optRaw = get("options");
    if (optRaw) {
      options = optRaw
        .split("|")
        .map((s) => s.trim())
        .filter(Boolean);
    }

    defs.push({
      key,
      label: get("label") || key,
      type,
      scope,
      default: get("default"),
      roll: get("roll"),
      target: get("target"),
      formula: get("formula"),
      options,
      source,
    });
  }

  return defs;
}

/** Split a CSV row respecting quoted fields. */
function splitCsvRow(row: string): string[] {
  const cols: string[] = [];
  let current = "";
  let inQuote = false;

  for (let i = 0; i < row.length; i++) {
    const ch = row[i];
    if (ch === '"') {
      inQuote = !inQuote;
    } else if (ch === "," && !inQuote) {
      cols.push(current);
      current = "";
    } else {
      current += ch;
    }
  }
  cols.push(current);
  return cols;
}

// ------------------- Init (runs eagerly at import time) -------------------

// Using a top-level IIFE so the promise starts immediately
const _initPromise: Promise<void> = (async () => {
  // 1. Try server first (CLI mode)
  const serverData = await tryServer();
  if (serverData) {
    setCompletionsState({ status: "loaded", data: serverData });
    return;
  }

  // 2. Fall back to client-side scan (dev/browser mode)
  try {
    const data = await scanClientSide();
    if (data.dice.length > 0 || data.links.length > 0) {
      setCompletionsState({ status: "loaded", data });
    } else {
      setCompletionsState({ status: "empty" });
    }
  } catch (e) {
    setCompletionsState({
      status: "error",
      message: e instanceof Error ? e.message : "Failed to scan",
    });
  }
})();

// ------------------- Public API -------------------

/**
 * Returns a Promise that resolves once completions are loaded (or failed).
 * Useful for waiting before showing the completions dropdown.
 */
export function ensureCompletions(): Promise<void> {
  return _initPromise;
}

/** Force a re-fetch on the next page load. For runtime, call before invalidate triggers. */
let _invalidated = false;
export function invalidateCompletions(): void {
  _invalidated = true;
  // On next import (page reload), the module will re-init.
  // For a runtime invalidation, you could call init again.
}

/**
 * Reactive hooks for the journal input.
 * Returns the current completions state + a convenience `data` extractor.
 */
export function useJournalCompletions(): {
  state: CompletionsState;
  data: JournalCompletions;
} {
  const s = completionsState();
  if (s.status === "loaded") {
    return { state: s, data: s.data };
  }
  return {
    state: s,
    data: { dice: [], links: [], sparkTables: [], stats: [] },
  };
}