const BAIJIAHAO_TABLE_STYLE = [
  "width: 100%",
  "border-collapse: collapse",
  "border-spacing: 0",
  "margin: 12px 0",
  "font-size: 15px",
  "line-height: 1.6",
  "color: #1f2937",
].join("; ");

const BAIJIAHAO_TABLE_CELL_STYLE = [
  "border: 1px solid #d9d9d9",
  "padding: 8px 10px",
  "vertical-align: middle",
  "word-break: break-word",
  "min-width: 64px",
].join("; ");

const BAIJIAHAO_TABLE_HEADER_CELL_STYLE = [
  BAIJIAHAO_TABLE_CELL_STYLE,
  "background-color: #f5f7fa",
  "font-weight: 600",
].join("; ");

const TABLE_PARAGRAPH_CELL_SEPARATOR = "   ";

const BAIJIAHAO_TABLE_ALLOWED_ATTRS = ["colspan", "rowspan", "align", "valign", "width"];

type ParsedParagraphTableRow = string[];

function hasUnescapedPipe(value: string): boolean {
  let escaped = false;
  for (const char of value) {
    if (escaped) {
      escaped = false;
      continue;
    }
    if (char === "\\") {
      escaped = true;
      continue;
    }
    if (char === "|") {
      return true;
    }
  }
  return false;
}

function splitMarkdownTableCells(value: string): string[] {
  const cells: string[] = [];
  let cell = "";
  let escaped = false;
  const trimmed = value.trim();
  const source = trimmed.startsWith("|") ? trimmed.slice(1) : trimmed;
  const content = source.endsWith("|") && !source.endsWith("\\|") ? source.slice(0, -1) : source;

  for (const char of content) {
    if (escaped) {
      cell += char;
      escaped = false;
      continue;
    }
    if (char === "\\") {
      escaped = true;
      cell += char;
      continue;
    }
    if (char === "|") {
      cells.push(cell.trim());
      cell = "";
      continue;
    }
    cell += char;
  }

  cells.push(cell.trim());
  return cells;
}

function isMarkdownTableRow(value: string): boolean {
  const trimmed = value.trim();
  return trimmed !== "" && hasUnescapedPipe(trimmed) && splitMarkdownTableCells(trimmed).length >= 2;
}

function isMarkdownTableSeparator(value: string): boolean {
  const cells = splitMarkdownTableCells(value).filter(Boolean);
  return cells.length >= 2 && cells.every((cell) => /^:?-{2,}:?$/.test(cell.trim()));
}

function isMarkdownTableStart(lines: string[], index: number): boolean {
  return isMarkdownTableRow(lines[index] ?? "") && isMarkdownTableSeparator(lines[index + 1] ?? "");
}

function isFenceBoundary(value: string): boolean {
  return /^\s*(```|~~~)/.test(value);
}

export function prepareBaijiahaoMarkdown(markdown: string): string {
  const source = markdown.replace(/\r\n?/g, "\n").trim();
  if (!source) {
    return "";
  }

  const lines = source.split("\n");
  const output: string[] = [];
  let inCodeFence = false;

  for (let index = 0; index < lines.length; index += 1) {
    const line = lines[index] ?? "";
    if (isFenceBoundary(line)) {
      inCodeFence = !inCodeFence;
      output.push(line);
      continue;
    }

    if (!inCodeFence && isMarkdownTableStart(lines, index)) {
      while (output.length > 0 && output[output.length - 1]?.trim() === "") {
        output.pop();
      }
      if (/^\s*#{1,6}\s*$/.test(output[output.length - 1] ?? "")) {
        output.pop();
      }
      if (output.length > 0 && output[output.length - 1]?.trim() !== "") {
        output.push("");
      }

      output.push(lines[index] ?? "");
      output.push(lines[index + 1] ?? "");
      index += 2;

      while (index < lines.length && isMarkdownTableRow(lines[index] ?? "")) {
        output.push(lines[index] ?? "");
        index += 1;
      }

      if (index < lines.length && lines[index]?.trim() !== "") {
        output.push("");
      }
      index -= 1;
      continue;
    }

    output.push(line);
  }

  return output.join("\n").trim();
}

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

function extractAttribute(sourceTag: string, attributeName: string): string | null {
  const matcher = new RegExp(`\\s${attributeName}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s"'>]+))`, "i");
  const match = matcher.exec(sourceTag);
  const value = match?.[1] ?? match?.[2] ?? match?.[3] ?? "";
  const trimmed = value.trim();
  return trimmed ? trimmed : null;
}

function allowedTableAttributes(sourceTag: string): string {
  return BAIJIAHAO_TABLE_ALLOWED_ATTRS
    .map((attributeName) => {
      const value = extractAttribute(sourceTag, attributeName);
      return value ? `${attributeName}="${escapeAttribute(value)}"` : "";
    })
    .filter(Boolean)
    .join(" ");
}

function normalizeCellContent(value: string): string {
  const trimmed = value.trim();
  return trimmed ? trimmed : "<br/>";
}

function normalizeTableCell(sourceTag: string, content: string, header: boolean): string {
  const attrs = allowedTableAttributes(sourceTag);
  const attrPrefix = attrs ? `${attrs} ` : "";
  const style = header ? BAIJIAHAO_TABLE_HEADER_CELL_STYLE : BAIJIAHAO_TABLE_CELL_STYLE;
  const normalizedContent = normalizeCellContent(content);
  const cellContent = header ? `<strong>${normalizedContent}</strong>` : normalizedContent;
  return `<td ${attrPrefix}style="${style}">${cellContent}</td>`;
}

function normalizeSingleTable(tableHtml: string): string {
  let body = tableHtml
    .replace(/^\s*<table\b[^>]*>/i, "")
    .replace(/<\/table>\s*$/i, "")
    .replace(/<caption\b[^>]*>[\s\S]*?<\/caption>/gi, "")
    .replace(/<colgroup\b[^>]*>[\s\S]*?<\/colgroup>/gi, "")
    .replace(/<col\b[^>]*\/?>/gi, "")
    .replace(/<\/?(?:thead|tbody|tfoot)\b[^>]*>/gi, "");

  body = body.replace(/<th\b([^>]*)>([\s\S]*?)<\/th>/gi, (_match, attrs: string, content: string) =>
    normalizeTableCell(`<th${attrs}>`, content, true),
  );
  body = body.replace(/<td\b([^>]*)>([\s\S]*?)<\/td>/gi, (_match, attrs: string, content: string) =>
    normalizeTableCell(`<td${attrs}>`, content, false),
  );

  let rowIndex = 0;
  body = body.replace(/<tr\b[^>]*>/gi, () => {
    rowIndex += 1;
    return rowIndex === 1 ? `<tr class="firstRow">` : "<tr>";
  });

  return `<table data-sort="sortDisabled" border="1" cellpadding="0" cellspacing="0" style="${BAIJIAHAO_TABLE_STYLE}"><tbody>${body.trim()}</tbody></table>`;
}

export function normalizeBaijiahaoTables(html: string): string {
  if (!/<table\b/i.test(html)) {
    return html;
  }
  return html.replace(/<table\b[^>]*>[\s\S]*?<\/table>/gi, (tableHtml) => normalizeSingleTable(tableHtml));
}

function normalizeParagraphCellContent(value: string): string {
  return value
    .trim()
    .replace(/<br\s*\/?>/gi, " ")
    .replace(/<\/?(?:p|div|section|article|header|footer|ul|ol|li|blockquote|h[1-6])\b[^>]*>/gi, " ")
    .replace(/\s+/g, " ")
    .trim();
}

function parseParagraphTableRows(tableHtml: string): ParsedParagraphTableRow[] {
  const rows: ParsedParagraphTableRow[] = [];
  for (const rowMatch of tableHtml.matchAll(/<tr\b[^>]*>([\s\S]*?)<\/tr>/gi)) {
    const cells: ParsedParagraphTableRow = [];
    const rowContent = rowMatch[1] ?? "";
    for (const cellMatch of rowContent.matchAll(/<(?:th|td)\b[^>]*>([\s\S]*?)<\/(?:th|td)>/gi)) {
      const content = normalizeParagraphCellContent(cellMatch[1] ?? "");
      if (content) {
        cells.push(content);
      }
    }
    if (cells.length > 0) {
      rows.push(cells);
    }
  }
  return rows;
}

function renderSingleTableAsParagraphRows(tableHtml: string): string {
  const rows = parseParagraphTableRows(tableHtml);
  if (!rows.length) {
    return "";
  }

  return rows
    .map((row) => `<p>${row.join(TABLE_PARAGRAPH_CELL_SEPARATOR)}</p>`)
    .join("");
}

export function renderTablesAsParagraphRows(html: string): string {
  if (!/<table\b/i.test(html)) {
    return html;
  }
  return html.replace(/<table\b[^>]*>[\s\S]*?<\/table>/gi, (tableHtml) =>
    renderSingleTableAsParagraphRows(tableHtml),
  );
}

export function renderBaijiahaoTablesAsBlocks(html: string): string {
  return renderTablesAsParagraphRows(html);
}

export function prepareBaijiahaoArticleHtml(html: string): string {
  return renderTablesAsParagraphRows(html).trim();
}