import { truncate, plural, formatDay, mdEscapePipe, escapeMd } from './util.js';

import { REPO_URL } from './config.js';

const ICONS = {

  root: '⬢',

  direction: '→',

  correction: '↩',

  'scope-change': '⚑',

  checkpoint: '◆',

  question: '?',

};

const MAX_NODE_TEXT = 1500;

export function renderMarkdown(tree, opts = {}) {

  const { projectName, titlesOnly = false, version } = opts;

  const { stats, roots, nodes, sessions } = tree;

  const lines = [];

  lines.push(`# Prompt Tree: ${escapeMd(projectName)}`);

  lines.push('');

  lines.push(`> ${banner(stats)}`);

  lines.push('');

  const root = nodes.find((n) => n.kind === 'root') || nodes[0];

  if (root) {

    lines.push('## Goal');

    lines.push('');

    lines.push(blockquote(clip(root.text, 900)));

    lines.push('');

  }

  lines.push('## The Path');

  lines.push('');

  const kindsPresent = new Set(nodes.map((n) => n.kind));

  const legendDefs = [

    ['root', '`⬢` root'],

    ['direction', '`→` direction'],

    ['correction', '`↩` correction'],

    ['scope-change', '`⚑` scope change'],

    ['checkpoint', '`◆` checkpoint'],

    ['question', '`?` question'],

  ];

  const legend = legendDefs.filter(([kind]) => kindsPresent.has(kind)).map(([, label]) => label);

  if (nodes.some((n) => n.status === 'abandoned')) legend.push('`✗` abandoned');

  if (legend.length) {

    lines.push(legend.join(' · '));

    lines.push('');

  }

  for (const r of roots) renderNode(r, 0, lines, { titlesOnly });

  lines.push('');

  const active = sessions.filter((s) => s.prompts.length);

  if (active.length > 1) {

    lines.push('## Sessions');

    lines.push('');

    lines.push('| # | When | Prompts | Session |');

    lines.push('|---|------|---------|---------|');

    active.forEach((s, i) => {

      lines.push(

        `| ${i + 1} | ${formatDay(s.firstTs) || ''} | ${s.prompts.length} | ${mdEscapePipe(

          escapeMd(s.title || s.sessionId || '')

        )} |`

      );

    });

    lines.push('');

  }

  lines.push('## Reusable Prompt Pack');

  lines.push('');

  const pack = promptPack(nodes);

  const fence = '`'.repeat(Math.max(3, longestRun(pack, '`') + 1));

  lines.push(`${fence}text`);

  lines.push(pack);

  lines.push(fence);

  lines.push('');

  lines.push('---');

  lines.push('');

  lines.push(`*[treetrace](${REPO_URL})${version ? ` v${version}` : ''} · [schema](${REPO_URL}/blob/main/SCHEMA.md)*`);

  lines.push('');

  return lines.join('\n');

}

function banner(stats) {

  const parts = [

    `**${plural(stats.promptCount, 'prompt')}**`,

    `**${plural(stats.sessionCount, 'session')}**`,

  ];

  if (stats.days) parts.push(`**${plural(stats.days, 'day')}**`);

  if (stats.corrections) parts.push(plural(stats.corrections, 'correction'));

  if (stats.scopeChanges) parts.push(plural(stats.scopeChanges, 'scope change'));

  if (stats.abandonedBranches)

    parts.push(plural(stats.abandonedBranches, 'abandoned branch', 'abandoned branches'));

  if (stats.toolUses) parts.push(`${stats.toolUses.toLocaleString()} tool calls`);

  if (stats.filesTouched) parts.push(`${plural(stats.filesTouched, 'file')} touched`);

  return parts.join(' · ');

}

function renderNode(node, depth, lines, opts) {

  let cur = node;

  for (;;) {

    emitNode(cur, depth, lines, opts);

    if (cur.children.length === 1) {

      cur = cur.children[0];

      continue;

    }

    for (const child of cur.children) renderNode(child, depth + 1, lines, opts);

    return;

  }

}

function emitNode(node, depth, lines, { titlesOnly }) {

  const indent = '  '.repeat(depth);

  const icon = ICONS[node.kind] || '→';

  const dead = node.status === 'abandoned';

  const safe = escapeMd(node.title);

  const title = dead ? `~~${safe}~~ ✗` : node.kind === 'root' ? `**${safe}**` : safe;

  const session = node.sessionBoundary ? ` ${dim(`(new session${node.ts ? `, ${formatDay(node.ts)}` : ''})`)}` : '';

  const nudges = node.nudges > 1 ? ` ${dim(`(+${node.nudges} nudges)`)}` : '';

  const reruns = node.reruns ? ` ${dim(`(re-issued ×${node.reruns + 1})`)}` : '';

  lines.push(`${indent}- \`${icon}\` ${title}${session}${nudges}${reruns}`);

  if (!titlesOnly && node.text.replace(/\s+/g, ' ').trim().length > node.title.replace(/\.\.\.$/, '').length + 12) {

    lines.push(`${indent}  <details><summary>full prompt</summary>`);

    lines.push('');

    lines.push(blockquote(clip(node.text, MAX_NODE_TEXT), indent + '  '));

    lines.push(`${indent}  </details>`);

  }

}

function dim(s) {

  return `<sub>${s}</sub>`;

}

function blockquote(text, indent = '') {

  return text

    .split('\n')

    .map((l) => `${indent}> ${l}`)

    .join('\n');

}

function clip(text, max) {

  if (text.length <= max) return escapeMd(text);

  return `${escapeMd(text.slice(0, max).trimEnd())}\n\n*[...trimmed, ${text.length - max} more chars]*`;

}

export function promptPack(nodes) {

  const accepted = nodes.filter(

    (n) =>

      n.status !== 'abandoned' &&

      (n.kind === 'root' || n.kind === 'direction' || n.kind === 'scope-change')

  );

  const out = [];

  accepted.forEach((n, i) => {

    const corrections = n.children?.filter((ch) => ch.kind === 'correction' && ch.status !== 'abandoned') || [];

    let entry = `${i + 1}. ${condense(n.text)}`;

    for (const corr of corrections) {

      entry += `\n   (constraint learned along the way: ${condense(corr.text, 220)})`;

    }

    out.push(entry);

  });

  return out.join('\n');

}

function condense(text, max = 420) {

  return truncate(text.replace(/\s+/g, ' '), max);

}

function longestRun(text, ch) {

  let max = 0;

  let cur = 0;

  for (const c of text) {

    if (c === ch) { cur++; if (cur > max) max = cur; } else cur = 0;

  }

  return max;

}