import { OutputPort, OutputOptions } from '../../domain/ports/OutputPort';
import { ReviewReport, SecurityIssue, TestSuggestion, DocSuggestion } from '../../domain/entities';
import { marked } from 'marked';
import * as fs from 'fs/promises';
import * as path from 'path';
import chalk from 'chalk';
import ora from 'ora';

export class OutputAdapter implements OutputPort {
  private spinner: any | null = null;

  async displayReviewReport(report: ReviewReport, options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console' } = options;
    
    switch (format) {
      case 'console':
        await this.displayReviewReportConsole(report, options);
        break;
      case 'markdown':
        await this.displayReviewReportMarkdown(report, options);
        break;
      case 'json':
        await this.displayReviewReportJSON(report, options);
        break;
      case 'html':
        await this.displayReviewReportHTML(report, options);
        break;
      case 'file':
        await this.exportToFile(report, options.outputPath || 'review-report.json', 'json');
        break;
      default:
        throw new Error(`Unsupported output format: ${format}`);
    }
  }

  async displaySecurityIssues(issues: SecurityIssue[], options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console' } = options;
    
    switch (format) {
      case 'console':
        await this.displaySecurityIssuesConsole(issues, options);
        break;
      case 'markdown':
        await this.displaySecurityIssuesMarkdown(issues, options);
        break;
      case 'json':
        await this.displaySecurityIssuesJSON(issues, options);
        break;
      case 'html':
        await this.displaySecurityIssuesHTML(issues, options);
        break;
      case 'file':
        await this.exportToFile(issues, options.outputPath || 'security-issues.json', 'json');
        break;
      default:
        throw new Error(`Unsupported output format: ${format}`);
    }
  }

  async displayTestSuggestions(suggestions: TestSuggestion[], options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console' } = options;
    
    switch (format) {
      case 'console':
        await this.displayTestSuggestionsConsole(suggestions, options);
        break;
      case 'markdown':
        await this.displayTestSuggestionsMarkdown(suggestions, options);
        break;
      case 'json':
        await this.displayTestSuggestionsJSON(suggestions, options);
        break;
      case 'html':
        await this.displayTestSuggestionsHTML(suggestions, options);
        break;
      case 'file':
        await this.exportToFile(suggestions, options.outputPath || 'test-suggestions.json', 'json');
        break;
      default:
        throw new Error(`Unsupported output format: ${format}`);
    }
  }

  async displayDocSuggestions(suggestions: DocSuggestion[], options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console' } = options;
    
    switch (format) {
      case 'console':
        await this.displayDocSuggestionsConsole(suggestions, options);
        break;
      case 'markdown':
        await this.displayDocSuggestionsMarkdown(suggestions, options);
        break;
      case 'json':
        await this.displayDocSuggestionsJSON(suggestions, options);
        break;
      case 'html':
        await this.displayDocSuggestionsHTML(suggestions, options);
        break;
      case 'file':
        await this.exportToFile(suggestions, options.outputPath || 'doc-suggestions.json', 'json');
        break;
      default:
        throw new Error(`Unsupported output format: ${format}`);
    }
  }

  async displayMessage(message: string, options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console', colorize = true } = options;
    
    if (format === 'console') {
      if (colorize) {
        console.log(chalk.blue(message));
      } else {
        console.log(message);
      }
    } else if (format === 'file' && options.outputPath) {
      await this.exportToFile(message, options.outputPath, 'markdown');
    } else {
      console.log(message);
    }
  }

  async displayError(error: string, options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console', colorize = true } = options;
    
    if (format === 'console') {
      if (colorize) {
        console.error(chalk.red(error));
      } else {
        console.error(error);
      }
    } else {
      console.error(error);
    }
  }

  async displayWarning(warning: string, options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console', colorize = true } = options;
    
    if (format === 'console') {
      if (colorize) {
        console.warn(chalk.yellow(warning));
      } else {
        console.warn(warning);
      }
    } else {
      console.warn(warning);
    }
  }

  async displaySuccess(message: string, options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console', colorize = true } = options;
    
    if (format === 'console') {
      if (colorize) {
        console.log(chalk.green(message));
      } else {
        console.log(message);
      }
    } else {
      console.log(message);
    }
  }

  displayProgress(message: string): void {
    this.spinner = ora(message).start();
  }

  clearProgress(): void {
    if (this.spinner) {
      this.spinner.stop();
      this.spinner = null;
    }
  }

  async displayTable(data: Record<string, unknown>[], options: OutputOptions = { format: 'console' }): Promise<void> {
    const { format = 'console' } = options;
    
    if (format === 'console') {
      console.table(data);
    } else if (format === 'markdown') {
      const markdown = this.convertTableToMarkdown(data);
      await this.displayMessage(markdown, options);
    } else {
      await this.exportToFile(data, options.outputPath || 'table.json', 'json');
    }
  }

  async exportToFile(data: unknown, filePath: string, format: 'json' | 'markdown' | 'html'): Promise<void> {
    let content: string;
    
    switch (format) {
      case 'json':
        content = JSON.stringify(data, null, 2);
        break;
      case 'markdown':
        content = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
        break;
      case 'html':
        content = this.convertToHTML(data);
        break;
      default:
        throw new Error(`Unsupported export format: ${format}`);
    }

    await fs.writeFile(filePath, content, 'utf-8');
    console.log(`Exported to: ${filePath}`);
  }

  private async displayReviewReportConsole(report: ReviewReport, options: OutputOptions): Promise<void> {
    const { colorize = true } = options;
    
    console.log('\n' + (colorize ? chalk.bold.blue('📋 Review Report') : 'Review Report'));
    console.log('=' .repeat(50));
    
    console.log(`Summary: ${report.summary}`);
    console.log(`Overall Score: ${this.getScoreColor(report.overallScore, colorize)}`);
    console.log(`Timestamp: ${report.timestamp.toISOString()}`);
    
    console.log('\n' + (colorize ? chalk.bold('📊 Metrics') : 'Metrics'));
    console.log('-'.repeat(20));
    console.log(`Total Comments: ${report.metrics.totalComments}`);
    console.log(`Errors: ${report.metrics.errorCount}`);
    console.log(`Warnings: ${report.metrics.warningCount}`);
    console.log(`Info: ${report.metrics.infoCount}`);
    console.log(`Suggestions: ${report.metrics.suggestionCount}`);
    console.log(`Files Reviewed: ${report.metrics.filesReviewed}`);
    console.log(`Lines Added: ${report.metrics.linesAdded}`);
    console.log(`Lines Removed: ${report.metrics.linesRemoved}`);
    
    if (report.comments.length > 0) {
      console.log('\n' + (colorize ? chalk.bold('💬 Comments') : 'Comments'));
      console.log('-'.repeat(20));
      
      for (const comment of report.comments) {
        console.log(`\n${colorize ? chalk.bold.cyan(comment.filePath) : comment.filePath}${comment.lineNumber ? `:${colorize ? chalk.gray(comment.lineNumber.toString()) : comment.lineNumber}` : ''}`);
        
        // Parse JSON response if it's a JSON string
        if (typeof comment.message === 'string' && comment.message.trim().startsWith('```json')) {
          try {
            const jsonMatch = comment.message.match(/```json\n([\s\S]*?)\n```/);
            if (jsonMatch) {
              const jsonData = JSON.parse(jsonMatch[1] || '{}');
              if (Array.isArray(jsonData)) {
                for (const item of jsonData) {
                  console.log(`  ${this.getSeverityColor((item.severity || comment.severity) as string, colorize)} [${colorize ? chalk.magenta(item.category || comment.category) : (item.category || comment.category)}] ${item.message || comment.message}`);
                  if (item.suggestion) {
                    console.log(`    ${colorize ? chalk.green('💡 Suggestion:') : '💡 Suggestion:'} ${item.suggestion}`);
                  }
                }
              } else {
                console.log(`  ${this.getSeverityColor((jsonData.severity || comment.severity) as string, colorize)} [${colorize ? chalk.magenta(jsonData.category || comment.category) : (jsonData.category || comment.category)}] ${jsonData.message || comment.message}`);
                if (jsonData.suggestion) {
                  console.log(`    ${colorize ? chalk.green('💡 Suggestion:') : '💡 Suggestion:'} ${jsonData.suggestion}`);
                }
              }
            } else {
              // Fallback to original message if JSON parsing fails
              console.log(`  ${this.getSeverityColor(comment.severity, colorize)} [${colorize ? chalk.magenta(comment.category) : comment.category}] ${comment.message}`);
            }
          } catch (error) {
            // Fallback to original message if JSON parsing fails
            console.log(`  ${this.getSeverityColor(comment.severity, colorize)} [${colorize ? chalk.magenta(comment.category) : comment.category}] ${comment.message}`);
          }
        } else {
          // Regular message display
          console.log(`  ${this.getSeverityColor(comment.severity, colorize)} [${colorize ? chalk.magenta(comment.category) : comment.category}] ${comment.message}`);
        }
        
        if (comment.suggestion && typeof comment.message !== 'string') {
          console.log(`  ${colorize ? chalk.green('💡 Suggestion:') : '💡 Suggestion:'} ${comment.suggestion}`);
        }
      }
    }
    
    if (report.recommendations.length > 0) {
      console.log('\n' + (colorize ? chalk.bold('🎯 Recommendations') : 'Recommendations'));
      console.log('-'.repeat(20));
      for (const rec of report.recommendations) {
        console.log(`• ${rec}`);
      }
    }
  }

  private async displaySecurityIssuesConsole(issues: SecurityIssue[], options: OutputOptions): Promise<void> {
    const { colorize = true } = options;
    
    console.log('\n' + (colorize ? chalk.bold.red('🔒 Security Issues') : 'Security Issues'));
    console.log('=' .repeat(50));
    
    if (issues.length === 0) {
      console.log(colorize ? chalk.green('✅ No security issues found!') : '✅ No security issues found!');
      return;
    }
    
    for (const issue of issues) {
      console.log(`\n${colorize ? chalk.bold.cyan(issue.filePath) : issue.filePath}${issue.lineNumber ? `:${colorize ? chalk.gray(issue.lineNumber.toString()) : issue.lineNumber}` : ''}`);
      
      // Parse JSON response if it's a JSON string
      if (typeof issue.description === 'string' && issue.description.trim().startsWith('```json')) {
        try {
          const jsonMatch = issue.description.match(/```json\n([\s\S]*?)\n```/);
          if (jsonMatch) {
            const jsonData = JSON.parse(jsonMatch[1] || '{}');
            if (Array.isArray(jsonData)) {
              for (const item of jsonData) {
                console.log(`  ${this.getSeverityColor((item.severity || issue.severity) as string, colorize)} [${colorize ? chalk.magenta(item.category || issue.category) : (item.category || issue.category)}] ${item.title || issue.title}`);
                console.log(`    ${colorize ? chalk.yellow('Description:') : 'Description:'} ${item.description || issue.description}`);
                console.log(`    ${colorize ? chalk.green('Remediation:') : 'Remediation:'} ${item.remediation || issue.remediation}`);
                
                if (item.references && item.references.length > 0) {
                  console.log(`    ${colorize ? chalk.blue('References:') : 'References:'}`);
                  for (const ref of item.references) {
                    console.log(`      • ${ref}`);
                  }
                }
              }
            } else {
              console.log(`  ${this.getSeverityColor((jsonData.severity || issue.severity) as string, colorize)} [${colorize ? chalk.magenta(jsonData.category || issue.category) : (jsonData.category || issue.category)}] ${jsonData.title || issue.title}`);
              console.log(`    ${colorize ? chalk.yellow('Description:') : 'Description:'} ${jsonData.description || issue.description}`);
              console.log(`    ${colorize ? chalk.green('Remediation:') : 'Remediation:'} ${jsonData.remediation || issue.remediation}`);
              
              if (jsonData.references && jsonData.references.length > 0) {
                console.log(`    ${colorize ? chalk.blue('References:') : 'References:'}`);
                for (const ref of jsonData.references) {
                  console.log(`      • ${ref}`);
                }
              }
            }
          } else {
            // Fallback to original description if JSON parsing fails
            console.log(`  ${this.getSeverityColor(issue.severity, colorize)} [${colorize ? chalk.magenta(issue.category) : issue.category}] ${issue.title}`);
            console.log(`    ${colorize ? chalk.yellow('Description:') : 'Description:'} ${issue.description}`);
            console.log(`    ${colorize ? chalk.green('Remediation:') : 'Remediation:'} ${issue.remediation}`);
          }
        } catch (error) {
          // Fallback to original description if JSON parsing fails
          console.log(`  ${this.getSeverityColor(issue.severity, colorize)} [${colorize ? chalk.magenta(issue.category) : issue.category}] ${issue.title}`);
          console.log(`    ${colorize ? chalk.yellow('Description:') : 'Description:'} ${issue.description}`);
          console.log(`    ${colorize ? chalk.green('Remediation:') : 'Remediation:'} ${issue.remediation}`);
        }
      } else {
        // Regular issue display
        console.log(`  ${this.getSeverityColor(issue.severity, colorize)} [${colorize ? chalk.magenta(issue.category) : issue.category}] ${issue.title}`);
        console.log(`    ${colorize ? chalk.yellow('Description:') : 'Description:'} ${issue.description}`);
        console.log(`    ${colorize ? chalk.green('Remediation:') : 'Remediation:'} ${issue.remediation}`);
      }
      
      if (issue.references && issue.references.length > 0 && typeof issue.description !== 'string') {
        console.log(`    ${colorize ? chalk.blue('References:') : 'References:'}`);
        for (const ref of issue.references) {
          console.log(`      • ${ref}`);
        }
      }
    }
  }

  private async displayTestSuggestionsConsole(suggestions: TestSuggestion[], options: OutputOptions): Promise<void> {
    const { colorize = true } = options;
    
    console.log('\n' + (colorize ? chalk.bold.green('🧪 Test Suggestions') : 'Test Suggestions'));
    console.log('=' .repeat(50));
    
    for (const suggestion of suggestions) {
      console.log(`\n${colorize ? chalk.bold.cyan(suggestion.description) : suggestion.description}`);
      console.log(`${colorize ? chalk.yellow('Framework:') : 'Framework:'} ${colorize ? chalk.cyan(suggestion.framework) : suggestion.framework}`);
      console.log(`${colorize ? chalk.yellow('Type:') : 'Type:'} ${colorize ? chalk.cyan(suggestion.testType) : suggestion.testType}`);
      if (suggestion.targetFunction) {
        console.log(`${colorize ? chalk.yellow('Target:') : 'Target:'} ${colorize ? chalk.cyan(suggestion.targetFunction) : suggestion.targetFunction}`);
      }
      
      // Parse JSON response if it's a JSON string
      if (typeof suggestion.testCode === 'string' && suggestion.testCode.trim().startsWith('```json')) {
        try {
          const jsonMatch = suggestion.testCode.match(/```json\n([\s\S]*?)\n```/);
          if (jsonMatch) {
            const jsonData = JSON.parse(jsonMatch[1] || '{}');
            
            console.log(`\n${colorize ? chalk.bold.green('Test Code:') : 'Test Code:'}`);
            
            // Display test code if present
            if (jsonData.testCode) {
              console.log(`${colorize ? chalk.gray('```') : '```'}${suggestion.framework}`);
              console.log(jsonData.testCode);
              console.log(`${colorize ? chalk.gray('```') : '```'}`);
            }
            
            // Display test cases if present
            if (jsonData.testCases && Array.isArray(jsonData.testCases) && jsonData.testCases.length > 0) {
              console.log(`\n${colorize ? chalk.bold.magenta('Test Cases:') : 'Test Cases:'}`);
              for (const testCase of jsonData.testCases) {
                console.log(`  ${colorize ? chalk.green('•') : '•'} ${colorize ? chalk.cyan(testCase.name || testCase.title) : (testCase.name || testCase.title)}: ${testCase.description || testCase.content}`);
              }
            }
            
            // Display description if present
            if (jsonData.description) {
              console.log(`\n${colorize ? chalk.bold.blue('Description:') : 'Description:'}`);
              console.log(`  ${jsonData.description}`);
            }
          } else {
            // Fallback to original test code if JSON parsing fails
            console.log(`\n${colorize ? chalk.bold.green('Test Code:') : 'Test Code:'}`);
            console.log(suggestion.testCode);
          }
        } catch (error) {
          // Fallback to original test code if JSON parsing fails
          console.log(`\n${colorize ? chalk.bold.green('Test Code:') : 'Test Code:'}`);
          console.log(suggestion.testCode);
        }
      } else {
        // Regular test code display
        console.log(`\n${colorize ? chalk.bold.green('Test Code:') : 'Test Code:'}`);
        console.log(suggestion.testCode);
      }
      
      if (suggestion.testCases.length > 0 && typeof suggestion.testCode !== 'string') {
        console.log(`\n${colorize ? chalk.bold.magenta('Test Cases:') : 'Test Cases:'}`);
        for (const testCase of suggestion.testCases) {
          console.log(`  ${colorize ? chalk.green('•') : '•'} ${testCase.name}: ${testCase.description}`);
        }
      }
    }
  }

  private async displayDocSuggestionsConsole(suggestions: DocSuggestion[], options: OutputOptions): Promise<void> {
    const { colorize = true } = options;
    
    console.log('\n' + (colorize ? chalk.bold.cyan('📚 Documentation Suggestions') : 'Documentation Suggestions'));
    console.log('=' .repeat(50));
    
    for (const suggestion of suggestions) {
      console.log(`\n${colorize ? chalk.bold.cyan(suggestion.title) : suggestion.title}`);
      console.log(`${colorize ? chalk.yellow('Type:') : 'Type:'} ${suggestion.type}`);
      console.log(`${colorize ? chalk.yellow('Format:') : 'Format:'} ${suggestion.format}`);
      if (suggestion.targetFile) {
        console.log(`${colorize ? chalk.yellow('Target:') : 'Target:'} ${colorize ? chalk.cyan(suggestion.targetFile) : suggestion.targetFile}`);
      }
      
      // Parse JSON response if it's a JSON string
      if (typeof suggestion.content === 'string' && suggestion.content.trim().startsWith('```json')) {
        try {
          const jsonMatch = suggestion.content.match(/```json\n([\s\S]*?)\n```/);
          if (jsonMatch) {
            const jsonData = JSON.parse(jsonMatch[1] || '{}');
            
            console.log(`\n${colorize ? chalk.bold('Content:') : 'Content:'}`);
            
            // Display title if present
            if (jsonData.title) {
              console.log(`${colorize ? chalk.bold.blue('Title:') : 'Title:'} ${jsonData.title}`);
            }
            
            // Display main content
            if (jsonData.content) {
              console.log(`\n${colorize ? chalk.bold('Description:') : 'Description:'}`);
              console.log(`  ${jsonData.content}`);
            }
            
            // Display examples if present
            if (jsonData.examples && Array.isArray(jsonData.examples) && jsonData.examples.length > 0) {
              console.log(`\n${colorize ? chalk.bold.green('Examples:') : 'Examples:'}`);
              for (let i = 0; i < jsonData.examples.length; i++) {
                console.log(`  ${colorize ? chalk.green(`${i + 1}.`) : `${i + 1}.`} ${jsonData.examples[i]}`);
              }
            }
            
            // Display parameters if present
            if (jsonData.parameters && Array.isArray(jsonData.parameters) && jsonData.parameters.length > 0) {
              console.log(`\n${colorize ? chalk.bold.magenta('Parameters:') : 'Parameters:'}`);
              for (const param of jsonData.parameters) {
                console.log(`  ${colorize ? chalk.cyan(`• ${param.name}`) : `• ${param.name}`} ${colorize ? chalk.gray(`(${param.type})`) : `(${param.type})`}`);
                console.log(`    ${colorize ? chalk.yellow('Required:') : 'Required:'} ${param.required ? (colorize ? chalk.red('Yes') : 'Yes') : (colorize ? chalk.green('No') : 'No')}`);
                if (param.description) {
                  console.log(`    ${colorize ? chalk.yellow('Description:') : 'Description:'} ${param.description}`);
                }
              }
            }
            
            // Display return type if present
            if (jsonData.returnType) {
              console.log(`\n${colorize ? chalk.bold.blue('Return Type:') : 'Return Type:'} ${colorize ? chalk.cyan(jsonData.returnType) : jsonData.returnType}`);
            }
            
            // Display see also if present
            if (jsonData.seeAlso && Array.isArray(jsonData.seeAlso) && jsonData.seeAlso.length > 0) {
              console.log(`\n${colorize ? chalk.bold.blue('See Also:') : 'See Also:'}`);
              for (const item of jsonData.seeAlso) {
                console.log(`  • ${colorize ? chalk.blue(item) : item}`);
              }
            }
          } else {
            // Fallback to original content if JSON parsing fails
            console.log(`\n${colorize ? chalk.bold('Content:') : 'Content:'}`);
            console.log(suggestion.content);
          }
        } catch (error) {
          // Fallback to original content if JSON parsing fails
          console.log(`\n${colorize ? chalk.bold('Content:') : 'Content:'}`);
          console.log(suggestion.content);
        }
      } else {
        // Regular content display
        console.log(`\n${colorize ? chalk.bold('Content:') : 'Content:'}`);
        console.log(suggestion.content);
      }
    }
  }

  private async displayReviewReportMarkdown(report: ReviewReport, options: OutputOptions): Promise<void> {
    let markdown = `# Review Report\n\n`;
    markdown += `**Summary:** ${report.summary}\n\n`;
    markdown += `**Overall Score:** ${report.overallScore}/100\n\n`;
    markdown += `**Timestamp:** ${report.timestamp.toISOString()}\n\n`;
    
    markdown += `## Metrics\n\n`;
    markdown += `- Total Comments: ${report.metrics.totalComments}\n`;
    markdown += `- Errors: ${report.metrics.errorCount}\n`;
    markdown += `- Warnings: ${report.metrics.warningCount}\n`;
    markdown += `- Info: ${report.metrics.infoCount}\n`;
    markdown += `- Suggestions: ${report.metrics.suggestionCount}\n`;
    markdown += `- Files Reviewed: ${report.metrics.filesReviewed}\n`;
    markdown += `- Lines Added: ${report.metrics.linesAdded}\n`;
    markdown += `- Lines Removed: ${report.metrics.linesRemoved}\n\n`;
    
    if (report.comments.length > 0) {
      markdown += `## Comments\n\n`;
      for (const comment of report.comments) {
        markdown += `### ${comment.filePath}${comment.lineNumber ? `:${comment.lineNumber}` : ''}\n\n`;
        markdown += `**Severity:** ${comment.severity}\n\n`;
        markdown += `**Category:** ${comment.category}\n\n`;
        markdown += `**Message:** ${comment.message}\n\n`;
        if (comment.suggestion) {
          markdown += `**Suggestion:** ${comment.suggestion}\n\n`;
        }
        markdown += `---\n\n`;
      }
    }
    
    if (report.recommendations.length > 0) {
      markdown += `## Recommendations\n\n`;
      for (const rec of report.recommendations) {
        markdown += `- ${rec}\n`;
      }
    }
    
    await this.displayMessage(markdown, options);
  }

  private async displaySecurityIssuesMarkdown(issues: SecurityIssue[], options: OutputOptions): Promise<void> {
    let markdown = `# Security Issues\n\n`;
    
    if (issues.length === 0) {
      markdown += `✅ No security issues found!\n`;
    } else {
      for (const issue of issues) {
        markdown += `## ${issue.title}\n\n`;
        markdown += `**Severity:** ${issue.severity}\n\n`;
        markdown += `**Category:** ${issue.category}\n\n`;
        markdown += `**File:** ${issue.filePath}${issue.lineNumber ? `:${issue.lineNumber}` : ''}\n\n`;
        markdown += `**Description:** ${issue.description}\n\n`;
        markdown += `**Remediation:** ${issue.remediation}\n\n`;
        
        if (issue.references && issue.references.length > 0) {
          markdown += `**References:**\n`;
          for (const ref of issue.references) {
            markdown += `- ${ref}\n`;
          }
          markdown += `\n`;
        }
        
        markdown += `---\n\n`;
      }
    }
    
    await this.displayMessage(markdown, options);
  }

  private async displayTestSuggestionsMarkdown(suggestions: TestSuggestion[], options: OutputOptions): Promise<void> {
    let markdown = `# Test Suggestions\n\n`;
    
    for (const suggestion of suggestions) {
      markdown += `## ${suggestion.description}\n\n`;
      markdown += `**Framework:** ${suggestion.framework}\n\n`;
      markdown += `**Type:** ${suggestion.testType}\n\n`;
      if (suggestion.targetFunction) {
        markdown += `**Target Function:** ${suggestion.targetFunction}\n\n`;
      }
      
      markdown += `**Test Code:**\n\`\`\`${suggestion.framework}\n${suggestion.testCode}\n\`\`\`\n\n`;
      
      if (suggestion.testCases.length > 0) {
        markdown += `**Test Cases:**\n`;
        for (const testCase of suggestion.testCases) {
          markdown += `- **${testCase.name}:** ${testCase.description}\n`;
        }
        markdown += `\n`;
      }
      
      markdown += `---\n\n`;
    }
    
    await this.displayMessage(markdown, options);
  }

  private async displayDocSuggestionsMarkdown(suggestions: DocSuggestion[], options: OutputOptions): Promise<void> {
    let markdown = `# Documentation Suggestions\n\n`;
    
    for (const suggestion of suggestions) {
      markdown += `## ${suggestion.title}\n\n`;
      markdown += `**Type:** ${suggestion.type}\n\n`;
      markdown += `**Format:** ${suggestion.format}\n\n`;
      if (suggestion.targetFile) {
        markdown += `**Target File:** ${suggestion.targetFile}\n\n`;
      }
      
      markdown += `**Content:**\n\n${suggestion.content}\n\n`;
      
      if (suggestion.examples && suggestion.examples.length > 0) {
        markdown += `**Examples:**\n`;
        for (const example of suggestion.examples) {
          markdown += `\`\`\`\n${example}\n\`\`\`\n`;
        }
        markdown += `\n`;
      }
      
      markdown += `---\n\n`;
    }
    
    await this.displayMessage(markdown, options);
  }

  private async displayReviewReportJSON(report: ReviewReport, options: OutputOptions): Promise<void> {
    await this.displayMessage(JSON.stringify(report, null, 2), options);
  }

  private async displaySecurityIssuesJSON(issues: SecurityIssue[], options: OutputOptions): Promise<void> {
    await this.displayMessage(JSON.stringify(issues, null, 2), options);
  }

  private async displayTestSuggestionsJSON(suggestions: TestSuggestion[], options: OutputOptions): Promise<void> {
    await this.displayMessage(JSON.stringify(suggestions, null, 2), options);
  }

  private async displayDocSuggestionsJSON(suggestions: DocSuggestion[], options: OutputOptions): Promise<void> {
    await this.displayMessage(JSON.stringify(suggestions, null, 2), options);
  }

  private async displayReviewReportHTML(report: ReviewReport, options: OutputOptions): Promise<void> {
    const html = this.convertReviewReportToHTML(report);
    await this.displayMessage(html, options);
  }

  private async displaySecurityIssuesHTML(issues: SecurityIssue[], options: OutputOptions): Promise<void> {
    const html = this.convertSecurityIssuesToHTML(issues);
    await this.displayMessage(html, options);
  }

  private async displayTestSuggestionsHTML(suggestions: TestSuggestion[], options: OutputOptions): Promise<void> {
    const html = this.convertTestSuggestionsToHTML(suggestions);
    await this.displayMessage(html, options);
  }

  private async displayDocSuggestionsHTML(suggestions: DocSuggestion[], options: OutputOptions): Promise<void> {
    const html = this.convertDocSuggestionsToHTML(suggestions);
    await this.displayMessage(html, options);
  }

  private getScoreColor(score: number, colorize: boolean): string {
    if (!colorize) return score.toString();
    
    if (score >= 80) return chalk.green(score.toString());
    if (score >= 60) return chalk.yellow(score.toString());
    return chalk.red(score.toString());
  }

  private getSeverityColor(severity: string, colorize: boolean): string {
    if (!colorize) return `[${severity}]`;
    
    switch (severity) {
      case 'error':
        return chalk.red(`[${severity}]`);
      case 'warning':
        return chalk.yellow(`[${severity}]`);
      case 'info':
        return chalk.blue(`[${severity}]`);
      case 'suggestion':
        return chalk.cyan(`[${severity}]`);
      default:
        return `[${severity}]`;
    }
  }

  private convertTableToMarkdown(data: Record<string, unknown>[]): string {
    if (data.length === 0) return '';
    
    const headers = Object.keys(data[0] || {});
    let markdown = `| ${headers.join(' | ')} |\n`;
    markdown += `| ${headers.map(() => '---').join(' | ')} |\n`;
    
    for (const row of data) {
      const values = headers.map(header => String(row[header] || ''));
      markdown += `| ${values.join(' | ')} |\n`;
    }
    
    return markdown;
  }

  private convertToHTML(data: unknown): string {
    // Simple HTML conversion - in a real implementation, you'd want more sophisticated templating
    return `
<!DOCTYPE html>
<html>
<head>
    <title>AI Developer Assistant Output</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .header { background-color: #f0f0f0; padding: 10px; border-radius: 5px; }
        .content { margin-top: 20px; }
        pre { background-color: #f5f5f5; padding: 10px; border-radius: 5px; overflow-x: auto; }
    </style>
</head>
<body>
    <div class="header">
        <h1>AI Developer Assistant Output</h1>
        <p>Generated on ${new Date().toISOString()}</p>
    </div>
    <div class="content">
        <pre>${JSON.stringify(data, null, 2)}</pre>
    </div>
</body>
</html>
    `;
  }

  private convertReviewReportToHTML(report: ReviewReport): string {
    return `
<!DOCTYPE html>
<html>
<head>
    <title>Review Report</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .header { background-color: #e3f2fd; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
        .metrics { background-color: #f5f5f5; padding: 15px; border-radius: 5px; margin-bottom: 20px; }
        .comment { border-left: 4px solid #2196f3; padding: 10px; margin: 10px 0; background-color: #fafafa; }
        .error { border-left-color: #f44336; }
        .warning { border-left-color: #ff9800; }
        .info { border-left-color: #2196f3; }
        .suggestion { border-left-color: #00bcd4; }
    </style>
</head>
<body>
    <div class="header">
        <h1>📋 Review Report</h1>
        <p><strong>Summary:</strong> ${report.summary}</p>
        <p><strong>Overall Score:</strong> ${report.overallScore}/100</p>
        <p><strong>Timestamp:</strong> ${report.timestamp.toISOString()}</p>
    </div>
    
    <div class="metrics">
        <h2>📊 Metrics</h2>
        <ul>
            <li>Total Comments: ${report.metrics.totalComments}</li>
            <li>Errors: ${report.metrics.errorCount}</li>
            <li>Warnings: ${report.metrics.warningCount}</li>
            <li>Info: ${report.metrics.infoCount}</li>
            <li>Suggestions: ${report.metrics.suggestionCount}</li>
            <li>Files Reviewed: ${report.metrics.filesReviewed}</li>
            <li>Lines Added: ${report.metrics.linesAdded}</li>
            <li>Lines Removed: ${report.metrics.linesRemoved}</li>
        </ul>
    </div>
    
    <div class="comments">
        <h2>💬 Comments</h2>
        ${report.comments.map(comment => `
            <div class="comment ${comment.severity}">
                <h3>${comment.filePath}${comment.lineNumber ? `:${comment.lineNumber}` : ''}</h3>
                <p><strong>[${comment.severity}]</strong> [${comment.category}] ${comment.message}</p>
                ${comment.suggestion ? `<p><strong>💡 Suggestion:</strong> ${comment.suggestion}</p>` : ''}
            </div>
        `).join('')}
    </div>
    
    ${report.recommendations.length > 0 ? `
    <div class="recommendations">
        <h2>🎯 Recommendations</h2>
        <ul>
            ${report.recommendations.map(rec => `<li>${rec}</li>`).join('')}
        </ul>
    </div>
    ` : ''}
</body>
</html>
    `;
  }

  private convertSecurityIssuesToHTML(issues: SecurityIssue[]): string {
    return `
<!DOCTYPE html>
<html>
<head>
    <title>Security Issues</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .header { background-color: #ffebee; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
        .issue { border: 1px solid #ddd; padding: 15px; margin: 10px 0; border-radius: 5px; }
        .critical { border-left: 4px solid #f44336; }
        .high { border-left: 4px solid #ff5722; }
        .medium { border-left: 4px solid #ff9800; }
        .low { border-left: 4px solid #4caf50; }
    </style>
</head>
<body>
    <div class="header">
        <h1>🔒 Security Issues</h1>
        <p>Found ${issues.length} security issue(s)</p>
    </div>
    
    ${issues.map(issue => `
        <div class="issue ${issue.severity}">
            <h2>${issue.title}</h2>
            <p><strong>Severity:</strong> ${issue.severity}</p>
            <p><strong>Category:</strong> ${issue.category}</p>
            <p><strong>File:</strong> ${issue.filePath}${issue.lineNumber ? `:${issue.lineNumber}` : ''}</p>
            <p><strong>Description:</strong> ${issue.description}</p>
            <p><strong>Remediation:</strong> ${issue.remediation}</p>
            ${issue.references && issue.references.length > 0 ? `
                <p><strong>References:</strong></p>
                <ul>
                    ${issue.references.map(ref => `<li>${ref}</li>`).join('')}
                </ul>
            ` : ''}
        </div>
    `).join('')}
</body>
</html>
    `;
  }

  private convertTestSuggestionsToHTML(suggestions: TestSuggestion[]): string {
    return `
<!DOCTYPE html>
<html>
<head>
    <title>Test Suggestions</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .header { background-color: #e8f5e8; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
        .suggestion { border: 1px solid #ddd; padding: 15px; margin: 10px 0; border-radius: 5px; }
        pre { background-color: #f5f5f5; padding: 10px; border-radius: 5px; overflow-x: auto; }
    </style>
</head>
<body>
    <div class="header">
        <h1>🧪 Test Suggestions</h1>
        <p>Generated ${suggestions.length} test suggestion(s)</p>
    </div>
    
    ${suggestions.map(suggestion => `
        <div class="suggestion">
            <h2>${suggestion.description}</h2>
            <p><strong>Framework:</strong> ${suggestion.framework}</p>
            <p><strong>Type:</strong> ${suggestion.testType}</p>
            ${suggestion.targetFunction ? `<p><strong>Target Function:</strong> ${suggestion.targetFunction}</p>` : ''}
            
            <h3>Test Code:</h3>
            <pre><code>${suggestion.testCode}</code></pre>
            
            ${suggestion.testCases.length > 0 ? `
                <h3>Test Cases:</h3>
                <ul>
                    ${suggestion.testCases.map(testCase => `
                        <li><strong>${testCase.name}:</strong> ${testCase.description}</li>
                    `).join('')}
                </ul>
            ` : ''}
        </div>
    `).join('')}
</body>
</html>
    `;
  }

  private convertDocSuggestionsToHTML(suggestions: DocSuggestion[]): string {
    return `
<!DOCTYPE html>
<html>
<head>
    <title>Documentation Suggestions</title>
    <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        .header { background-color: #e3f2fd; padding: 20px; border-radius: 5px; margin-bottom: 20px; }
        .suggestion { border: 1px solid #ddd; padding: 15px; margin: 10px 0; border-radius: 5px; }
        pre { background-color: #f5f5f5; padding: 10px; border-radius: 5px; overflow-x: auto; }
    </style>
</head>
<body>
    <div class="header">
        <h1>📚 Documentation Suggestions</h1>
        <p>Generated ${suggestions.length} documentation suggestion(s)</p>
    </div>
    
    ${suggestions.map(suggestion => `
        <div class="suggestion">
            <h2>${suggestion.title}</h2>
            <p><strong>Type:</strong> ${suggestion.type}</p>
            <p><strong>Format:</strong> ${suggestion.format}</p>
            ${suggestion.targetFile ? `<p><strong>Target File:</strong> ${suggestion.targetFile}</p>` : ''}
            
            <h3>Content:</h3>
            <div>${suggestion.content}</div>
            
            ${suggestion.examples && suggestion.examples.length > 0 ? `
                <h3>Examples:</h3>
                ${suggestion.examples.map(example => `
                    <pre><code>${example}</code></pre>
                `).join('')}
            ` : ''}
        </div>
    `).join('')}
</body>
</html>
    `;
  }
}