malice

import markdown, { type MarkdownNode } from '@cloudrac3r/discord-markdown';

import type { Emote } from './emotes';

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

const { markdownEngine, rules } = markdown;

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 mentionLinker(mentions: Mention[]): (escaped: string) => string {

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

  if (byText.size === 0) return (escaped) => escaped;

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

  const pattern = new RegExp(names.map(escapeRegExp).join('|'), 'g');

  return (escaped) =>

    escaped.replace(pattern, (name) => `<a href="https://matrix.to/#/${escapeHtml(byText.get(name)!)}">${name}</a>`);

}

function emoteLinker(emotes: Emote[]): (escaped: string) => string {

  if (emotes.length === 0) return (escaped) => escaped;

  const byCode = new Map(emotes.map((e) => [e.shortcode, e.mxc]));

  return (escaped) =>

    escaped.replace(/:([\w+-]+):/g, (whole, code: string) => {

      const mxc = byCode.get(code);

      return mxc ? `<img data-mx-emoticon src="${escapeHtml(mxc)}" alt="${whole}" title="${whole}" height="32">` : whole;

    });

}

function textToHtml(text: string, link: (escaped: string) => string): string {

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

}

const parseMarkdown = markdownEngine.parserFor(

  Object.fromEntries(Object.entries(rules).filter(([name]) => !name.startsWith('discord')))

);

const INLINE_TAGS: Record<string, string> = { em: 'em', strong: 'strong', u: 'u', strike: 'del', small: 'sub' };

const BLOCK_TYPES = new Set(['blockQuote', 'codeBlock', 'heading', 'list', 'paragraph']);

function renderMarkdown(nodes: MarkdownNode[], link: (escaped: string) => string): string {

  let html = '';

  let text = '';

  const flushText = () => {

    html += textToHtml(text, link);

    text = '';

  };

  for (const node of nodes) {

    if (node.type === 'text') {

      text += node.content;

      continue;

    }

    flushText();

    const children = () => renderMarkdown(node.content, link);

    const tag = INLINE_TAGS[node.type];

    if (tag) {

      html += `<${tag}>${children()}</${tag}>`;

      continue;

    }

    switch (node.type) {

      case 'br':

      case 'newline':

        html += '<br>';

        break;

      case 'inlineCode':

        html += `<code>${escapeHtml(node.content)}</code>`;

        break;

      case 'codeBlock': {

        const lang = /^[\w+#-]+$/.test(node.lang ?? '') ? ` class="language-${escapeHtml(node.lang)}"` : '';

        html += `<pre><code${lang}>${escapeHtml(node.content)}\n</code></pre>`;

        break;

      }

      case 'spoiler':

        html += `<span data-mx-spoiler>${renderMarkdown(node.parsed, link)}</span>`;

        break;

      case 'blockQuote':

        html += `<blockquote>${children()}</blockquote>`;

        break;

      case 'paragraph':

        html += `<p>${children()}</p>`;

        break;

      case 'heading': {

        const level = Math.max(1, Math.min(6, node.level));

        html += `<h${level}>${children()}</h${level}>`;

        break;

      }

      case 'list': {

        const tag = node.ordered ? 'ol' : 'ul';

        const start = node.ordered && Number.isSafeInteger(node.start) && node.start > 0 ? ` start="${node.start}"` : '';

        html += `<${tag}${start}>${node.items.map((item: MarkdownNode[]) => `<li>${renderMarkdown(item, link)}</li>`).join('')}</${tag}>`;

        break;

      }

      case 'link':

      case 'url':

      case 'autolink': {

        const label = renderMarkdown(node.content, (escaped) => escaped);

        const href = markdownEngine.sanitizeUrl(node.target);

        const title = node.title ? ` title="${escapeHtml(node.title)}"` : '';

        html += href && /^(https?:|mailto:)/i.test(href) ? `<a href="${escapeHtml(href)}"${title}>${label}</a>` : label;

        break;

      }

    }

  }

  flushText();

  return html;

}

function markdownToHtml(body: string, link: (escaped: string) => string): string | null {

  const nodes = parseMarkdown(body, { inline: true });

  const html = renderMarkdown(nodes, link);

  if (html === textToHtml(body, (escaped) => escaped)) return null;

  if (nodes.every((node) => node.type === 'text' || node.type === 'br' || node.type === 'newline') ||

    nodes.some((node) => BLOCK_TYPES.has(node.type))) return html;

  return `<p>${html}</p>`;

}

/** Matrix `formatted_body` for a composed message, or null when plain text says it all. */

export function formatBody(body: string, mentions: Mention[], markdown: boolean, emotes: Emote[] = []): string | null {

  const mention = mentionLinker(mentions);

  const emote = emoteLinker(emotes);

  const link = (escaped: string) => emote(mention(escaped));

  const html = markdown ? markdownToHtml(body, link) : null;

  if (html !== null) return html;

  const plain = textToHtml(body, link);

  return plain === escapeHtml(body).replace(/\n/g, '<br>') ? null : plain;

}

export function insideOpenFence(text: string, caret: number): boolean {

  return (text.slice(0, caret).match(/^\s*```/gm)?.length ?? 0) % 2 === 1;

}