Code Review Best Practices - Complete Guide

# Code Review Workflow Implementation

# 1. Pre-Review Checklist
class PreReviewChecklist {
  constructor() {
    this.checks = [
      'Code compiles without errors',
      'All tests pass',
      'Code follows style guidelines',
      'No console.log statements',
      'No commented-out code',
      'Proper error handling',
      'Documentation updated'
    ];
  }
  
  validate(code) {
    const results = [];
    
    for (const check of this.checks) {
      const result = this.performCheck(check, code);
      results.push({
        check: check,
        passed: result.passed,
        message: result.message
      });
    }
    
    return results;
  }
  
  performCheck(check, code) {
    switch (check) {
      case 'Code compiles without errors':
        return this.checkCompilation(code);
      case 'All tests pass':
        return this.checkTests(code);
      case 'Code follows style guidelines':
        return this.checkStyle(code);
      case 'No console.log statements':
        return this.checkConsoleLogs(code);
      case 'No commented-out code':
        return this.checkCommentedCode(code);
      case 'Proper error handling':
        return this.checkErrorHandling(code);
      case 'Documentation updated':
        return this.checkDocumentation(code);
      default:
        return { passed: true, message: 'Check not implemented' };
    }
  }
  
  checkCompilation(code) {
    try {
      // Simulate compilation check
      const hasErrors = code.includes('undefined_variable') || code.includes('syntax_error');
      return {
        passed: !hasErrors,
        message: hasErrors ? 'Code has compilation errors' : 'Code compiles successfully'
      };
    } catch (error) {
      return { passed: false, message: 'Compilation check failed' };
    }
  }
  
  checkTests(code) {
    const hasTests = code.includes('test(') || code.includes('describe(') || code.includes('it(');
    return {
      passed: hasTests,
      message: hasTests ? 'Tests found' : 'No tests found'
    };
  }
  
  checkStyle(code) {
    const hasInconsistentIndentation = code.includes('  ') && code.includes('\t');
    const hasLongLines = code.split('\n').some(line => line.length > 120);
    
    return {
      passed: !hasInconsistentIndentation && !hasLongLines,
      message: hasInconsistentIndentation ? 'Inconsistent indentation' : 
               hasLongLines ? 'Lines too long' : 'Style guidelines followed'
    };
  }
  
  checkConsoleLogs(code) {
    const hasConsoleLogs = code.includes('console.log') || code.includes('console.error');
    return {
      passed: !hasConsoleLogs,
      message: hasConsoleLogs ? 'Console statements found' : 'No console statements'
    };
  }
  
  checkCommentedCode(code) {
    const hasCommentedCode = code.includes('// TODO') || code.includes('// FIXME');
    return {
      passed: !hasCommentedCode,
      message: hasCommentedCode ? 'Commented code found' : 'No commented code'
    };
  }
  
  checkErrorHandling(code) {
    const hasTryCatch = code.includes('try {') && code.includes('} catch');
    const hasErrorHandling = code.includes('throw new Error') || hasTryCatch;
    
    return {
      passed: hasErrorHandling,
      message: hasErrorHandling ? 'Error handling present' : 'Missing error handling'
    };
  }
  
  checkDocumentation(code) {
    const hasJSDoc = code.includes('/**') && code.includes('*/');
    const hasComments = code.includes('//') || code.includes('/*');
    
    return {
      passed: hasJSDoc || hasComments,
      message: hasJSDoc ? 'JSDoc documentation found' : 
               hasComments ? 'Comments found' : 'No documentation'
    };
  }
}

# 2. Review Request Template
class ReviewRequestTemplate {
  constructor() {
    this.template = {
      title: '',
      description: '',
      type: '',
      priority: '',
      testing: '',
      screenshots: [],
      relatedIssues: [],
      checklist: []
    };
  }
  
  generateRequest(prData) {
    return {
      title: prData.title,
      description: this.generateDescription(prData),
      type: this.determineType(prData),
      priority: this.determinePriority(prData),
      testing: this.generateTestingNotes(prData),
      screenshots: prData.screenshots || [],
      relatedIssues: prData.relatedIssues || [],
      checklist: this.generateChecklist(prData)
    };
  }
  
  generateDescription(prData) {
    let description = `## Overview\n${prData.description}\n\n`;
    
    if (prData.changes) {
      description += `## Changes\n`;
      prData.changes.forEach(change => {
        description += `- ${change}\n`;
      });
      description += '\n';
    }
    
    if (prData.breakingChanges) {
      description += `## Breaking Changes\n${prData.breakingChanges}\n\n`;
    }
    
    if (prData.dependencies) {
      description += `## Dependencies\n${prData.dependencies}\n\n`;
    }
    
    return description;
  }
  
  determineType(prData) {
    if (prData.title.includes('fix') || prData.title.includes('bug')) {
      return 'Bug Fix';
    } else if (prData.title.includes('feat') || prData.title.includes('feature')) {
      return 'Feature';
    } else if (prData.title.includes('refactor')) {
      return 'Refactoring';
    } else if (prData.title.includes('docs')) {
      return 'Documentation';
    } else if (prData.title.includes('test')) {
      return 'Test';
    } else {
      return 'Other';
    }
  }
  
  determinePriority(prData) {
    if (prData.labels && prData.labels.includes('urgent')) {
      return 'High';
    } else if (prData.labels && prData.labels.includes('low')) {
      return 'Low';
    } else {
      return 'Medium';
    }
  }
  
  generateTestingNotes(prData) {
    let notes = '## Testing\n\n';
    notes += '### Manual Testing\n';
    notes += '- [ ] Tested in development environment\n';
    notes += '- [ ] Tested in staging environment\n';
    notes += '- [ ] Tested with different browsers\n';
    notes += '- [ ] Tested with different screen sizes\n\n';
    
    notes += '### Automated Testing\n';
    notes += '- [ ] Unit tests pass\n';
    notes += '- [ ] Integration tests pass\n';
    notes += '- [ ] E2E tests pass\n\n';
    
    if (prData.testingNotes) {
      notes += `### Additional Testing Notes\n${prData.testingNotes}\n\n`;
    }
    
    return notes;
  }
  
  generateChecklist(prData) {
    return [
      'Code follows project style guidelines',
      'Self-review completed',
      'Tests added/updated',
      'Documentation updated',
      'No breaking changes (or documented)',
      'Performance impact considered',
      'Security implications reviewed'
    ];
  }
}

# 3. Review Guidelines
class ReviewGuidelines {
  constructor() {
    this.guidelines = {
      reviewer: this.getReviewerGuidelines(),
      author: this.getAuthorGuidelines(),
      process: this.getProcessGuidelines()
    };
  }
  
  getReviewerGuidelines() {
    return {
      focus: [
        'Code correctness and logic',
        'Performance implications',
        'Security vulnerabilities',
        'Code maintainability',
        'Test coverage',
        'Documentation quality'
      ],
      approach: [
        'Be constructive and respectful',
        'Explain the why behind suggestions',
        'Ask questions rather than making demands',
        'Focus on the code, not the person',
        'Provide specific examples',
        'Suggest alternatives when possible'
      ],
      timing: [
        'Review within 24 hours when possible',
        'Set expectations for review timeline',
        'Communicate delays proactively',
        'Prioritize urgent reviews'
      ]
    };
  }
  
  getAuthorGuidelines() {
    return {
      preparation: [
        'Self-review your code first',
        'Write clear commit messages',
        'Keep PRs focused and small',
        'Include relevant tests',
        'Update documentation',
        'Add screenshots for UI changes'
      ],
      communication: [
        'Respond to feedback promptly',
        'Ask questions if feedback is unclear',
        'Explain your reasoning',
        'Be open to suggestions',
        'Thank reviewers for their time'
      ],
      followup: [
        'Address all feedback',
        'Test changes after updates',
        'Update tests if needed',
        'Communicate when ready for re-review'
      ]
    };
  }
  
  getProcessGuidelines() {
    return {
      workflow: [
        'Use feature branches',
        'Require at least one approval',
        'Ensure CI passes before merge',
        'Squash commits when appropriate',
        'Delete feature branches after merge'
      ],
      tools: [
        'Use pull request templates',
        'Enable required status checks',
        'Set up branch protection rules',
        'Use automated testing',
        'Integrate code quality tools'
      ],
      metrics: [
        'Track review time',
        'Monitor review coverage',
          'Measure code quality metrics',
          'Collect feedback on process'
        ]
      };
    }
  }
}

# 4. Automated Review Tools
class AutomatedReviewTools {
  constructor() {
    this.tools = {
      linting: new LintingTool(),
      testing: new TestingTool(),
      security: new SecurityTool(),
      performance: new PerformanceTool(),
      documentation: new DocumentationTool()
    };
  }
  
  runAllChecks(code) {
    const results = {
      linting: this.tools.linting.check(code),
      testing: this.tools.testing.check(code),
      security: this.tools.security.check(code),
      performance: this.tools.performance.check(code),
      documentation: this.tools.documentation.check(code)
    };
    
    return this.generateReport(results);
  }
  
  generateReport(results) {
    const report = {
      overall: 'pass',
      checks: results,
      summary: this.generateSummary(results),
      recommendations: this.generateRecommendations(results)
    };
    
    // Determine overall status
    const failedChecks = Object.values(results).filter(result => result.status === 'fail');
    if (failedChecks.length > 0) {
      report.overall = 'fail';
    } else if (Object.values(results).some(result => result.status === 'warn')) {
      report.overall = 'warn';
    }
    
    return report;
  }
  
  generateSummary(results) {
    const totalChecks = Object.keys(results).length;
    const passedChecks = Object.values(results).filter(result => result.status === 'pass').length;
    const failedChecks = Object.values(results).filter(result => result.status === 'fail').length;
    const warningChecks = Object.values(results).filter(result => result.status === 'warn').length;
    
    return {
      total: totalChecks,
      passed: passedChecks,
      failed: failedChecks,
      warnings: warningChecks,
      score: Math.round((passedChecks / totalChecks) * 100)
    };
  }
  
  generateRecommendations(results) {
    const recommendations = [];
    
    for (const [tool, result] of Object.entries(results)) {
      if (result.status === 'fail') {
        recommendations.push({
          tool: tool,
          priority: 'high',
          message: result.message,
          action: result.action
        });
      } else if (result.status === 'warn') {
        recommendations.push({
          tool: tool,
          priority: 'medium',
          message: result.message,
          action: result.action
        });
      }
    }
    
    return recommendations;
  }
}

# 5. Linting Tool Implementation
class LintingTool {
  check(code) {
    const issues = [];
    
    // Check for common issues
    if (this.hasUnusedVariables(code)) {
      issues.push('Unused variables detected');
    }
    
    if (this.hasLongFunctions(code)) {
      issues.push('Functions longer than 50 lines detected');
    }
    
    if (this.hasComplexFunctions(code)) {
      issues.push('Functions with high cyclomatic complexity detected');
    }
    
    if (this.hasInconsistentNaming(code)) {
      issues.push('Inconsistent naming conventions detected');
    }
    
    if (this.hasMissingSemicolons(code)) {
      issues.push('Missing semicolons detected');
    }
    
    return {
      status: issues.length === 0 ? 'pass' : 'warn',
      message: issues.length === 0 ? 'No linting issues found' : issues.join(', '),
      action: issues.length === 0 ? 'No action required' : 'Fix linting issues',
      issues: issues
    };
  }
  
  hasUnusedVariables(code) {
    // Simplified check for unused variables
    const variableRegex = /(?:let|const|var)\s+(\w+)/g;
    const usedVariables = new Set();
    const declaredVariables = new Set();
    
    let match;
    while ((match = variableRegex.exec(code)) !== null) {
      declaredVariables.add(match[1]);
    }
    
    // Check if variables are used
    for (const variable of declaredVariables) {
      const usageRegex = new RegExp(`\\b${variable}\\b`, 'g');
      const matches = code.match(usageRegex);
      if (matches && matches.length > 1) {
        usedVariables.add(variable);
      }
    }
    
    return declaredVariables.size > usedVariables.size;
  }
  
  hasLongFunctions(code) {
    const functions = code.split(/function\s+\w+|const\s+\w+\s*=\s*\(/g);
    return functions.some(func => func.split('\n').length > 50);
  }
  
  hasComplexFunctions(code) {
    // Simplified complexity check
    const functions = code.split(/function\s+\w+|const\s+\w+\s*=\s*\(/g);
    return functions.some(func => {
      const complexity = (func.match(/if|for|while|switch|catch/g) || []).length;
      return complexity > 10;
    });
  }
  
  hasInconsistentNaming(code) {
    const camelCaseRegex = /[a-z]+[A-Z]/g;
    const snakeCaseRegex = /[a-z]+_[a-z]/g;
    const hasCamelCase = camelCaseRegex.test(code);
    const hasSnakeCase = snakeCaseRegex.test(code);
    
    return hasCamelCase && hasSnakeCase;
  }
  
  hasMissingSemicolons(code) {
    const lines = code.split('\n');
    return lines.some(line => {
      const trimmed = line.trim();
      return trimmed.length > 0 && 
             !trimmed.endsWith(';') && 
             !trimmed.endsWith('{') && 
             !trimmed.endsWith('}') &&
             !trimmed.startsWith('//') &&
             !trimmed.startsWith('*') &&
             !trimmed.startsWith('/*');
    });
  }
}

# 6. Testing Tool Implementation
class TestingTool {
  check(code) {
    const issues = [];
    
    if (!this.hasTests(code)) {
      issues.push('No tests found');
    }
    
    if (this.hasLowTestCoverage(code)) {
      issues.push('Low test coverage detected');
    }
    
    if (this.hasSlowTests(code)) {
      issues.push('Slow tests detected');
    }
    
    if (this.hasFlakyTests(code)) {
      issues.push('Potentially flaky tests detected');
    }
    
    return {
      status: issues.length === 0 ? 'pass' : 'warn',
      message: issues.length === 0 ? 'Tests look good' : issues.join(', '),
      action: issues.length === 0 ? 'No action required' : 'Improve test coverage',
      issues: issues
    };
  }
  
  hasTests(code) {
    return code.includes('test(') || code.includes('describe(') || code.includes('it(');
  }
  
  hasLowTestCoverage(code) {
    // Simplified coverage check
    const functions = (code.match(/function\s+\w+|const\s+\w+\s*=\s*\(/g) || []).length;
    const tests = (code.match(/test\(|describe\(|it\(/g) || []).length;
    
    return functions > 0 && tests < functions * 0.8;
  }
  
  hasSlowTests(code) {
    return code.includes('setTimeout') || code.includes('sleep') || code.includes('wait');
  }
  
  hasFlakyTests(code) {
    return code.includes('Math.random') || code.includes('Date.now') || code.includes('new Date()');
  }
}

# 7. Security Tool Implementation
class SecurityTool {
  check(code) {
    const issues = [];
    
    if (this.hasHardcodedSecrets(code)) {
      issues.push('Hardcoded secrets detected');
    }
    
    if (this.hasSQLInjection(code)) {
      issues.push('Potential SQL injection vulnerability');
    }
    
    if (this.hasXSSVulnerability(code)) {
      issues.push('Potential XSS vulnerability');
    }
    
    if (this.hasInsecureRandom(code)) {
      issues.push('Insecure random number generation');
    }
    
    return {
      status: issues.length === 0 ? 'pass' : 'fail',
      message: issues.length === 0 ? 'No security issues found' : issues.join(', '),
      action: issues.length === 0 ? 'No action required' : 'Fix security vulnerabilities',
      issues: issues
    };
  }
  
  hasHardcodedSecrets(code) {
    const secretPatterns = [
      /password\s*=\s*['"][^'"]+['"]/i,
      /api[_-]?key\s*=\s*['"][^'"]+['"]/i,
      /secret\s*=\s*['"][^'"]+['"]/i,
      /token\s*=\s*['"][^'"]+['"]/i
    ];
    
    return secretPatterns.some(pattern => pattern.test(code));
  }
  
  hasSQLInjection(code) {
    const sqlPatterns = [
      /SELECT.*\+.*req\./i,
      /INSERT.*\+.*req\./i,
      /UPDATE.*\+.*req\./i,
      /DELETE.*\+.*req\./i
    ];
    
    return sqlPatterns.some(pattern => pattern.test(code));
  }
  
  hasXSSVulnerability(code) {
    return code.includes('innerHTML') && code.includes('req.') || 
           code.includes('document.write') && code.includes('req.');
  }
  
  hasInsecureRandom(code) {
    return code.includes('Math.random()') && code.includes('crypto') ||
           code.includes('Math.random()') && code.includes('password');
  }
}

# 8. Performance Tool Implementation
class PerformanceTool {
  check(code) {
    const issues = [];
    
    if (this.hasNPlusOneQueries(code)) {
      issues.push('Potential N+1 query problem');
    }
    
    if (this.hasInefficientLoops(code)) {
      issues.push('Inefficient loop detected');
    }
    
    if (this.hasMemoryLeaks(code)) {
      issues.push('Potential memory leak detected');
    }
    
    if (this.hasBlockingOperations(code)) {
      issues.push('Blocking operations detected');
    }
    
    return {
      status: issues.length === 0 ? 'pass' : 'warn',
      message: issues.length === 0 ? 'No performance issues found' : issues.join(', '),
      action: issues.length === 0 ? 'No action required' : 'Optimize performance',
      issues: issues
    };
  }
  
  hasNPlusOneQueries(code) {
    return code.includes('forEach') && code.includes('database') && code.includes('query');
  }
  
  hasInefficientLoops(code) {
    return code.includes('for (let i = 0; i < array.length; i++)') ||
           code.includes('while (true)');
  }
  
  hasMemoryLeaks(code) {
    return code.includes('setInterval') && !code.includes('clearInterval') ||
           code.includes('setTimeout') && !code.includes('clearTimeout');
  }
  
  hasBlockingOperations(code) {
    return code.includes('fs.readFileSync') || code.includes('JSON.parse') && code.includes('large');
  }
}

# 9. Documentation Tool Implementation
class DocumentationTool {
  check(code) {
    const issues = [];
    
    if (!this.hasFunctionDocumentation(code)) {
      issues.push('Missing function documentation');
    }
    
    if (!this.hasClassDocumentation(code)) {
      issues.push('Missing class documentation');
    }
    
    if (this.hasOutdatedComments(code)) {
      issues.push('Outdated comments detected');
    }
    
    if (!this.hasReadme(code)) {
      issues.push('Missing README file');
    }
    
    return {
      status: issues.length === 0 ? 'pass' : 'warn',
      message: issues.length === 0 ? 'Documentation looks good' : issues.join(', '),
      action: issues.length === 0 ? 'No action required' : 'Improve documentation',
      issues: issues
    };
  }
  
  hasFunctionDocumentation(code) {
    const functions = (code.match(/function\s+\w+|const\s+\w+\s*=\s*\(/g) || []).length;
    const documentedFunctions = (code.match(/\/\*\*[\s\S]*?\*\/\s*(?:function|const)/g) || []).length;
    
    return functions === 0 || documentedFunctions >= functions * 0.8;
  }
  
  hasClassDocumentation(code) {
    const classes = (code.match(/class\s+\w+/g) || []).length;
    const documentedClasses = (code.match(/\/\*\*[\s\S]*?\*\/\s*class/g) || []).length;
    
    return classes === 0 || documentedClasses >= classes * 0.8;
  }
  
  hasOutdatedComments(code) {
    return code.includes('// TODO: Remove this') || 
           code.includes('// FIXME: This is broken') ||
           code.includes('// HACK: Temporary fix');
  }
  
  hasReadme(code) {
    // This would typically check for README.md file existence
    return true; // Simplified for example
  }
}

# Review Metrics Implementation

class ReviewMetrics {
  constructor() {
    this.metrics = {
      reviewTime: new ReviewTimeMetric(),
      reviewCoverage: new ReviewCoverageMetric(),
      codeQuality: new CodeQualityMetric(),
      teamCollaboration: new TeamCollaborationMetric()
    };
  }
  
  collectMetrics(reviews) {
    const results = {};
    
    for (const [metricName, metric] of Object.entries(this.metrics)) {
      results[metricName] = metric.calculate(reviews);
    }
    
    return this.generateReport(results);
  }
  
  generateReport(metrics) {
    return {
      summary: this.generateSummary(metrics),
      trends: this.generateTrends(metrics),
      recommendations: this.generateRecommendations(metrics),
      dashboard: this.generateDashboard(metrics)
    };
  }
  
  generateSummary(metrics) {
    return {
      averageReviewTime: metrics.reviewTime.average,
      reviewCoverage: metrics.reviewCoverage.percentage,
      codeQualityScore: metrics.codeQuality.score,
      teamCollaborationScore: metrics.teamCollaboration.score
    };
  }
  
  generateTrends(metrics) {
    return {
      reviewTimeTrend: metrics.reviewTime.trend,
      qualityTrend: metrics.codeQuality.trend,
      coverageTrend: metrics.reviewCoverage.trend
    };
  }
  
  generateRecommendations(metrics) {
    const recommendations = [];
    
    if (metrics.reviewTime.average > 24) {
      recommendations.push({
        category: 'Review Time',
        issue: 'Reviews taking too long',
        suggestion: 'Consider smaller PRs or more reviewers'
      });
    }
    
    if (metrics.reviewCoverage.percentage < 80) {
      recommendations.push({
        category: 'Coverage',
        issue: 'Low review coverage',
        suggestion: 'Ensure all code changes are reviewed'
      });
    }
    
    if (metrics.codeQuality.score < 70) {
      recommendations.push({
        category: 'Quality',
        issue: 'Code quality declining',
        suggestion: 'Focus on quality guidelines and training'
      });
    }
    
    return recommendations;
  }
  
  generateDashboard(metrics) {
    return {
      charts: [
        {
          type: 'line',
          title: 'Review Time Trend',
          data: metrics.reviewTime.history
        },
        {
          type: 'bar',
          title: 'Review Coverage by Team',
          data: metrics.reviewCoverage.byTeam
        },
        {
          type: 'pie',
          title: 'Code Quality Distribution',
          data: metrics.codeQuality.distribution
        }
      ]
    };
  }
}

class ReviewTimeMetric {
  calculate(reviews) {
    const times = reviews.map(review => this.calculateReviewTime(review));
    
    return {
      average: this.calculateAverage(times),
      median: this.calculateMedian(times),
      min: Math.min(...times),
      max: Math.max(...times),
      trend: this.calculateTrend(times),
      history: this.generateHistory(reviews)
    };
  }
  
  calculateReviewTime(review) {
    const startTime = new Date(review.createdAt);
    const endTime = new Date(review.mergedAt || review.closedAt);
    return (endTime - startTime) / (1000 * 60 * 60); // Hours
  }
  
  calculateAverage(times) {
    return times.reduce((sum, time) => sum + time, 0) / times.length;
  }
  
  calculateMedian(times) {
    const sorted = times.sort((a, b) => a - b);
    const mid = Math.floor(sorted.length / 2);
    return sorted.length % 2 === 0 ? 
           (sorted[mid - 1] + sorted[mid]) / 2 : 
           sorted[mid];
  }
  
  calculateTrend(times) {
    if (times.length < 2) return 'stable';
    
    const recent = times.slice(-10);
    const older = times.slice(0, -10);
    
    if (recent.length === 0 || older.length === 0) return 'stable';
    
    const recentAvg = this.calculateAverage(recent);
    const olderAvg = this.calculateAverage(older);
    
    const change = ((recentAvg - olderAvg) / olderAvg) * 100;
    
    if (change > 10) return 'increasing';
    if (change < -10) return 'decreasing';
    return 'stable';
  }
  
  generateHistory(reviews) {
    const history = {};
    
    reviews.forEach(review => {
      const date = new Date(review.createdAt).toISOString().split('T')[0];
      if (!history[date]) {
        history[date] = [];
      }
      history[date].push(this.calculateReviewTime(review));
    });
    
    return Object.entries(history).map(([date, times]) => ({
      date: date,
      average: this.calculateAverage(times),
      count: times.length
    }));
  }
}

class ReviewCoverageMetric {
  calculate(reviews) {
    const totalCommits = reviews.reduce((sum, review) => sum + review.commits, 0);
    const reviewedCommits = reviews.filter(review => review.reviewers.length > 0).length;
    
    return {
      percentage: (reviewedCommits / totalCommits) * 100,
      totalCommits: totalCommits,
      reviewedCommits: reviewedCommits,
      byTeam: this.calculateByTeam(reviews),
      trend: this.calculateTrend(reviews)
    };
  }
  
  calculateByTeam(reviews) {
    const teamStats = {};
    
    reviews.forEach(review => {
      review.teams.forEach(team => {
        if (!teamStats[team]) {
          teamStats[team] = { total: 0, reviewed: 0 };
        }
        teamStats[team].total++;
        if (review.reviewers.length > 0) {
          teamStats[team].reviewed++;
        }
      });
    });
    
    return Object.entries(teamStats).map(([team, stats]) => ({
      team: team,
      coverage: (stats.reviewed / stats.total) * 100,
      total: stats.total,
      reviewed: stats.reviewed
    }));
  }
  
  calculateTrend(reviews) {
    const sortedReviews = reviews.sort((a, b) => new Date(a.createdAt) - new Date(b.createdAt));
    const chunks = this.chunkArray(sortedReviews, 10);
    
    if (chunks.length < 2) return 'stable';
    
    const recentChunk = chunks[chunks.length - 1];
    const olderChunk = chunks[chunks.length - 2];
    
    const recentCoverage = this.calculateChunkCoverage(recentChunk);
    const olderCoverage = this.calculateChunkCoverage(olderChunk);
    
    const change = recentCoverage - olderCoverage;
    
    if (change > 5) return 'improving';
    if (change < -5) return 'declining';
    return 'stable';
  }
  
  calculateChunkCoverage(chunk) {
    const total = chunk.length;
    const reviewed = chunk.filter(review => review.reviewers.length > 0).length;
    return (reviewed / total) * 100;
  }
  
  chunkArray(array, size) {
    const chunks = [];
    for (let i = 0; i < array.length; i += size) {
      chunks.push(array.slice(i, i + size));
    }
    return chunks;
  }
}

class CodeQualityMetric {
  calculate(reviews) {
    const qualityScores = reviews.map(review => this.calculateQualityScore(review));
    
    return {
      score: this.calculateAverage(qualityScores),
      distribution: this.calculateDistribution(qualityScores),
      trend: this.calculateTrend(qualityScores),
      factors: this.analyzeFactors(reviews)
    };
  }
  
  calculateQualityScore(review) {
    let score = 100;
    
    // Deduct points for issues
    score -= review.bugs * 10;
    score -= review.vulnerabilities * 20;
    score -= review.codeSmells * 5;
    score -= review.duplications * 3;
    
    // Bonus for good practices
    if (review.hasTests) score += 5;
    if (review.hasDocumentation) score += 5;
    if (review.followsGuidelines) score += 5;
    
    return Math.max(0, Math.min(100, score));
  }
  
  calculateAverage(scores) {
    return scores.reduce((sum, score) => sum + score, 0) / scores.length;
  }
  
  calculateDistribution(scores) {
    const distribution = {
      excellent: 0,
      good: 0,
      fair: 0,
      poor: 0
    };
    
    scores.forEach(score => {
      if (score >= 90) distribution.excellent++;
      else if (score >= 70) distribution.good++;
      else if (score >= 50) distribution.fair++;
      else distribution.poor++;
    });
    
    return distribution;
  }
  
  calculateTrend(scores) {
    if (scores.length < 2) return 'stable';
    
    const recent = scores.slice(-10);
    const older = scores.slice(0, -10);
    
    if (recent.length === 0 || older.length === 0) return 'stable';
    
    const recentAvg = this.calculateAverage(recent);
    const olderAvg = this.calculateAverage(older);
    
    const change = recentAvg - olderAvg;
    
    if (change > 5) return 'improving';
    if (change < -5) return 'declining';
    return 'stable';
  }
  
  analyzeFactors(reviews) {
    const factors = {
      bugs: 0,
      vulnerabilities: 0,
      codeSmells: 0,
      duplications: 0,
      testCoverage: 0,
      documentation: 0
    };
    
    reviews.forEach(review => {
      factors.bugs += review.bugs || 0;
      factors.vulnerabilities += review.vulnerabilities || 0;
      factors.codeSmells += review.codeSmells || 0;
      factors.duplications += review.duplications || 0;
      factors.testCoverage += review.testCoverage || 0;
      factors.documentation += review.hasDocumentation ? 1 : 0;
    });
    
    return factors;
  }
}

class TeamCollaborationMetric {
  calculate(reviews) {
    return {
      score: this.calculateCollaborationScore(reviews),
      participation: this.calculateParticipation(reviews),
      communication: this.calculateCommunication(reviews),
      knowledgeSharing: this.calculateKnowledgeSharing(reviews)
    };
  }
  
  calculateCollaborationScore(reviews) {
    let score = 0;
    let totalReviews = reviews.length;
    
    reviews.forEach(review => {
      // Bonus for multiple reviewers
      score += Math.min(review.reviewers.length, 3) * 10;
      
      // Bonus for constructive feedback
      score += review.constructiveComments * 5;
      
      // Bonus for quick responses
      if (review.responseTime < 4) score += 10;
      
      // Bonus for knowledge sharing
      if (review.hasKnowledgeSharing) score += 15;
    });
    
    return Math.min(100, score / totalReviews);
  }
  
  calculateParticipation(reviews) {
    const reviewers = new Set();
    const authors = new Set();
    
    reviews.forEach(review => {
      authors.add(review.author);
      review.reviewers.forEach(reviewer => reviewers.add(reviewer));
    });
    
    return {
      uniqueReviewers: reviewers.size,
      uniqueAuthors: authors.size,
      participationRate: (reviewers.size / authors.size) * 100
    };
  }
  
  calculateCommunication(reviews) {
    const totalComments = reviews.reduce((sum, review) => sum + review.comments, 0);
    const totalReviews = reviews.length;
    
    return {
      averageComments: totalComments / totalReviews,
      responseRate: reviews.filter(r => r.responseTime < 24).length / totalReviews * 100,
      constructiveRate: reviews.filter(r => r.constructiveComments > 0).length / totalReviews * 100
    };
  }
  
  calculateKnowledgeSharing(reviews) {
    const knowledgeSharingReviews = reviews.filter(r => r.hasKnowledgeSharing);
    
    return {
      percentage: (knowledgeSharingReviews.length / reviews.length) * 100,
      topics: this.extractTopics(knowledgeSharingReviews)
    };
  }
  
  extractTopics(reviews) {
    const topics = {};
    
    reviews.forEach(review => {
      review.topics.forEach(topic => {
        topics[topic] = (topics[topic] || 0) + 1;
      });
    });
    
    return topics;
  }
}