malice

import type { Mention } from './mentions';

export type CodeSegment =

  | { kind: 'text'; text: string }

  | { kind: 'inline'; text: string }

  | { kind: 'block'; text: string; lang: string | null };

const FENCE = /```([^\s`]*)[^\S\n]*\n?([\s\S]*?)\n?```/g;

const INLINE = /`([^`\n]+)`/g;

function splitInline(text: string, out: CodeSegment[]): void {

  let last = 0;

  for (const m of text.matchAll(INLINE)) {

    if (m.index > last) out.push({ kind: 'text', text: text.slice(last, m.index) });

    out.push({ kind: 'inline', text: m[1] });

    last = m.index + m[0].length;

  }

  if (last < text.length) out.push({ kind: 'text', text: text.slice(last) });

}

export function parseCode(text: string): CodeSegment[] {

  const out: CodeSegment[] = [];

  if (!text.includes('`')) {

    if (text) out.push({ kind: 'text', text });

    return out;

  }

  let last = 0;

  for (const m of text.matchAll(FENCE)) {

    splitInline(text.slice(last, m.index), out);

    out.push({ kind: 'block', text: m[2], lang: m[1] || null });

    last = m.index + m[0].length;

    if (text[last] === '\n') last += 1;

  }

  splitInline(text.slice(last), out);

  return out;

}

export function hasCode(segments: CodeSegment[]): boolean {

  return segments.some((s) => s.kind !== 'text');

}

function escapeHtml(text: string): string {

  return text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');

}

function escapeRegExp(text: string): string {

  return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

}

function textToHtml(text: string, pattern: RegExp | null, byText: Map<string, string>): string {

  if (!pattern) return escapeHtml(text).replace(/\n/g, '<br>');

  let out = '';

  let last = 0;

  for (const m of text.matchAll(pattern)) {

    out += escapeHtml(text.slice(last, m.index)).replace(/\n/g, '<br>');

    const userId = byText.get(m[0]) ?? m[0];

    out += `<a href="https://matrix.to/#/${escapeHtml(userId)}">${escapeHtml(m[0])}</a>`;

    last = m.index + m[0].length;

  }

  return out + escapeHtml(text.slice(last)).replace(/\n/g, '<br>');

}

/** Matrix `formatted_body` for a plain body, or null when it has no code or mentions to format. */

export function codeToHtml(body: string, mentions: Mention[] = []): string | null {

  const segments = parseCode(body);

  const byText = new Map(mentions.map((m) => [m.text, m.user_id]));

  const texts = [...byText.keys()].sort((a, b) => b.length - a.length);

  const pattern = texts.length > 0 ? new RegExp(texts.map(escapeRegExp).join('|'), 'g') : null;

  const linked = pattern !== null && segments.some((s) => s.kind === 'text' && new RegExp(pattern.source).test(s.text));

  if (!hasCode(segments) && !linked) return null;

  return segments

    .map((s) => {

      if (s.kind === 'inline') return `<code>${escapeHtml(s.text)}</code>`;

      if (s.kind === 'block') {

        const cls = s.lang ? ` class="language-${escapeHtml(s.lang)}"` : '';

        return `<pre><code${cls}>${escapeHtml(s.text)}</code></pre>`;

      }

      return textToHtml(s.text, pattern, byText);

    })

    .join('');

}