index.js

const fs = require('fs-extra');
const path = require('path');

/**
 * Docusaurus plugin to expose documentation as raw markdown for AI/LLM access
 * - Converts MDX files to clean markdown
 * - Generates _sitemap.md with full documentation structure
 * - Adds "AI & Markdown" dropdown to each page with ChatGPT/Claude integration
 */

// Convert Tabs/TabItem components to readable markdown format
function convertTabsToMarkdown(content) {
  const tabsPattern = /<Tabs[^>]*>([\s\S]*?)<\/Tabs>/g;

  return content.replace(tabsPattern, (fullMatch, tabsContent) => {
    const tabItemPattern = /<TabItem\s+[^>]*value="([^"]*)"[^>]*label="([^"]*)"[^>]*>([\s\S]*?)<\/TabItem>/g;

    let result = [];
    let match;

    while ((match = tabItemPattern.exec(tabsContent)) !== null) {
      const [, value, label, itemContent] = match;

      const cleanContent = itemContent
        .split('\n')
        .map(line => line.replace(/^\s{4}/, ''))
        .join('\n')
        .trim();

      result.push(`**${label}:**\n\n${cleanContent}`);
    }

    return result.join('\n\n---\n\n');
  });
}

// Convert details/summary components to readable markdown format
function convertDetailsToMarkdown(content) {
  const detailsPattern = /<details>\s*<summary>(<strong>)?([^<]+)(<\/strong>)?<\/summary>([\s\S]*?)<\/details>/g;

  return content.replace(detailsPattern, (fullMatch, strongOpen, summaryText, strongClose, detailsContent) => {
    const cleanContent = detailsContent
      .split('\n')
      .map(line => line.trim())
      .filter(line => line.length > 0)
      .join('\n')
      .trim();

    return `### ${summaryText.trim()}\n\n${cleanContent}`;
  });
}

// Extract slug from frontmatter if present
function extractSlug(content) {
  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
  if (frontmatterMatch) {
    const frontmatter = frontmatterMatch[1];
    const slugMatch = frontmatter.match(/^slug:\s*(.+)$/m);
    if (slugMatch) {
      return slugMatch[1].trim();
    }
  }
  return null;
}

// Extract title from frontmatter or first heading
function extractTitle(content) {
  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
  if (frontmatterMatch) {
    const frontmatter = frontmatterMatch[1];
    const titleMatch = frontmatter.match(/^title:\s*["']?([^"'\n]+)["']?$/m);
    if (titleMatch) {
      return titleMatch[1].trim();
    }
  }
  const h1Match = content.match(/^#\s+(.+)$/m);
  if (h1Match) {
    return h1Match[1].trim();
  }
  return null;
}

// Extract sidebar_position from frontmatter
function extractSidebarPosition(content) {
  const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
  if (frontmatterMatch) {
    const frontmatter = frontmatterMatch[1];
    const posMatch = frontmatter.match(/^sidebar_position:\s*(\d+)/m);
    if (posMatch) {
      return parseInt(posMatch[1], 10);
    }
  }
  return 999;
}

// Clean markdown content for raw display - remove MDX/Docusaurus-specific syntax
function cleanMarkdownForDisplay(content, filepath, siteUrl, projectName) {
  const fileDir = filepath.replace(/[^/]*$/, '');

  // Strip YAML front matter
  content = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '');

  // Add header with link to sitemap
  const header = `> This is official ${projectName} documentation. See [full sitemap](${siteUrl}/_sitemap.md) for all pages.\n\n`;
  content = header + content;

  // Remove import statements
  content = content.replace(/^import\s+.*?from\s+['"].*?['"];?\s*$/gm, '');

  // Convert HTML images to markdown
  content = content.replace(
    /<p align="center">\s*\n?\s*<img src=\{require\(['"]([^'"]+)['"]\)\.default\} alt="([^"]*)"(?:\s+width="[^"]*")?\s*\/>\s*\n?\s*<\/p>/g,
    (match, imagePath, alt) => {
      const cleanPath = imagePath.replace('@site/static/', '/');
      return `![${alt}](${cleanPath})`;
    }
  );

  // Convert YouTube iframes to text links
  content = content.replace(
    /<iframe[^>]*src="https:\/\/www\.youtube\.com\/embed\/([a-zA-Z0-9_-]+)[^"]*"[^>]*title="([^"]*)"[^>]*>[\s\S]*?<\/iframe>/g,
    'Watch the video: [$2](https://www.youtube.com/watch?v=$1)'
  );

  // Clean HTML5 video tags
  content = content.replace(
    /<video[^>]*>\s*<source src=["']([^"']+)["'][^>]*>\s*<\/video>/g,
    '<video controls>\n  <source src="$1" type="video/mp4" />\n  <p>Video demonstration: $1</p>\n</video>'
  );

  // Remove <Head> components
  content = content.replace(/<Head>[\s\S]*?<\/Head>/g, '');

  // Convert Tabs/TabItem components
  content = convertTabsToMarkdown(content);

  // Convert details/summary components
  content = convertDetailsToMarkdown(content);

  // Remove custom React/MDX components
  content = content.replace(/<[A-Z][a-zA-Z]*[\s\S]*?(?:\/>|<\/[A-Z][a-zA-Z]*>)/g, '');

  // Convert relative image paths to absolute paths
  content = content.replace(
    /!\[([^\]]*)\]\((\.\/)?img\/([^)]+)\)/g,
    (match, alt, relPrefix, filename) => {
      return `![${alt}](/docs/${fileDir}img/${filename})`;
    }
  );

  // Remove any leading blank lines
  content = content.replace(/^\s*\n/, '');

  return content;
}

// Recursively find all markdown/MDX files in a directory
function findMarkdownFiles(dir, fileList = [], baseDir = dir) {
  const files = fs.readdirSync(dir);

  files.forEach((file) => {
    const filePath = path.join(dir, file);
    const stat = fs.statSync(filePath);

    if (stat.isDirectory()) {
      findMarkdownFiles(filePath, fileList, baseDir);
    } else if (file.endsWith('.md') || file.endsWith('.mdx')) {
      const relativePath = path.relative(baseDir, filePath);
      fileList.push(relativePath);
    }
  });

  return fileList;
}

// Generate a markdown sitemap following sidebar hierarchy
function generateSitemap(mdFiles, docsDir, siteUrl, sidebarStructure, projectName, basePath = '') {
  const lines = [
    `# ${projectName} Documentation Sitemap`,
    '',
    `> Official ${projectName} documentation: ${siteUrl}`,
    '',
    'Each page link below points to the markdown version of the page.',
    '',
  ];

  // Build file data map
  const fileDataMap = {};
  for (const mdFile of mdFiles) {
    const sourcePath = path.join(docsDir, mdFile);
    const content = fs.readFileSync(sourcePath, 'utf8');
    const slug = extractSlug(content);
    const title = extractTitle(content) || mdFile.replace(/\.mdx?$/, '').split('/').pop();
    const position = extractSidebarPosition(content);

    let urlPath;
    if (slug) {
      urlPath = slug.startsWith('/') ? slug : '/' + slug;
      if (urlPath === '/') urlPath = '/introduction';
    } else {
      urlPath = '/' + mdFile.replace(/\.mdx?$/, '');
    }

    // Prepend basePath to URL
    const fullUrlPath = basePath + urlPath;

    fileDataMap[mdFile] = {
      title,
      url: `${siteUrl}${fullUrlPath}.md`,
      position,
      dirName: mdFile.includes('/') ? mdFile.split('/')[0] : null
    };
  }

  // Get files for a directory, sorted by sidebar_position
  function getFilesForDir(dirName) {
    return Object.entries(fileDataMap)
      .filter(([file, data]) => {
        if (!dirName) return !file.includes('/');
        return file.startsWith(dirName + '/');
      })
      .sort((a, b) => a[1].position - b[1].position)
      .map(([file, data]) => ({ file, ...data }));
  }

  // Render files with subcategories
  function renderCategory(dirName, indent = 0) {
    const files = getFilesForDir(dirName);
    const prefix = '  '.repeat(indent) + '- ';

    const subDirs = new Map();
    const topLevelFiles = [];

    for (const fileData of files) {
      const relativePath = dirName ? fileData.file.slice(dirName.length + 1) : fileData.file;
      if (relativePath.includes('/')) {
        const subDir = relativePath.split('/')[0];
        if (!subDirs.has(subDir)) {
          subDirs.set(subDir, []);
        }
        subDirs.get(subDir).push(fileData);
      } else {
        topLevelFiles.push(fileData);
      }
    }

    for (const fileData of topLevelFiles) {
      lines.push(`${prefix}[${fileData.title}](${fileData.url})`);
    }

    for (const [subDir, subFiles] of subDirs) {
      const subDirLabel = subDir.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
      lines.push(`${prefix}**${subDirLabel}/**`);
      subFiles.sort((a, b) => a.position - b.position);
      for (const fileData of subFiles) {
        lines.push(`${'  '.repeat(indent + 1)}- [${fileData.title}](${fileData.url})`);
      }
    }
  }

  // Follow sidebar structure if provided
  if (sidebarStructure && sidebarStructure.length > 0) {
    for (const item of sidebarStructure) {
      if (item.type === 'doc') {
        const fileEntry = Object.entries(fileDataMap).find(([file]) =>
          file.replace(/\.mdx?$/, '') === item.id
        );
        if (fileEntry) {
          lines.push(`- [${fileEntry[1].title}](${fileEntry[1].url})`);
        }
      } else if (item.type === 'category') {
        lines.push(`- **${item.label}**`);
        renderCategory(item.dirName, 1);
      }
    }
  } else {
    // Auto-generate from file structure
    const topLevelDirs = [...new Set(mdFiles.filter(f => f.includes('/')).map(f => f.split('/')[0]))].sort();
    const topLevelFiles = mdFiles.filter(f => !f.includes('/'));

    for (const file of topLevelFiles) {
      const data = fileDataMap[file];
      if (data) {
        lines.push(`- [${data.title}](${data.url})`);
      }
    }

    for (const dir of topLevelDirs) {
      const dirLabel = dir.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
      lines.push(`- **${dirLabel}**`);
      renderCategory(dir, 1);
    }
  }

  lines.push('');
  lines.push('---');
  lines.push('');
  lines.push(`Generated: ${new Date().toISOString()}`);

  return lines.join('\n');
}

// Parse sidebars.ts/js to extract structure
function parseSidebars(siteDir) {
  const possiblePaths = [
    path.join(siteDir, 'sidebars.ts'),
    path.join(siteDir, 'sidebars.js'),
  ];

  for (const sidebarPath of possiblePaths) {
    if (fs.existsSync(sidebarPath)) {
      try {
        const content = fs.readFileSync(sidebarPath, 'utf8');
        const structure = [];

        // Parse category blocks with autogenerated dirName
        const categoryRegex = /\{\s*type:\s*['"]category['"]\s*,\s*label:\s*['"]([^'"]+)['"]\s*,\s*items:\s*\[\s*\{\s*type:\s*['"]autogenerated['"]\s*,\s*dirName:\s*['"]([^'"]+)['"]\s*\}/g;
        let match;
        while ((match = categoryRegex.exec(content)) !== null) {
          structure.push({ type: 'category', label: match[1], dirName: match[2] });
        }

        // Parse standalone doc references (simple string entries)
        const docsMatch = content.match(/docs:\s*\[([\s\S]*?)\]/);
        if (docsMatch) {
          const docsContent = docsMatch[1];
          // Find string entries like 'introduction' or "help-and-support"
          const stringDocRegex = /['"]([a-zA-Z0-9-_/]+)['"]\s*(?:,|$)/g;
          let docMatch;
          while ((docMatch = stringDocRegex.exec(docsContent)) !== null) {
            const docId = docMatch[1];
            // Only add if not already captured as category
            if (!structure.some(s => s.dirName === docId)) {
              structure.push({ type: 'doc', id: docId, label: docId });
            }
          }
        }

        return structure;
      } catch (e) {
        console.warn('[docs-to-markdown] Could not parse sidebars file:', e.message);
      }
    }
  }
  return [];
}

// Build a map of slug -> source file path for dev server
function buildSlugToFileMap(docsDir, rootDocId) {
  const mdFiles = findMarkdownFiles(docsDir);
  const slugMap = {};

  for (const mdFile of mdFiles) {
    const sourcePath = path.join(docsDir, mdFile);
    try {
      const content = fs.readFileSync(sourcePath, 'utf8');
      const slug = extractSlug(content);

      let urlPath;
      if (slug) {
        urlPath = slug.startsWith('/') ? slug.slice(1) : slug;
        if (urlPath === '' || urlPath === '/') urlPath = rootDocId;
      } else {
        urlPath = mdFile.replace(/\.mdx?$/, '');
      }

      slugMap[urlPath] = { sourcePath, mdFile };
    } catch (e) {
      // Skip files that can't be read
    }
  }

  return slugMap;
}

/**
 * Plugin factory function
 * @param {Object} context - Docusaurus context
 * @param {Object} options - Plugin options
 * @param {string} options.rootDocId - Document ID for root slug (default: 'introduction')
 * @param {string} options.projectName - Project name for headers (default: from site title)
 * @param {string} options.routeBasePath - Base path for docs routes (default: '/')
 */
module.exports = function docsToMarkdownPlugin(context, options = {}) {
  const { rootDocId = 'introduction', routeBasePath = '/' } = options;
  const projectName = options.projectName || context.siteConfig.title || 'Documentation';
  const sidebarStructure = parseSidebars(context.siteDir);
  const docsDir = path.join(context.siteDir, 'docs');

  // Normalize routeBasePath - ensure it starts with / but doesn't end with /
  const normalizedBasePath = routeBasePath === '/' ? '' :
    (routeBasePath.startsWith('/') ? routeBasePath : '/' + routeBasePath).replace(/\/$/, '');

  return {
    name: 'docusaurus-plugin-docs-to-markdown',

    getThemePath() {
      return path.resolve(__dirname, './theme');
    },

    // Add dev server middleware to serve .md files on-the-fly
    configureWebpack(config, isServer, utils) {
      return {
        devServer: {
          setupMiddlewares(middlewares, devServer) {
            // Create middleware function to handle .md requests
            const mdMiddleware = (req, res, next) => {
              const urlPath = req.path;

              // Only handle .md requests
              if (!urlPath.endsWith('.md')) {
                return next();
              }

              // Handle _sitemap.md specially
              if (urlPath === '/_sitemap.md') {
                try {
                  const mdFiles = findMarkdownFiles(docsDir);
                  const siteUrl = context.siteConfig.url || 'http://localhost:3000';
                  const sitemap = generateSitemap(mdFiles, docsDir, siteUrl, sidebarStructure, projectName, normalizedBasePath);
                  res.setHeader('Content-Type', 'text/plain; charset=utf-8');
                  res.send(sitemap);
                  return;
                } catch (e) {
                  console.error('[docs-to-markdown] Error generating sitemap:', e.message);
                  return next();
                }
              }

              // Strip .md extension and leading slash to get the slug
              let slug = urlPath.replace(/\.md$/, '').replace(/^\//, '');

              // Strip routeBasePath prefix if present
              if (normalizedBasePath && slug.startsWith(normalizedBasePath.slice(1) + '/')) {
                slug = slug.slice(normalizedBasePath.length);
              }

              // Build slug map (rebuilt on each request to pick up changes)
              const slugMap = buildSlugToFileMap(docsDir, rootDocId);

              const fileInfo = slugMap[slug];
              if (!fileInfo) {
                return next();
              }

              try {
                const content = fs.readFileSync(fileInfo.sourcePath, 'utf8');
                const siteUrl = context.siteConfig.url || 'http://localhost:3000';
                const cleanedContent = cleanMarkdownForDisplay(content, fileInfo.mdFile, siteUrl, projectName);

                res.setHeader('Content-Type', 'text/plain; charset=utf-8');
                res.send(cleanedContent);
              } catch (e) {
                console.error(`[docs-to-markdown] Error serving ${slug}.md:`, e.message);
                next();
              }
            };

            // Add our middleware at the very beginning
            middlewares.unshift({
              name: 'docs-to-markdown',
              middleware: mdMiddleware,
            });

            return middlewares;
          },
        },
      };
    },

    async postBuild({ outDir }) {
      const buildDir = outDir;
      const siteUrl = context.siteConfig.url;

      console.log('[docs-to-markdown] Copying markdown source files...');
      if (normalizedBasePath) {
        console.log(`[docs-to-markdown] Using routeBasePath: ${normalizedBasePath}`);
      }

      const mdFiles = findMarkdownFiles(docsDir);
      let copiedCount = 0;

      for (const mdFile of mdFiles) {
        const sourcePath = path.join(docsDir, mdFile);

        try {
          const content = await fs.readFile(sourcePath, 'utf8');
          const slug = extractSlug(content);

          let destFile;
          if (slug) {
            let slugPath = slug.startsWith('/') ? slug.slice(1) : slug;
            if (slugPath === '' || slugPath === '/') slugPath = rootDocId;
            destFile = slugPath + '.md';
          } else {
            destFile = mdFile.replace(/\.mdx$/, '.md');
          }

          // Prepend routeBasePath to destination
          const destPath = normalizedBasePath
            ? path.join(buildDir, normalizedBasePath.slice(1), destFile)
            : path.join(buildDir, destFile);

          await fs.ensureDir(path.dirname(destPath));

          const cleanedContent = cleanMarkdownForDisplay(content, mdFile, siteUrl, projectName);

          await fs.writeFile(destPath, cleanedContent, 'utf8');
          copiedCount++;
        } catch (error) {
          console.error(`  Failed to process ${mdFile}:`, error.message);
        }
      }

      console.log(`[docs-to-markdown] Successfully copied ${copiedCount} markdown files`);

      // Generate _sitemap.md
      console.log('[docs-to-markdown] Generating _sitemap.md...');
      const sitemap = generateSitemap(mdFiles, docsDir, siteUrl, sidebarStructure, projectName, normalizedBasePath);
      await fs.writeFile(path.join(buildDir, '_sitemap.md'), sitemap, 'utf8');
      console.log('[docs-to-markdown] Successfully generated _sitemap.md');
    },
  };
};