stack/docs/scripts/generate-docs.js

import fs from 'fs';
import { glob } from 'glob';
import yaml from 'js-yaml';
import path from 'path';
import { fileURLToPath } from 'url';

// Get __dirname equivalent in ESM
const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Configure paths
const TEMPLATE_DIR = path.resolve(__dirname, '../templates');
const PYTHON_TEMPLATE_DIR = path.resolve(__dirname, '../templates-python');
const OUTPUT_BASE_DIR = path.resolve(__dirname, '../content/docs');
const CONFIG_FILE = path.resolve(__dirname, '../docs-platform.yml');
const PLATFORMS = ['next', 'react', 'js', 'python'];

// Platform groups mapping
const PLATFORM_GROUPS = {
  'react-like': ['next', 'react'],  // Platforms that use React components
  'js-like': ['next', 'react', 'js']  // Platforms that use JavaScript SDK (includes React-based platforms)
};

// Load platform configuration
let platformConfig = {};
try {
  const configContent = fs.readFileSync(CONFIG_FILE, 'utf8');
  platformConfig = yaml.load(configContent);
  console.log('Loaded platform configuration from docs-platform.yml');
} catch (error) {
  console.error('Failed to load platform configuration:', error.message);
  console.log('Falling back to include all files for all platforms');
}

// Platform folder naming - now using root folders
function getFolderName(platform) {
  return platform; // Use direct platform names instead of pages-{platform}
}

// Platform display names
function getPlatformDisplayName(platform) {
  const platformNames = {
    'next': 'Next.js',
    'react': 'React',
    'js': 'JavaScript',
    'python': 'Python'
  };
  return platformNames[platform] || platform;
}

// Platform-specific content markers - Updated regex to handle both syntaxes (with and without colon)
const PLATFORM_START_MARKER = /{\s*\/\*\s*IF_PLATFORM:?\s*([\w-]+)\s*\*\/\s*}/;
const PLATFORM_ELSE_MARKER = /{\s*\/\*\s*ELSE_IF_PLATFORM:?\s+([\w-]+)\s*\*\/\s*}/;
const PLATFORM_END_MARKER = /{\s*\/\*\s*END_PLATFORM\s*\*\/\s*}/;

/**
 * Check if a platform or platform group includes the target platform
 */
function isPlatformMatch(platformSpec, targetPlatform) {
  // Direct platform match
  if (platformSpec === targetPlatform) {
    return true;
  }
  
  // Platform group match
  if (PLATFORM_GROUPS[platformSpec]) {
    return PLATFORM_GROUPS[platformSpec].includes(targetPlatform);
  }
  
  return false;
}

/**
 * Check if a file should be included for a specific platform
 */
function shouldIncludeFileForPlatform(platform, filePath) {
  // If no configuration loaded, include everything
  if (!platformConfig.pages) {
    return true;
  }
  
  // Find the page configuration for this file
  const pageConfig = platformConfig.pages.find(page => page.path === filePath);
  
  // If no specific configuration found, exclude by default
  if (!pageConfig) {
    console.log(`No configuration found for ${filePath}, excluding by default`);
    return false;
  }
  
  // Check if the platform is in the allowed list
  return pageConfig.platforms.includes(platform);
}

/**
 * Process a template file for a specific platform
 */
function processTemplateForPlatform(content, targetPlatform) {
  const lines = content.split('\n');
  let result = [];
  let currentPlatformSpec = null;
  let isIncluding = true;
  let platformSection = false;

  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    
    // Check for platform start
    const startMatch = line.match(PLATFORM_START_MARKER);
    if (startMatch) {
      platformSection = true;
      currentPlatformSpec = startMatch[1];
      isIncluding = isPlatformMatch(currentPlatformSpec, targetPlatform);
      continue;
    }

    // Check for platform else
    const elseMatch = line.match(PLATFORM_ELSE_MARKER);
    if (elseMatch && platformSection) {
      currentPlatformSpec = elseMatch[1];
      isIncluding = isPlatformMatch(currentPlatformSpec, targetPlatform);
      continue;
    }

    // Check for platform end
    const endMatch = line.match(PLATFORM_END_MARKER);
    if (endMatch && platformSection) {
      platformSection = false;
      isIncluding = true;
      continue;
    }

    // Include the line if we're supposed to
    if (isIncluding) {
      result.push(line);
    }
  }

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

/**
 * Generate meta.json files for Fumadocs navigation
 */
function generateMetaFiles() {
  // Process meta.json files for each platform from templates
  for (const platform of PLATFORMS) {
    const folderName = getFolderName(platform);
    const platformDisplayName = getPlatformDisplayName(platform);
    
    // For Python platform, prioritize Python-specific templates, but also include shared templates
    const templateDir = (platform === 'python' && fs.existsSync(PYTHON_TEMPLATE_DIR)) ? PYTHON_TEMPLATE_DIR : TEMPLATE_DIR;
    
    // Find all meta.json files in the appropriate template directory
    const metaFiles = glob.sync('**/meta.json', { cwd: templateDir });
    
    // For Python, also get meta.json files from shared templates (excluding root meta.json to avoid conflicts)
    let sharedMetaFiles = [];
    if (platform === 'python' && fs.existsSync(PYTHON_TEMPLATE_DIR)) {
      sharedMetaFiles = glob.sync('**/meta.json', { cwd: TEMPLATE_DIR }).filter(file => file !== 'meta.json');
    }
    
    // Process Python-specific meta files
    for (const metaFile of metaFiles) {
      const srcPath = path.join(templateDir, metaFile);
      const destPath = path.join(OUTPUT_BASE_DIR, folderName, metaFile);
      
      // If this is a nested meta.json (not root), check if the folder should exist for this platform
      if (metaFile !== 'meta.json') {
        const folderPath = path.dirname(metaFile);
        
        // Check if any pages in this folder are included for this platform
        const hasContentInFolder = platformConfig.pages && platformConfig.pages.some(configPage => 
          configPage.path.startsWith(`${folderPath}/`) && 
          configPage.platforms.includes(platform)
        );
        
        if (!hasContentInFolder) {
          console.log(`Skipped meta.json for ${folderPath} (no content for ${platform})`);
          continue; // Skip this meta.json file
        }
      }
      
      // Read and parse the template meta.json
      const templateContent = fs.readFileSync(srcPath, 'utf8');
      const metaData = JSON.parse(templateContent);
      
      // If this is the root meta.json, customize it for the platform
      if (metaFile === 'meta.json') {
        metaData.title = platformDisplayName;
        metaData.description = `Stack Auth for ${platformDisplayName} applications`;
        metaData.root = true;
        
        // Filter pages based on platform configuration
        if (platformConfig.pages && metaData.pages) {
          const cleanedPages = [];
          let currentSectionPages = [];
          let currentSectionHeader = null;
          
          for (let i = 0; i < metaData.pages.length; i++) {
            const page = metaData.pages[i];
            
            // If this is a section divider
            if (typeof page === 'string' && page.startsWith('---')) {
              // Process the previous section first (or pages before first section)
              if (currentSectionPages.length > 0) {
                if (currentSectionHeader !== null) {
                  // Add section header if we had one
                  cleanedPages.push(currentSectionHeader);
                }
                cleanedPages.push(...currentSectionPages);
              }
              
              // Start new section
              currentSectionHeader = page;
              currentSectionPages = [];
            } 
            // If this is a folder reference (like "...customization")
            else if (typeof page === 'string' && page.startsWith('...')) {
              // Only include folder references if they have content for this platform
              const folderName = page.substring(3); // Remove "..."
              const hasContentInFolder = platformConfig.pages.some(configPage => 
                configPage.path.startsWith(`${folderName}/`) && 
                configPage.platforms.includes(platform)
              );
              
              if (hasContentInFolder) {
                currentSectionPages.push(page);
              }
            }
            // Regular page
            else {
              // Check if this is actually a folder reference vs a page reference
              // Check both template directories for Python
              let folderPath = path.join(templateDir, page);
              let isActualFolder = fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory();
              
              // For Python, also check shared templates directory
              if (!isActualFolder && platform === 'python') {
                folderPath = path.join(TEMPLATE_DIR, page);
                isActualFolder = fs.existsSync(folderPath) && fs.statSync(folderPath).isDirectory();
              }
              
              if (isActualFolder) {
                // This is a folder reference - check if folder has content for this platform
                const hasContentInFolder = platformConfig.pages.some(configPage => 
                  configPage.path.startsWith(`${page}/`) && 
                  configPage.platforms.includes(platform)
                );
                
                if (hasContentInFolder) {
                  currentSectionPages.push(page);
                }
              } else {
                // This is a regular page reference
                const pagePath = `${page}.mdx`;
                const shouldInclude = shouldIncludeFileForPlatform(platform, pagePath);
                if (shouldInclude) {
                  currentSectionPages.push(page);
                }
              }
            }
          }
          
          // Don't forget the last section (or remaining pages)
          if (currentSectionPages.length > 0) {
            if (currentSectionHeader !== null) {
              cleanedPages.push(currentSectionHeader);
            }
            cleanedPages.push(...currentSectionPages);
          }
          
          metaData.pages = cleanedPages;
        }
      }
      
      // Create directory if it doesn't exist
      fs.mkdirSync(path.dirname(destPath), { recursive: true });
      
      // Write the processed meta.json
      fs.writeFileSync(destPath, JSON.stringify(metaData, null, 2));
      console.log(`Generated platform-specific meta.json for ${platform}: ${destPath}`);
    }
    
    // For Python, also process shared meta.json files (but not root)
    for (const metaFile of sharedMetaFiles) {
      const folderPath = path.dirname(metaFile);
      
      // Check if any pages in this folder are included for Python
      const hasContentInFolder = platformConfig.pages && platformConfig.pages.some(configPage => 
        configPage.path.startsWith(`${folderPath}/`) && 
        configPage.platforms.includes(platform)
      );
      
      if (hasContentInFolder) {
        const srcPath = path.join(TEMPLATE_DIR, metaFile);
        const destPath = path.join(OUTPUT_BASE_DIR, folderName, metaFile);
        
        // Read and copy the shared meta.json
        const templateContent = fs.readFileSync(srcPath, 'utf8');
        
        // Create directory if it doesn't exist
        fs.mkdirSync(path.dirname(destPath), { recursive: true });
        
        // Write the shared meta.json
        fs.writeFileSync(destPath, templateContent);
        console.log(`Generated shared meta.json for ${platform}: ${destPath}`);
      }
    }
  }
}

/**
 * Copy assets from template to platform-specific directories
 */
function copyAssets() {
  const assetDirs = ['imgs'];
  
  // Copy assets from main templates directory
  for (const dir of assetDirs) {
    const srcDir = path.join(TEMPLATE_DIR, dir);
    
    if (fs.existsSync(srcDir)) {
      // Copy assets to each platform directory
      for (const platform of PLATFORMS) {
        const folderName = getFolderName(platform);
        const destDir = path.join(OUTPUT_BASE_DIR, folderName, dir);
        fs.mkdirSync(destDir, { recursive: true });
        
        // Find and copy all files
        const files = glob.sync('**/*', { cwd: srcDir, nodir: true });
        for (const file of files) {
          const srcFile = path.join(srcDir, file);
          const destFile = path.join(destDir, file);
          fs.mkdirSync(path.dirname(destFile), { recursive: true });
          fs.copyFileSync(srcFile, destFile);
          console.log(`Copied asset: ${srcFile} -> ${destFile}`);
        }
      }
    }
  }
  
  // Copy Python-specific assets if they exist
  if (fs.existsSync(PYTHON_TEMPLATE_DIR)) {
    for (const dir of assetDirs) {
      const srcDir = path.join(PYTHON_TEMPLATE_DIR, dir);
      
      if (fs.existsSync(srcDir)) {
        const destDir = path.join(OUTPUT_BASE_DIR, 'python', dir);
        fs.mkdirSync(destDir, { recursive: true });
        
        // Find and copy all files
        const files = glob.sync('**/*', { cwd: srcDir, nodir: true });
        for (const file of files) {
          const srcFile = path.join(srcDir, file);
          const destFile = path.join(destDir, file);
          fs.mkdirSync(path.dirname(destFile), { recursive: true });
          fs.copyFileSync(srcFile, destFile);
          console.log(`Copied Python-specific asset: ${srcFile} -> ${destFile}`);
        }
      }
    }
  }
}

/**
 * Main function to generate platform-specific docs
 */
function generateDocs() {
  // Find all MDX files in the main template directory
  const templateFiles = glob.sync('**/*.mdx', { cwd: TEMPLATE_DIR });
  
  if (templateFiles.length === 0) {
    console.warn(`No template files found in ${TEMPLATE_DIR}`);
    return;
  }

  console.log(`Found ${templateFiles.length} shared template files`);
  
  // Process shared templates for each platform
  for (const platform of PLATFORMS) {
    const folderName = getFolderName(platform);
    const outputDir = path.join(OUTPUT_BASE_DIR, folderName);
    
    // Create the output directory
    fs.mkdirSync(outputDir, { recursive: true });
    
    // Process each shared template file
    for (const file of templateFiles) {
      // Check if this file should be included for this platform
      if (!shouldIncludeFileForPlatform(platform, file)) {
        console.log(`Skipped file (not configured for platform): ${file} for ${platform}`);
        continue;
      }
      
      const inputFile = path.join(TEMPLATE_DIR, file);
      const outputFile = path.join(outputDir, file);
      
      // Read the template
      const templateContent = fs.readFileSync(inputFile, 'utf8');
      
      // Process for this platform
      const processedContent = processTemplateForPlatform(templateContent, platform);
      
      // Create output directory if it doesn't exist
      fs.mkdirSync(path.dirname(outputFile), { recursive: true });
      
      // Write the processed content
      fs.writeFileSync(outputFile, processedContent);
      
      console.log(`Generated: ${outputFile}`);
    }
  }
  
  // Process Python-specific templates if they exist
  if (fs.existsSync(PYTHON_TEMPLATE_DIR)) {
    console.log(`Processing Python-specific templates from ${PYTHON_TEMPLATE_DIR}`);
    const pythonTemplateFiles = glob.sync('**/*.mdx', { cwd: PYTHON_TEMPLATE_DIR });
    
    if (pythonTemplateFiles.length > 0) {
      const pythonOutputDir = path.join(OUTPUT_BASE_DIR, 'python');
      
      for (const file of pythonTemplateFiles) {
        const inputFile = path.join(PYTHON_TEMPLATE_DIR, file);
        const outputFile = path.join(pythonOutputDir, file);
        
        // Read the Python-specific template
        const templateContent = fs.readFileSync(inputFile, 'utf8');
        
        // Create output directory if it doesn't exist
        fs.mkdirSync(path.dirname(outputFile), { recursive: true });
        
        // Write the content (no platform processing needed for Python-specific files)
        fs.writeFileSync(outputFile, templateContent);
        
        console.log(`Generated Python-specific: ${outputFile}`);
      }
    }
  }
  
  // Generate meta.json files for navigation
  generateMetaFiles();
  
  // Copy assets (images, etc.)
  copyAssets();
  
  console.log('Documentation generation complete!');
}

// Run the generator
generateDocs();