#!/usr/bin/env node

import fs from 'fs';
import path from 'path';
import { fileURLToPath } from 'url';
import { execSync } from 'child_process';

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

// Get the project root
const PROJECT_ROOT = path.join(__dirname, '..');
const APP_DIR = path.join(PROJECT_ROOT, 'app');

// Import utilities
import { discoverPages, generateSitemapXml, analyzeInternalLinks } from '../lib/seo-utils.js';
import { 
  defaultConfig as defaultLinkConfig, 
  calculatePageScore,
  getKeywordsForTarget,
  getAnchorTexts,
  isExcludedRoute,
  getMaxLinksForPage,
  getMinWordsBetweenLinks,
  findKeywordsInContent
} from '../lib/internal-link-config.js';

// Import readline only when needed
let readline;

/**
 * Display colored output in console
 */
function colorize(text, color) {
  const colors = {
    reset: '\x1b[0m',
    red: '\x1b[31m',
    green: '\x1b[32m',
    yellow: '\x1b[33m',
    blue: '\x1b[34m',
    magenta: '\x1b[35m',
    cyan: '\x1b[36m',
    white: '\x1b[37m'
  };
  return `${colors[color]}${text}${colors.reset}`;
}

/**
 * Display section header
 */
function displayHeader(title) {
  console.log(`\n${colorize('='.repeat(50), 'cyan')}`);
  console.log(colorize(`  ${title}`, 'cyan'));
  console.log(colorize('='.repeat(50), 'cyan'));
}

/**
 * Display success message
 */
function displaySuccess(message) {
  console.log(colorize(`✓ ${message}`, 'green'));
}

/**
 * Display error message
 */
function displayError(message) {
  console.log(colorize(`✗ ${message}`, 'red'));
}

/**
 * Display warning message
 */
function displayWarning(message) {
  console.log(colorize(`⚠ ${message}`, 'yellow'));
}

/**
 * Display info message
 */
function displayInfo(message) {
  console.log(colorize(`ℹ ${message}`, 'blue'));
}

/**
 * Show help information
 */
function showHelp() {
  displayHeader('SEO Internal Link Tool - Help');
  console.log(colorize('Usage:', 'white'));
  console.log('  node seo-internal-link-tool.js <command> [options]');
  console.log('');
  console.log(colorize('Commands:', 'white'));
  console.log('  sitemap              Generate sitemap from React pages');
  console.log('  analyze             Analyze internal links');
  console.log('  optimize            Optimize internal links');
  console.log('  report              Generate comprehensive SEO report');
  console.log('  json-ld             Generate JSON-LD structured data');
  console.log('  interactive         Start interactive mode');
  console.log('');
  console.log(colorize('Options:', 'white'));
  console.log('  --output <file>     Output file path');
  console.log('  --format <format>   Output format (json, html, csv, markdown)');
  console.log('  --verbose           Enable verbose output');
  console.log('  --help, -h          Show help information');
  console.log('');
  console.log(colorize('Examples:', 'white'));
  console.log('  node seo-internal-link-tool.js sitemap');
  console.log('  node seo-internal-link-tool.js analyze --output report.json');
  console.log('  node seo-internal-link-tool.js interactive');
}

/**
 * Read file content with error handling
 */
function readFileContent(filePath) {
  try {
    return fs.readFileSync(filePath, 'utf8');
  } catch (error) {
    return '';
  }
}

/**
 * Extract content from page file
 */
function extractPageContent(page) {
  return readFileContent(page.filePath);
}

/**
 * Generate JSON-LD structured data for a page
 */
function generatePageJsonLD(page, content, linkConfig = defaultLinkConfig) {
  const businessConfig = {
    name: linkConfig.businessName,
    websiteUrl: linkConfig.websiteUrl,
    description: extractPageDescription(content) || `${linkConfig.businessName} - ${page.title}`
  };

  const jsonLD = {
    '@context': 'https://schema.org',
    '@type': getSchemaTypeForRoute(page.route),
    name: page.title,
    description: businessConfig.description,
    url: `${businessConfig.websiteUrl}${page.url}`,
    datePublished: page.lastModified.toISOString(),
    dateModified: page.lastModified.toISOString(),
    publisher: {
      '@type': 'Organization',
      name: businessConfig.name,
      url: businessConfig.websiteUrl,
    }
  };

  // Add route-specific structured data
  if (page.route === '') {
    jsonLD['@type'] = 'WebSite';
    jsonLD.about = {
      '@type': 'LocalBusiness',
      name: businessConfig.name,
      description: businessConfig.description,
      url: businessConfig.websiteUrl,
    };
  } else if (page.route.includes('service') || page.route.includes('repair')) {
    jsonLD['@type'] = 'Service';
    jsonLD.serviceType = page.title;
    jsonLD.provider = {
      '@type': 'LocalBusiness',
      name: businessConfig.name,
      url: businessConfig.websiteUrl,
    };
  } else if (page.route.includes('contact-us')) {
    jsonLD['@type'] = 'ContactPage';
  } else if (page.route.includes('about')) {
    jsonLD['@type'] = 'AboutPage';
  }

  return jsonLD;
}

/**
 * Extract page description from content
 */
function extractPageDescription(content) {
  const descMatch = content.match(/description:\s*['"`]([^'"`]+)['"`]/);
  return descMatch ? descMatch[1] : null;
}

/**
 * Get schema type based on route
 */
function getSchemaTypeForRoute(route) {
  if (route === '') return 'WebSite';
  if (route.includes('service') || route.includes('repair')) return 'Service';
  if (route.includes('contact-us')) return 'ContactPage';
  if (route.includes('about')) return 'AboutPage';
  if (route.includes('product') || route.includes('vending')) return 'Product';
  return 'WebPage';
}

/**
 * Generate sitemap from React pages
 */
async function runSitemapGeneration(options) {
  displayHeader('Generating Sitemap from React Pages');
  
  try {
    // Discover pages
    displayInfo('Discovering React pages...');
    const pages = discoverPages(APP_DIR);
    displaySuccess(`Found ${pages.length} pages`);

    // Generate sitemap XML
    displayInfo('Generating sitemap XML...');
    const sitemapXml = generateSitemapXml(pages);

    // Output results
    if (options.output) {
      fs.writeFileSync(options.output, sitemapXml);
      displaySuccess(`Sitemap saved to: ${options.output}`);
    } else {
      console.log(colorize('\nGenerated Sitemap:', 'white'));
      console.log(sitemapXml);
    }

    // Also save to conventional location
    const sitemapPath = path.join(PROJECT_ROOT, 'out', 'sitemap.xml');
    fs.writeFileSync(sitemapPath, sitemapXml);
    displaySuccess(`Default sitemap location: ${sitemapPath}`);

  } catch (error) {
    displayError(`Failed to generate sitemap: ${error.message}`);
    throw error;
  }
}

/**
 * Analyze internal links
 */
async function runLinkAnalysis(options) {
  displayHeader('Analyzing Internal Links');

  try {
    // Discover pages
    displayInfo('Discovering React pages...');
    const pages = discoverPages(APP_DIR);
    displaySuccess(`Found ${pages.length} pages`);

    // Extract content from each page
    displayInfo('Extracting page content...');
    const contentByRoute = {};
    for (const page of pages) {
      contentByRoute[page.route] = extractPageContent(page);
    }

    // Analyze internal links
    displayInfo('Analyzing internal links...');
    const analysis = analyzeInternalLinks(pages, contentByRoute);

    // Display results
    displayLinkAnalysisResults(analysis, options);

    // Save results if output file specified
    if (options.output) {
      saveAnalysisResults(analysis, options.output, options.format);
      displaySuccess(`Analysis saved to: ${options.output}`);
    }

  } catch (error) {
    displayError(`Failed to analyze links: ${error.message}`);
    throw error;
  }
}

/**
 * Display link analysis results
 */
function displayLinkAnalysisResults(analysis, options) {
  console.log(colorize(`\n📊 Link Analysis Summary`, 'white'));
  console.log(colorize(`Total Pages: ${analysis.totalPages}`, 'cyan'));
  console.log(colorize(`Internal Links: ${analysis.internalLinks}`, 'cyan'));
  console.log(colorize(`Average Link Density: ${analysis.averageLinkDensity.toFixed(2)} links per page`, 'cyan'));

  if (analysis.orphanedPages.length > 0) {
    displayWarning(`Orphaned Pages: ${analysis.orphanedPages.length}`);
    analysis.orphanedPages.forEach(page => {
      console.log(colorize(`  - ${page}`, 'yellow'));
    });
  } else {
    displaySuccess('No orphaned pages found');
  }

  if (analysis.brokenLinks.length > 0) {
    displayError(`Broken Links: ${analysis.brokenLinks.length}`);
    analysis.brokenLinks.forEach(link => {
      console.log(colorize(`  - ${link}`, 'red'));
    });
  } else {
    displaySuccess('No broken links found');
  }

  // Page types breakdown
  console.log(colorize(`\n📋 Page Types:`, 'white'));
  for (const [type, count] of Object.entries(analysis.pageTypes)) {
    console.log(colorize(`  ${type}: ${count} pages`, 'blue'));
  }

  // Pages with issues
  if (analysis.pagesWithIssues.length > 0) {
    displayWarning(`Pages with Issues: ${analysis.pagesWithIssues.length}`);
    analysis.pagesWithIssues.forEach(page => {
      console.log(colorize(`  - ${page.url}:`, 'yellow'));
      page.issues.forEach(issue => {
        console.log(colorize(`    * ${issue}`, 'yellow'));
      });
    });
  }
}

/**
 * Save analysis results
 */
function saveAnalysisResults(results, outputPath, format) {
  const output = {
    timestamp: new Date().toISOString(),
    summary: {
      totalPages: results.totalPages,
      internalLinks: results.internalLinks,
      orphanedPages: results.orphanedPages.length,
      brokenLinks: results.brokenLinks.length,
      averageLinkDensity: results.averageLinkDensity
    },
    details: results
  };

  let content;
  switch (format) {
    case 'json':
      content = JSON.stringify(output, null, 2);
      break;
    case 'csv':
      content = convertToCSV(results);
      break;
    case 'markdown':
      content = convertToMarkdown(results);
      break;
    case 'html':
      content = convertToHTML(results);
      break;
    default:
      content = JSON.stringify(output, null, 2);
  }

  fs.writeFileSync(outputPath, content);
}

/**
 * Convert analysis results to CSV
 */
function convertToCSV(results) {
  let csv = 'Page,Route,Links,Issues\n';
  
  // Add pages with issues
  results.pagesWithIssues.forEach(page => {
    csv += `"${page.url}","${page.route}","0","${page.issues.join('; ')}"\n`;
  });

  // Add pages without issues
  const allPages = Array.from(new Set([
    ...results.orphanedPages,
    ...results.brokenLinks.map(link => link.split(' -> ')[0])
  ]));

  allPages.forEach(page => {
    csv += `"${page}","${page}","0","No issues"\n`;
  });

  return csv;
}

/**
 * Convert analysis results to Markdown
 */
function convertToMarkdown(results) {
  let md = '# SEO Link Analysis Report\n\n';
  md += `*Generated: ${new Date().toISOString()}*\n\n`;
  
  md += '## Summary\n\n';
  md += `- Total Pages: ${results.totalPages}\n`;
  md += `- Internal Links: ${results.internalLinks}\n`;
  md += `- Orphaned Pages: ${results.orphanedPages.length}\n`;
  md += `- Broken Links: ${results.brokenLinks.length}\n`;
  md += `- Average Link Density: ${results.averageLinkDensity.toFixed(2)}\n\n`;

  md += '## Page Types\n\n';
  for (const [type, count] of Object.entries(results.pageTypes)) {
    md += `- ${type}: ${count} pages\n`;
  }
  md += '\n';

  if (results.orphanedPages.length > 0) {
    md += '## Orphaned Pages\n\n';
    results.orphanedPages.forEach(page => {
      md += `- ${page}\n`;
    });
    md += '\n';
  }

  if (results.brokenLinks.length > 0) {
    md += '## Broken Links\n\n';
    results.brokenLinks.forEach(link => {
      md += `- ${link}\n`;
    });
    md += '\n';
  }

  if (results.pagesWithIssues.length > 0) {
    md += '## Pages with Issues\n\n';
    results.pagesWithIssues.forEach(page => {
      md += `### ${page.url}\n`;
      page.issues.forEach(issue => {
        md += `- ${issue}\n`;
      });
      md += '\n';
    });
  }

  return md;
}

/**
 * Convert analysis results to HTML
 */
function convertToHTML(results) {
  return `
<!DOCTYPE html>
<html>
<head>
    <title>SEO Link Analysis Report</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1, h2 { color: #333; }
        .summary { background: #f5f5f5; padding: 15px; border-radius: 5px; }
        .issue { color: #d32f2f; }
        .warning { color: #f57c00; }
        .success { color: #388e3c; }
    </style>
</head>
<body>
    <h1>SEO Link Analysis Report</h1>
    <p>Generated: ${new Date().toISOString()}</p>
    
    <div class="summary">
        <h2>Summary</h2>
        <p><strong>Total Pages:</strong> ${results.totalPages}</p>
        <p><strong>Internal Links:</strong> ${results.internalLinks}</p>
        <p><strong>Orphaned Pages:</strong> ${results.orphanedPages.length}</p>
        <p><strong>Broken Links:</strong> ${results.brokenLinks.length}</p>
        <p><strong>Average Link Density:</strong> ${results.averageLinkDensity.toFixed(2)}</p>
    </div>
    
    ${results.orphanedPages.length > 0 ? `
    <div>
        <h2 class="warning">Orphaned Pages</h2>
        <ul>
            ${results.orphanedPages.map(page => `<li class="warning">${page}</li>`).join('')}
        </ul>
    </div>` : ''}
    
    ${results.brokenLinks.length > 0 ? `
    <div>
        <h2 class="issue">Broken Links</h2>
        <ul>
            ${results.brokenLinks.map(link => `<li class="issue">${link}</li>`).join('')}
        </ul>
    </div>` : ''}
</body>
</html>`;
}

/**
 * Optimize internal links
 */
async function runLinkOptimization(options) {
  displayHeader('Optimizing Internal Links');

  try {
    // Load configuration
    displayInfo('Loading configuration...');
    const linkConfig = defaultLinkConfig;

    // Discover pages
    displayInfo('Discovering React pages...');
    const pages = discoverPages(APP_DIR);
    displaySuccess(`Found ${pages.length} pages`);

    // Extract content from each page
    displayInfo('Extracting page content...');
    const contentByRoute = {};
    for (const page of pages) {
      contentByRoute[page.route] = extractPageContent(page);
    }

    // Optimize links page by page
    let totalLinksAdded = 0;
    const optimizationResults = [];

    for (const page of pages) {
      if (isExcludedRoute(page.route, linkConfig)) {
        continue;
      }

      const maxLinks = getMaxLinksForPage(page.route, linkConfig);
      const minWordsBetween = getMinWordsBetweenLinks(page.route, linkConfig);
      const content = contentByRoute[page.route];

      // Calculate SEO score
      const internalLinks = extractInternalLinksFromContent(content);
      const seoScore = calculatePageScore(page.route, content, internalLinks, linkConfig);

      // Find keywords to link
      const keywordsToLink = findKeywordsInContent(content, linkConfig);
      const linksAdded = addOptimalLinks(content, keywordsToLink, pages, linkConfig);

      if (linksAdded > 0) {
        totalLinksAdded += linksAdded;
        optimizationResults.push({
          page: page.route,
          linksAdded,
          seoScore: seoScore,
          keywordsFound: keywordsToLink.length
        });
        displaySuccess(`${page.route}: Added ${linksAdded} link(s)`);
      }
    }

    displaySuccess(`Total links added: ${totalLinksAdded}`);
    
    // Save results
    if (options.output) {
      const results = {
        timestamp: new Date().toISOString(),
        totalLinksAdded,
        pagesOptimized: optimizationResults.length,
        details: optimizationResults
      };

      fs.writeFileSync(options.output, JSON.stringify(results, null, 2));
      displaySuccess(`Optimization results saved to: ${options.output}`);
    }

  } catch (error) {
    displayError(`Failed to optimize links: ${error.message}`);
    throw error;
  }
}

/**
 * Extract internal links from content
 */
function extractInternalLinksFromContent(content) {
  const links = [];
  const linkRegex = /<a[^>]+href="([^"]+)"[^>]*>([^<]+)<\/a>/g;
  
  let match;
  while ((match = linkRegex.exec(content)) !== null) {
    if (isInternalLink(match[1])) {
      links.push({
        to: match[1],
        text: match[2].trim()
      });
    }
  }
  
  return links;
}

/**
 * Check if link is internal
 */
function isInternalLink(href) {
  return !href.startsWith('http') && !href.startsWith('mailto:') && !href.startsWith('tel:');
}

/**
 * Add optimal links to content
 */
function addOptimalLinks(content, keywords, pages, config) {
  let linksAdded = 0;
  const linkPositions = [];

  for (const keyword of keywords) {
    if (linksAdded >= config.linkDensity.maxLinksPerPage) {
      break;
    }

    // Find keyword in content
    const keywordRegex = new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'gi');
    let match;
    
    while ((match = keywordRegex.exec(content)) !== null) {
      if (linksAdded >= config.linkDensity.maxLinksPerPage) {
        break;
      }

      // Check distance from other links
      const tooClose = linkPositions.some(pos => 
        Math.abs(pos - match.index) < config.linkDensity.minWordsBetweenLinks * 5
      );

      if (tooClose) continue;

      // Add link
      const targetPage = pages.find(p => 
        p.title.toLowerCase().includes(keyword.toLowerCase()) ||
        p.route.toLowerCase().includes(keyword.toLowerCase())
      );

      if (targetPage && !isExcludedRoute(targetPage.route, config)) {
        const anchorTexts = getAnchorTexts(targetPage.route, config);
        const anchorText = anchorTexts[0] || keyword;
        
        // Insert link (simplified - in real implementation, would need to properly handle HTML)
        content = insertLink(content, match.index, match.index + match[0].length, targetPage.url, anchorText);
        
        linkPositions.push(match.index);
        linksAdded++;
        break; // Only link first occurrence per keyword
      }
    }
  }

  return linksAdded;
}

/**
 * Insert link into content
 */
function insertLink(content, startIndex, endIndex, url, anchorText) {
  const before = content.substring(0, startIndex);
  const after = content.substring(endIndex);
  const link = `<a href="${url}">${anchorText}</a>`;
  return before + link + after;
}

/**
 * Generate SEO report
 */
async function runSEOReport(options) {
  displayHeader('Generating SEO Report');

  try {
    // Discover pages
    displayInfo('Discovering React pages...');
    const pages = discoverPages(APP_DIR);
    displaySuccess(`Found ${pages.length} pages`);

    // Extract content from each page
    displayInfo('Extracting page content...');
    const contentByRoute = {};
    const pageScores = [];

    for (const page of pages) {
      contentByRoute[page.route] = extractPageContent(page);
      
      // Calculate SEO score
      const internalLinks = extractInternalLinksFromContent(contentByRoute[page.route]);
      const seoScore = calculatePageScore(page.route, contentByRoute[page.route], internalLinks);
      
      pageScores.push({
        page: page.route,
        url: page.url,
        title: page.title,
        priority: page.priority,
        score: seoScore,
        internalLinks: internalLinks.length,
        lastModified: page.lastModified.toISOString()
      });
    }

    // Sort pages by score
    pageScores.sort((a, b) => b.score - a.score);

    // Display report
    displaySEOResults(pageScores, options);

    // Save results
    if (options.output) {
      const report = {
        timestamp: new Date().toISOString(),
        totalPages: pages.length,
        averageScore: pageScores.reduce((sum, p) => sum + p.score, 0) / pageScores.length,
        pages: pageScores
      };

      let content;
      switch (options.format) {
        case 'json':
          content = JSON.stringify(report, null, 2);
          break;
        case 'markdown':
          content = generateMarkdownReport(report);
          break;
        case 'html':
          content = generateHTMLReport(report);
          break;
        default:
          content = JSON.stringify(report, null, 2);
      }

      fs.writeFileSync(options.output, content);
      displaySuccess(`Report saved to: ${options.output}`);
    }

  } catch (error) {
    displayError(`Failed to generate report: ${error.message}`);
    throw error;
  }
}

/**
 * Display SEO results
 */
function displaySEOResults(pageScores, options) {
  console.log(colorize(`\n📊 SEO Analysis Summary`, 'white'));
  console.log(colorize(`Total Pages Analyzed: ${pageScores.length}`, 'cyan'));
  
  const averageScore = pageScores.reduce((sum, p) => sum + p.score, 0) / pageScores.length;
  console.log(colorize(`Average SEO Score: ${averageScore.toFixed(1)}/100`, 'cyan'));

  // Top performing pages
  console.log(colorize(`\n🏆 Top Performing Pages:`, 'white'));
  const topPages = pageScores.slice(0, 5);
  topPages.forEach((page, index) => {
    const scoreColor = page.score >= 80 ? 'green' : page.score >= 60 ? 'yellow' : 'red';
    console.log(colorize(`${index + 1}. ${page.title} (${page.route}) - Score: ${page.score.toFixed(1)}`, scoreColor));
  });

  // Pages needing improvement
  const poorPages = pageScores.filter(p => p.score < 60);
  if (poorPages.length > 0) {
    console.log(colorize(`\n⚠ Pages Needing Improvement:`, 'yellow'));
    poorPages.slice(0, 3).forEach(page => {
      console.log(colorize(`- ${page.title} (${page.route}) - Score: ${page.score.toFixed(1)}`, 'red'));
    });
  }
}

/**
 * Generate markdown report
 */
function generateMarkdownReport(report) {
  let md = '# SEO Report\n\n';
  md += `*Generated: ${report.timestamp}*\n\n`;
  
  md += '## Summary\n\n';
  md += `- Total Pages: ${report.totalPages}\n`;
  md += `- Average Score: ${report.averageScore.toFixed(1)}/100\n\n`;

  md += '## Page Scores\n\n';
  report.pages.forEach((page, index) => {
    const status = page.score >= 80 ? 'Excellent' : page.score >= 60 ? 'Good' : 'Needs Improvement';
    const statusColor = page.score >= 80 ? 'green' : page.score >= 60 ? 'yellow' : 'red';
    md += `${index + 1}. **${page.title}** (${page.route})\n`;
    md += `   - Score: ${page.score.toFixed(1)}/100 (${status})\n`;
    md += `   - Internal Links: ${page.internalLinks}\n`;
    md += `   - Priority: ${page.priority}\n`;
    md += `   - Last Modified: ${new Date(page.lastModified).toLocaleDateString()}\n\n`;
  });

  return md;
}

/**
 * Generate HTML report
 */
function generateHTMLReport(report) {
  return `
<!DOCTYPE html>
<html>
<head>
    <title>SEO Report</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1, h2 { color: #333; }
        .page { margin: 20px 0; padding: 15px; border: 1px solid #ddd; border-radius: 5px; }
        .score { font-size: 24px; font-weight: bold; }
        .excellent { color: #388e3c; }
        .good { color: #f57c00; }
        .poor { color: #d32f2f; }
    </style>
</head>
<body>
    <h1>SEO Report</h1>
    <p>Generated: ${report.timestamp}</p>
    
    <h2>Summary</h2>
    <p><strong>Total Pages:</strong> ${report.totalPages}</p>
    <p><strong>Average Score:</strong> ${report.averageScore.toFixed(1)}/100</p>
    
    <h2>Page Scores</h2>
    ${report.pages.map((page, index) => {
      const status = page.score >= 80 ? 'excellent' : page.score >= 60 ? 'good' : 'poor';
      return `
        <div class="page">
            <h3>${index + 1}. ${page.title} (${page.route})</h3>
            <p class="score ${status}">${page.score.toFixed(1)}/100</p>
            <p>Internal Links: ${page.internalLinks}</p>
            <p>Priority: ${page.priority}</p>
            <p>Last Modified: ${new Date(page.lastModified).toLocaleDateString()}</p>
        </div>`;
    }).join('')}
</body>
</html>`;
}

/**
 * Generate JSON-LD structured data
 */
async function runJsonLDGeneration(options) {
  displayHeader('Generating JSON-LD Structured Data');

  try {
    // Discover pages
    displayInfo('Discovering React pages...');
    const pages = discoverPages(APP_DIR);
    displaySuccess(`Found ${pages.length} pages`);

    // Generate JSON-LD for each page
    const jsonLDData = {};
    
    for (const page of pages) {
      const content = extractPageContent(page);
      const jsonLD = generatePageJsonLD(page, content);
      jsonLDData[page.route] = jsonLD;
      
      if (options.verbose) {
        displaySuccess(`Generated JSON-LD for: ${page.route}`);
      }
    }

    // Output results
    if (options.output) {
      fs.writeFileSync(options.output, JSON.stringify(jsonLDData, null, 2));
      displaySuccess(`JSON-LD data saved to: ${options.output}`);
    } else {
      console.log(colorize('\nGenerated JSON-LD Structured Data:', 'white'));
      console.log(JSON.stringify(jsonLDData, null, 2));
    }

    // Also save individual files (skip dynamic routes to avoid filesystem issues)
    const outputDir = path.join(PROJECT_ROOT, 'public', 'json-ld');
    if (!fs.existsSync(outputDir)) {
      fs.mkdirSync(outputDir, { recursive: true });
    }

    for (const [route, jsonLD] of Object.entries(jsonLDData)) {
      // Skip dynamic routes
      if (route.includes(':') || route.includes('...')) {
        continue;
      }
      
      let filename;
      if (route === '') {
        filename = 'home.jsonld';
      } else {
        filename = `${route.replace(/\//g, '_')}.jsonld`;
      }
      
      const filepath = path.join(outputDir, filename);
      fs.writeFileSync(filepath, JSON.stringify(jsonLD, null, 2));
    }

    displaySuccess(`Individual JSON-LD files saved to: ${outputDir}`);

  } catch (error) {
    displayError(`Failed to generate JSON-LD: ${error.message}`);
    throw error;
  }
}

/**
 * Start interactive mode
 */
async function startInteractiveMode(options) {
  displayHeader('SEO Internal Link Tool - Interactive Mode');
  displayInfo('Type "help" for available commands or "exit" to quit');

  // Import readline only when needed
  try {
    readline = await import('readline');
  } catch (error) {
    displayError('Interactive mode requires Node.js readline module');
    process.exit(1);
  }

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  const question = (query) => new Promise(resolve => rl.question(query, resolve));

  while (true) {
    const command = await question('\nseo-tool> ');
    
    if (command.toLowerCase() === 'exit' || command.toLowerCase() === 'quit') {
      break;
    }
    
    if (command.toLowerCase() === 'help') {
      showHelp();
      continue;
    }

    const args = command.split(' ');
    const cmd = args[0];
    const cmdOptions = {
      output: null,
      format: 'console',
      verbose: false
    };

    // Parse options
    for (let i = 1; i < args.length; i++) {
      const arg = args[i];
      
      if (arg === '--output' && i + 1 < args.length) {
        cmdOptions.output = args[i + 1];
        i++;
      } else if (arg === '--format' && i + 1 < args.length) {
        cmdOptions.format = args[i + 1];
        i++;
      } else if (arg === '--verbose' || arg === '-v') {
        cmdOptions.verbose = true;
      }
    }

    try {
      switch (cmd) {
        case 'sitemap':
          await runSitemapGeneration(cmdOptions);
          break;
        case 'analyze':
          await runLinkAnalysis(cmdOptions);
          break;
        case 'optimize':
          await runLinkOptimization(cmdOptions);
          break;
        case 'report':
          await runSEOReport(cmdOptions);
          break;
        case 'json-ld':
          await runJsonLDGeneration(cmdOptions);
          break;
        default:
          displayError(`Unknown command: ${cmd}`);
          showHelp();
      }
    } catch (error) {
      displayError(`Error: ${error.message}`);
    }
  }

  rl.close();
  displaySuccess('Goodbye!');
}

/**
 * Main CLI dispatcher
 */
function main() {
  const args = process.argv.slice(2);
  
  if (args.length === 0 || args.includes('--help') || args.includes('-h')) {
    showHelp();
    return;
  }

  const command = args[0];
  const options = {
    output: null,
    format: 'console',
    verbose: false
  };

  // Parse options
  for (let i = 1; i < args.length; i++) {
    const arg = args[i];
    
    if (arg === '--output' && i + 1 < args.length) {
      options.output = args[i + 1];
      i++;
    } else if (arg === '--format' && i + 1 < args.length) {
      options.format = args[i + 1];
      i++;
    } else if (arg === '--verbose' || arg === '-v') {
      options.verbose = true;
    }
  }

  // Check if we need to import readline for interactive mode
  if (command === 'interactive') {
    try {
      readline = require('readline');
    } catch (error) {
      displayError('Interactive mode requires Node.js readline module');
      process.exit(1);
    }
  }

  switch (command) {
    case 'sitemap':
      executeCommand(runSitemapGeneration, options);
      break;
    case 'analyze':
      executeCommand(runLinkAnalysis, options);
      break;
    case 'optimize':
      executeCommand(runLinkOptimization, options);
      break;
    case 'report':
      executeCommand(runSEOReport, options);
      break;
    case 'json-ld':
      executeCommand(runJsonLDGeneration, options);
      break;
    case 'interactive':
      startInteractiveMode(options);
      break;
    default:
      displayError(`Unknown command: ${command}`);
      console.log('');
      showHelp();
      process.exit(1);
  }
}

/**
 * Execute function and handle errors
 */
async function executeCommand(commandFn, options) {
  try {
    await commandFn(options);
  } catch (error) {
    displayError(`Error: ${error.message}`);
    if (options.verbose) {
      console.error(error);
    }
    process.exit(1);
  }
}

// Export functions for external use
export { 
  main, 
  executeCommand, 
  displayHeader, 
  displaySuccess, 
  displayError, 
  displayWarning, 
  displayInfo,
  runSitemapGeneration,
  runLinkAnalysis,
  runLinkOptimization,
  runSEOReport,
  runJsonLDGeneration
};

// Run if called directly
if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('seo-internal-link-tool.js')) {
  main();
}