/**
 * Markdown → HTML conversion, the import counterpart of ./markdown
 * (docToMarkdown). Dependency-free and scoped to the same structural subset
 * the serializer emits: headings, blockquotes, bullet/ordered/task lists
 * (nested), fenced code blocks, GFM tables, horizontal rules, and the inline
 * marks (**bold**, *italic*, ~~strike~~, `code`, [links](…), images).
 *
 * The output is intentionally plain HTML that the schema's parseDOM rules
 * understand (e.g. <pre data-language>, <ul data-task-list>), and every
 * consumer feeds it through htmlToDoc/htmlToSlice — so the schema and the
 * sanitizer stay the single source of truth for what lands in the document.
 */

const BULLET_RE = /^(\s*)([-*+])\s+(.*)$/;
const ORDERED_RE = /^(\s*)(\d+)[.)]\s+(.*)$/;
const TASK_RE = /^\[([ xX])\]\s+(.*)$/;
const FENCE_RE = /^\s{0,3}(```+|~~~+)\s*(\S*)\s*$/;
const HEADING_RE = /^\s{0,3}(#{1,6})\s+(.*)$/;
const HR_RE = /^\s{0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/;
const QUOTE_RE = /^\s{0,3}>\s?/;
const TABLE_DIVIDER_RE = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;

function escapeHtml(text: string): string {
  return text
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;');
}

/**
 * Swaps backslash-escaped Markdown characters for placeholders so the inline
 * formatter never reads them as syntax; restoreEscapes() puts them back.
 */
function protectEscapes(text: string): string {
  return text.replace(
    /\\([\\`*_[\]()#+\-.!~|])/g,
    (_, ch: string) => `\u0000${ch.charCodeAt(0)}\u0000`
  );
}

function restoreEscapes(text: string): string {
  return text.replace(/\u0000(\d+)\u0000/g, (_, code: string) =>
    String.fromCharCode(Number(code))
  );
}

/** Inline formatting for one already-HTML-escaped, code-span-free segment. */
function formatSpans(escaped: string): string {
  let out = escaped;
  // Images before links so ![…](…) is never read as a link.
  out = out.replace(
    /!\[([^\]]*)\]\(([^()\s]+)(?:\s+[^)]*)?\)/g,
    (_, alt: string, src: string) => `<img src="${src}" alt="${alt}">`
  );
  out = out.replace(
    /\[([^\]]+)\]\(([^()\s]+)(?:\s+[^)]*)?\)/g,
    (_, label: string, href: string) => `<a href="${href}">${label}</a>`
  );
  // Bold before italic so '**' is never read as two italics.
  out = out.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
  out = out.replace(/__([^_]+)__/g, '<strong>$1</strong>');
  out = out.replace(/(^|[^*\w])\*([^*\s](?:[^*]*[^*\s])?)\*/g, '$1<em>$2</em>');
  out = out.replace(/(^|[^_\w])_([^_\s](?:[^_]*[^_\s])?)_(?![\w])/g, '$1<em>$2</em>');
  out = out.replace(/~~([^~]+)~~/g, '<s>$1</s>');
  // Newlines inside one paragraph become hard breaks.
  out = out.replace(/ *\n/g, '<br>');
  return out;
}

/** Inline Markdown → HTML. Code spans are lifted out first to stay literal. */
export function inlineToHtml(source: string): string {
  const protectedSrc = protectEscapes(source);
  const codeRe = /(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
  let rest = protectedSrc;
  let out = '';
  for (;;) {
    const match = codeRe.exec(rest);
    if (!match) {
      out += formatSpans(escapeHtml(rest));
      break;
    }
    out += formatSpans(escapeHtml(rest.slice(0, match.index)));
    out += `<code>${escapeHtml(match[2])}</code>`;
    rest = rest.slice(match.index + match[0].length);
  }
  return restoreEscapes(out);
}

/** True when a line begins a new block construct (ends a paragraph). */
function isBlockStart(line: string): boolean {
  return (
    HEADING_RE.test(line) ||
    FENCE_RE.test(line) ||
    HR_RE.test(line) ||
    QUOTE_RE.test(line) ||
    BULLET_RE.test(line) ||
    ORDERED_RE.test(line)
  );
}

interface ListItem {
  lines: string[];
  checked: boolean | null;
}

/**
 * One list region → <ul>/<ol>/task <ul>. Items deeper than the base indent
 * are re-parsed recursively, so nested and mixed lists come out right. A
 * base-indent item of the other marker type (bullet vs ordered) ends the
 * list and starts a sibling one, matching GFM.
 */
function parseListRegion(lines: string[]): string {
  const firstMatch = BULLET_RE.exec(lines[0]) ?? ORDERED_RE.exec(lines[0])!;
  const baseIndent = firstMatch[1].length;
  const ordered = ORDERED_RE.test(lines[0]) && !BULLET_RE.test(lines[0]);
  const startOrder = ordered ? Number(firstMatch[2]) : 1;

  const items: ListItem[] = [];
  let rest: string[] | null = null;
  for (let index = 0; index < lines.length; index += 1) {
    const line = lines[index];
    const match = ordered ? ORDERED_RE.exec(line) : BULLET_RE.exec(line);
    const other = ordered ? BULLET_RE.exec(line) : ORDERED_RE.exec(line);
    if (match && match[1].length <= baseIndent) {
      let text = match[3];
      let checked: boolean | null = null;
      if (!ordered) {
        const task = TASK_RE.exec(text);
        if (task) {
          checked = task[1].toLowerCase() === 'x';
          text = task[2];
        }
      }
      items.push({ lines: [text], checked });
    } else if (other && other[1].length <= baseIndent) {
      // Marker type switched at base level: a sibling list starts here.
      rest = lines.slice(index);
      break;
    } else if (items.length > 0) {
      // Continuation or nested content: drop the base marker's indent and
      // keep the relative indent so recursion sees the nesting.
      items[items.length - 1].lines.push(
        line.replace(new RegExp(`^\\s{0,${baseIndent + 2}}`), '')
      );
    }
  }

  // Consecutive runs of task/non-task items become separate lists, so a
  // checklist after a plain list never converts its neighbours.
  const runs: { task: boolean; items: ListItem[] }[] = [];
  for (const item of items) {
    const task = item.checked !== null;
    const lastRun = runs[runs.length - 1];
    if (lastRun && lastRun.task === task) lastRun.items.push(item);
    else runs.push({ task, items: [item] });
  }

  const rendered = runs
    .map(run => {
      const body = run.items
        .map(item => {
          const content = parseBlocks(item.lines);
          return run.task
            ? `<li data-task-item="true" data-checked="${item.checked === true}">${content}</li>`
            : `<li>${content}</li>`;
        })
        .join('');
      if (run.task) return `<ul data-task-list="true">${body}</ul>`;
      if (ordered) {
        const startAttr = startOrder !== 1 ? ` start="${startOrder}"` : '';
        return `<ol${startAttr}>${body}</ol>`;
      }
      return `<ul>${body}</ul>`;
    })
    .join('');

  return rest ? rendered + parseListRegion(rest) : rendered;
}

/** A GFM table region (header, divider, body rows) → <table>. */
function parseTableRegion(lines: string[]): string {
  const splitRow = (line: string): string[] =>
    line
      .trim()
      .replace(/^\|/, '')
      .replace(/\|$/, '')
      .split(/(?<!\\)\|/)
      .map(cell => cell.trim().replace(/\\\|/g, '|'));

  const header = splitRow(lines[0]);
  const rows = lines.slice(2).map(splitRow);
  const renderRow = (cells: string[], tag: 'th' | 'td'): string =>
    `<tr>${header
      .map((_, index) => `<${tag}><p>${inlineToHtml(cells[index] ?? '')}</p></${tag}>`)
      .join('')}</tr>`;

  return `<table>${renderRow(header, 'th')}${rows
    .map(row => renderRow(row, 'td'))
    .join('')}</table>`;
}

function parseBlocks(lines: string[]): string {
  const out: string[] = [];
  let i = 0;

  while (i < lines.length) {
    const line = lines[i];
    if (!line.trim()) {
      i += 1;
      continue;
    }

    // Fenced code block.
    const fence = FENCE_RE.exec(line);
    if (fence) {
      const closing = new RegExp(`^\\s{0,3}${fence[1]}\\s*$`);
      const buffer: string[] = [];
      i += 1;
      while (i < lines.length && !closing.test(lines[i])) {
        buffer.push(lines[i]);
        i += 1;
      }
      i += 1; // Skip the closing fence.
      const langAttr = fence[2] ? ` data-language="${escapeHtml(fence[2])}"` : '';
      out.push(`<pre${langAttr}><code>${escapeHtml(buffer.join('\n'))}</code></pre>`);
      continue;
    }

    // Heading (with optional trailing #'s, per CommonMark).
    const heading = HEADING_RE.exec(line);
    if (heading) {
      const level = heading[1].length;
      const text = heading[2].replace(/\s+#+\s*$/, '');
      out.push(`<h${level}>${inlineToHtml(text)}</h${level}>`);
      i += 1;
      continue;
    }

    // Horizontal rule (checked before lists: "---" vs "- item").
    if (HR_RE.test(line)) {
      out.push('<hr>');
      i += 1;
      continue;
    }

    // Blockquote: consecutive quoted lines, including lazy continuations.
    if (QUOTE_RE.test(line)) {
      const buffer: string[] = [];
      while (
        i < lines.length &&
        (QUOTE_RE.test(lines[i]) ||
          (buffer.length > 0 && lines[i].trim() !== '' && !isBlockStart(lines[i])))
      ) {
        buffer.push(lines[i].replace(QUOTE_RE, ''));
        i += 1;
      }
      out.push(`<blockquote>${parseBlocks(buffer)}</blockquote>`);
      continue;
    }

    // List: the region runs until a blank line not followed by more list
    // content, or a non-indented non-list line.
    if (BULLET_RE.test(line) || ORDERED_RE.test(line)) {
      const buffer: string[] = [];
      while (i < lines.length) {
        const current = lines[i];
        if (current.trim() === '') {
          const next = lines[i + 1];
          if (next !== undefined && (BULLET_RE.test(next) || ORDERED_RE.test(next) || /^\s{2,}\S/.test(next))) {
            i += 1;
            continue;
          }
          break;
        }
        if (
          !BULLET_RE.test(current) &&
          !ORDERED_RE.test(current) &&
          !/^\s{2,}\S/.test(current)
        ) {
          break;
        }
        buffer.push(current);
        i += 1;
      }
      out.push(parseListRegion(buffer));
      continue;
    }

    // GFM table: a pipe row followed by a divider row.
    if (
      line.includes('|') &&
      i + 1 < lines.length &&
      TABLE_DIVIDER_RE.test(lines[i + 1]) &&
      lines[i + 1].includes('|')
    ) {
      const buffer: string[] = [lines[i], lines[i + 1]];
      i += 2;
      while (i < lines.length && lines[i].includes('|') && lines[i].trim() !== '') {
        buffer.push(lines[i]);
        i += 1;
      }
      out.push(parseTableRegion(buffer));
      continue;
    }

    // Paragraph: collect until a blank line or the start of another block.
    const buffer: string[] = [line];
    i += 1;
    while (i < lines.length && lines[i].trim() !== '' && !isBlockStart(lines[i])) {
      buffer.push(lines[i]);
      i += 1;
    }
    out.push(`<p>${inlineToHtml(buffer.join('\n'))}</p>`);
  }

  return out.join('');
}

/** Parses a Markdown string into schema-compatible HTML. */
export function markdownToHtml(markdown: string): string {
  return parseBlocks(markdown.replace(/\r\n?/g, '\n').split('\n'));
}

/**
 * Conservative sniff for "this plain text is probably Markdown": one block
 * construct or one unambiguous inline construct is required. HTML-looking
 * text is never treated as Markdown.
 */
export function looksLikeMarkdown(text: string): boolean {
  if (/<\/?[a-z][^>]*>/i.test(text)) return false;
  const block =
    /^\s{0,3}(#{1,6}\s+\S|```|(?:[-*+]|\d+[.)])\s+\S|>\s?\S|\|.+\|)/m;
  const inline =
    /\*\*[^*\n]+\*\*|~~[^~\n]+~~|\[[^\]\n]+\]\([^)\n]+\)|`[^`\n]+`/;
  return block.test(text) || inline.test(text);
}