// Build-time markup helpers for note bodies: and/but/or/then connectors, heading ids, footnote sidenotes, TK marks and id scoping.

import { slugify } from './slug.mjs';

const CONNECTOR = /^(and|but|or|nor|yet|so|for|then|also|plus|because)$/i;
const FENCE = /^\s{0,3}(```|~~~)/;

/** Turn lone conjunction lines ("and", "but", "or", "then"…) outside fenced code into separator HTML blocks. Other lines are untouched. */
export function markConnectors(markdown) {
  let fence = null;
  return markdown
    .split('\n')
    .map((line) => {
      const f = line.match(FENCE);
      if (f) {
        if (!fence) fence = f[1];
        else if (f[1] === fence) fence = null;
        return line;
      }
      if (fence) return line;
      const t = line.trim();
      if (!CONNECTOR.test(t)) return line;
      const w = t.toLowerCase();
      return `\n<p class="thru thru-${w}" role="separator" aria-label="${w}">${w}</p>\n`;
    })
    .join('\n');
}

/**
 * End a blockquote at its last `>` line. NotePlan writes the author's own words on the line right
 * after a quote, which Markdown would otherwise fold into the quote by lazy continuation.
 */
export function endQuotes(markdown) {
  let fence = null;
  const lines = markdown.split('\n');
  return lines
    .map((line, i) => {
      const f = line.match(FENCE);
      if (f) {
        if (!fence) fence = f[1];
        else if (f[1] === fence) fence = null;
        return line;
      }
      const next = lines[i + 1];
      if (fence || !/^\s{0,3}>/.test(line) || next === undefined || !next.trim() || /^\s{0,3}>/.test(next)) return line;
      return `${line}\n`;
    })
    .join('\n');
}

/**
 * Give each bare heading the id Eleventy's id plugin would: its slugified text, with -2, -3… for repeats.
 * Headings that already carry attributes are left as they are.
 */
export function addHeadingIds(html) {
  const seen = new Map();
  return html.replace(/<(h[1-6])>([\s\S]*?)<\/\1>/g, (all, tag, inner) => {
    const base = slugify(inner.replace(/<[^>]*>/g, '')) || 'section';
    const n = (seen.get(base) ?? 0) + 1;
    seen.set(base, n);
    return `<${tag} id="${n > 1 ? `${base}-${n}` : base}">${inner}</${tag}>`;
  });
}

const VOID = new Set(['hr', 'br', 'img', 'input', 'meta', 'link', 'wbr', 'source', 'area', 'col']);
const TAG = /<(\/?)([a-zA-Z][a-zA-Z0-9]*)\b[^>]*?(\/?)>/g;

/** End offsets (exclusive) of each top-level element in `html`. */
function topLevelEnds(html) {
  const ends = [];
  let depth = 0;
  TAG.lastIndex = 0;
  for (let m; (m = TAG.exec(html)); ) {
    const name = m[2].toLowerCase();
    if (VOID.has(name) || m[3] === '/') {
      if (depth === 0) ends.push(TAG.lastIndex);
    } else if (m[1]) {
      depth = Math.max(0, depth - 1);
      if (depth === 0) ends.push(TAG.lastIndex);
    } else depth++;
  }
  return ends;
}

/** Move markdown-it-footnote output into inline `<aside class="sidenote">` blocks after the referencing block. */
export function placeSidenotes(bodyHtml) {
  const secStart = bodyHtml.indexOf('<section class="footnotes"');
  if (secStart === -1) return bodyHtml;
  const secEndTag = '</section>';
  const secEnd = bodyHtml.indexOf(secEndTag, secStart);
  if (secEnd === -1) return bodyHtml;
  const section = bodyHtml.slice(secStart, secEnd);
  let before = bodyHtml.slice(0, secStart).replace(/<hr class="footnotes-sep"\s*\/?>\s*$/, '');
  const after = bodyHtml.slice(secEnd + secEndTag.length);

  const items = [];
  for (const m of section.matchAll(/<li id="fn(\d+)" class="footnote-item">([\s\S]*?)<\/li>/g)) {
    const inner = m[2].replace(/\s*<a href="#fnref[^"]*" class="footnote-backref">[\s\S]*?<\/a>/g, '').trim();
    items.push({ n: m[1], html: `<aside class="sidenote" id="fn${m[1]}"><span class="sn-num">${m[1]}</span> ${inner}</aside>` });
  }

  before = before.replace(
    /<sup class="footnote-ref"><a href="#fn(\d+)" id="fnref[^"]*">\[[^\]]*\]<\/a><\/sup>/g,
    (all, n) => all.replace('class="footnote-ref"', 'class="footnote-ref sn-ref"').replace(/>\[[^\]]*\]</, `>${n}<`),
  );

  const ends = topLevelEnds(before);
  const inserts = new Map();
  const tail = [];
  for (const it of items) {
    const at = before.indexOf(`id="fnref${it.n}"`);
    const end = at === -1 ? undefined : ends.find((e) => e > at);
    if (end === undefined) tail.push(it.html);
    else inserts.set(end, [...(inserts.get(end) ?? []), it.html]);
  }
  let out = '';
  let last = 0;
  for (const end of [...inserts.keys()].sort((a, b) => a - b)) {
    out += before.slice(last, end) + inserts.get(end).join('');
    last = end;
  }
  out += before.slice(last) + tail.join('') + after;
  return out;
}

const TK_SKIP = new Set(['a', 'code', 'pre', 'script', 'style']);

/**
 * Mark each standalone "TK" (to come) in body text: a link to `href`, the note that defines TK,
 * or an unlinked `<mark>` when that note isn't published. Text inside links, code and tags is untouched.
 */
export function markTK(bodyHtml, href) {
  const mark = href ? `<a class="tk" href="${href}">TK</a>` : '<mark class="tk">TK</mark>';
  let skip = 0;
  const out = bodyHtml.replace(/(<[^>]*>)|([^<]+)/g, (all, tag, text) => {
    if (tag) {
      const m = tag.match(/^<(\/?)([a-zA-Z][a-zA-Z0-9]*)/);
      if (m && TK_SKIP.has(m[2].toLowerCase()) && !tag.endsWith('/>')) skip = Math.max(0, skip + (m[1] ? -1 : 1));
      return tag;
    }
    return skip ? text : text.replace(/(?<![\w-])TK(?![\w-])/g, mark);
  });
  // A drop cap would take the T of an opening TK; `tk-lead` lets the stylesheet skip it.
  return out.replace(/^((?:\s|<!--[\s\S]*?-->)*)<p>(?=<(?:a|mark) class="tk")/, '$1<p class="tk-lead">');
}

/**
 * Prefix element ids and in-page "#" links so a body printed beside others (a card, a stacked note) can't collide with the page's own anchors.
 * @param {string} html
 * @param {string} scope
 */
export function prefixIds(html, scope) {
  // A sprig's <use href="#seed-y"> points at the page's shared sprite, so it keeps its href.
  return html
    .replace(/\bid=(["'])([^"']*)\1/g, (_, q, id) => `id=${q}${scope}--${id}${q}`)
    .replace(/<(?!use\b)[a-z][^>]*>/gi, (tag) => tag.replace(/\bhref=(["'])#([^"']*)\1/g, (_, q, id) => `href=${q}#${scope}--${id}${q}`));
}