/**
 * Parser for the binary's tree-text response format (default since 0.10.x for
 * search_graph / search_code compact mode / trace_path / get_architecture).
 *
 * Shape:
 *   total: 116                                 <- scalar line
 *   search_mode: bm25
 *   results: 15  (cols: qn label file lines rank)   <- section header
 *     <qn> <label> <file> <lines> <rank>            <- indented row
 *   has_more: true
 *
 * Row cells are whitespace-separated; values with spaces are double-quoted.
 */

export type TreeSection = {
  name: string;
  count: number;
  cols: string[];
  /** Parsed cells per row; null when the token count didn't match cols. */
  rows: Array<Record<string, string> | null>;
  /** Raw row lines (trimmed), always present as a fallback. */
  raw: string[];
};

export type TreeDoc = {
  scalars: Record<string, string>;
  sections: TreeSection[];
};

const SECTION_RE = /^([a-z_]+): (\d+)\s+\(cols: ([^)]*)\)\s*$/;
const SCALAR_RE = /^([a-z_]+): (.*)$/;

/** Quote-aware whitespace split: `a "b c" d` → ["a", "b c", "d"]. */
function splitCells(line: string): string[] {
  const out: string[] = [];
  const re = /"([^"]*)"|(\S+)/g;
  let m: RegExpExecArray | null;
  while ((m = re.exec(line)) !== null) out.push(m[1] ?? m[2]!);
  return out;
}

/** Parse a tree-text document. Returns null when nothing matches the format. */
export function parseTree(text: string): TreeDoc | null {
  const scalars: Record<string, string> = {};
  const sections: TreeSection[] = [];
  let current: TreeSection | null = null;
  let matched = false;

  for (const line of text.split("\n")) {
    if (!line.trim()) continue;
    if (/^\s/.test(line)) {
      // Indented row belongs to the last section header.
      if (!current) continue;
      const trimmed = line.trim();
      current.raw.push(trimmed);
      const cells = splitCells(trimmed);
      current.rows.push(
        cells.length === current.cols.length
          ? Object.fromEntries(current.cols.map((c, i) => [c, cells[i]!]))
          : null,
      );
      continue;
    }
    const sec = SECTION_RE.exec(line);
    if (sec) {
      current = {
        name: sec[1]!,
        count: Number(sec[2]),
        cols: sec[3]!.split(/\s+/).filter(Boolean),
        rows: [],
        raw: [],
      };
      sections.push(current);
      matched = true;
      continue;
    }
    const sc = SCALAR_RE.exec(line);
    if (sc) {
      scalars[sc[1]!] = sc[2]!;
      current = null;
      matched = true;
    }
  }
  return matched ? { scalars, sections } : null;
}

export function section(doc: TreeDoc, name: string): TreeSection | undefined {
  return doc.sections.find((s) => s.name === name);
}

/** Last dot-segment of a qualified name (drops project/path prefix). */
export function shortName(qn: string): string {
  const i = qn.lastIndexOf(".");
  return i === -1 ? qn : qn.slice(i + 1);
}