export function extractRSCContent(html: string): { title: string; content: string } | null {
  if (!html.includes("self.__next_f.push")) return null;

  const chunkMap = new Map<string, string>();
  const scriptRegex = /<script>self\.__next_f\.push\(\[1,"([\s\S]*?)"\]\)<\/script>/g;

  for (const match of html.matchAll(scriptRegex)) {
    let content: string;
    try {
      content = JSON.parse('"' + match[1] + '"');
    } catch {
      continue;
    }
    for (const line of content.split("\n")) {
      if (!line.trim()) continue;
      const colonIdx = line.indexOf(":");
      if (colonIdx <= 0 || colonIdx > 4) continue;
      const id = line.slice(0, colonIdx);
      if (!/^[0-9a-f]+$/i.test(id)) continue;
      const payload = line.slice(colonIdx + 1);
      if (!payload) continue;
      const existing = chunkMap.get(id);
      if (!existing || payload.length > existing.length) {
        chunkMap.set(id, payload);
      }
    }
  }

  if (chunkMap.size === 0) return null;

  const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
  const title = titleMatch?.[1]?.split("|")[0]?.trim() || "";

  const parsedCache = new Map<string, unknown>();
  function getParsedChunk(id: string): unknown | null {
    if (parsedCache.has(id)) return parsedCache.get(id);
    const chunk = chunkMap.get(id);
    if (!chunk || !chunk.startsWith("[")) {
      parsedCache.set(id, null);
      return null;
    }
    try {
      const parsed = JSON.parse(chunk);
      parsedCache.set(id, parsed);
      return parsed;
    } catch {
      parsedCache.set(id, null);
      return null;
    }
  }

  const visitedRefs = new Set<string>();

  function extractNode(node: unknown, ctx = { inCode: false }): string {
    if (node === null || node === undefined) return "";
    if (typeof node === "string") {
      const refMatch = node.match(/^\$L([0-9a-f]+)$/i);
      if (refMatch) {
        const refId = refMatch[1];
        if (visitedRefs.has(refId)) return "";
        visitedRefs.add(refId);
        const refNode = getParsedChunk(refId);
        const result = refNode ? extractNode(refNode, ctx) : "";
        visitedRefs.delete(refId);
        return result;
      }
      if (!ctx.inCode && (node === "$undefined" || node === "$" || /^\$[A-Z]/.test(node))) {
        return "";
      }
      return node.trim() ? node : "";
    }
    if (typeof node === "number") return String(node);
    if (typeof node === "boolean") return "";
    if (!Array.isArray(node)) return "";

    if (node[0] === "$" && typeof node[1] === "string") {
      const tag = node[1] as string;
      const props = (node[3] || {}) as Record<string, unknown>;
      const skipTags = [
        "script", "style", "svg", "path", "circle", "link", "meta",
        "template", "button", "input", "nav", "footer", "aside",
      ];
      if (skipTags.includes(tag)) return "";

      if (tag.startsWith("$L")) {
        const refId = tag.slice(2);
        if (visitedRefs.has(refId)) return "";
        if (props.baseId && props.children) {
          return `## ${String(props.children)}\n\n`;
        }
        visitedRefs.add(refId);
        const refNode = getParsedChunk(refId);
        let result = "";
        if (refNode) result = extractNode(refNode, ctx);
        else if (props.children) result = extractNode(props.children, ctx);
        visitedRefs.delete(refId);
        return result;
      }

      const children = props.children;
      const content = children ? extractNode(children, ctx) : "";

      switch (tag) {
        case "h1": return `# ${content.trim()}\n\n`;
        case "h2": return `## ${content.trim()}\n\n`;
        case "h3": return `### ${content.trim()}\n\n`;
        case "h4": return `#### ${content.trim()}\n\n`;
        case "h5": return `##### ${content.trim()}\n\n`;
        case "h6": return `###### ${content.trim()}\n\n`;
        case "p": return `${content.trim()}\n\n`;
        case "code": {
          const cc = children ? extractNode(children, { inCode: true }) : "";
          return ctx.inCode ? cc : `\`${cc}\``;
        }
        case "pre": {
          const pc = children ? extractNode(children, { inCode: true }) : "";
          return "```\n" + pc + "\n```\n\n";
        }
        case "strong": case "b": return `**${content}**`;
        case "em": case "i": return `*${content}*`;
        case "li": return `- ${content.trim()}\n`;
        case "ul": case "ol": return content + "\n";
        case "blockquote": return `> ${content.trim()}\n\n`;
        case "a": {
          const href = props.href as string | undefined;
          return href && !href.startsWith("#") ? `[${content}](${href})` : content;
        }
        default: return content;
      }
    }

    return (node as unknown[]).map((n) => extractNode(n, ctx)).join("");
  }

  const contentParts: { order: number; text: string }[] = [];
  for (const [id] of chunkMap) {
    const parsed = getParsedChunk(id);
    if (!parsed) continue;
    visitedRefs.clear();
    const text = extractNode(parsed);
    if (text.trim().length > 50 && !text.includes("404") && !text.includes("not found")) {
      contentParts.push({ order: parseInt(id, 16) || 0, text: text.trim() });
    }
  }

  if (contentParts.length === 0) return null;
  contentParts.sort((a, b) => a.order - b.order);

  const seen = new Set<string>();
  const uniqueParts: string[] = [];
  for (const part of contentParts) {
    const key = part.text.slice(0, 150);
    if (!seen.has(key)) {
      seen.add(key);
      uniqueParts.push(part.text);
    }
  }

  const content = uniqueParts.join("\n\n").replace(/\n{3,}/g, "\n\n").trim();
  return content.length > 100 ? { title, content } : null;
}