The Future of AI in Enterprise Software Development

import OpenAI from 'openai';
import { PrismaClient } from '@prisma/client';

interface CodeReviewResult {
  summary: string;
  issues: CodeIssue[];
  suggestions: Suggestion[];
  securityRisks: SecurityRisk[];
  metrics: CodeMetrics;
  confidence: number;
}

interface CodeIssue {
  line: number;
  column?: number;
  severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
  category: 'bug' | 'security' | 'performance' | 'maintainability' | 'style';
  message: string;
  explanation: string;
  suggestedFix?: string;
}

interface Suggestion {
  type: 'refactoring' | 'optimization' | 'best-practice';
  description: string;
  impact: 'high' | 'medium' | 'low';
  effort: 'high' | 'medium' | 'low';
}

interface SecurityRisk {
  severity: 'critical' | 'high' | 'medium' | 'low';
  vulnerability: string;
  cwe?: string;
  mitigation: string;
}

interface CodeMetrics {
  complexity: number;
  maintainabilityIndex: number;
  testCoverage?: number;
  duplicateLines: number;
  linesOfCode: number;
}

class AICodeReviewer {
  private openai: OpenAI;
  private prisma: PrismaClient;
  private cache: Map<string, CodeReviewResult>;

  constructor(apiKey: string) {
    this.openai = new OpenAI({ apiKey });
    this.prisma = new PrismaClient();
    this.cache = new Map();
  }

  async reviewPullRequest(
    repoUrl: string,
    prNumber: number,
    files: ChangedFile[]
  ): Promise<CodeReviewResult> {
    const cacheKey = `${repoUrl}-${prNumber}`;

    if (this.cache.has(cacheKey)) {
      return this.cache.get(cacheKey)!;
    }

    const reviews = await Promise.all(
      files.map(file => this.reviewFile(file))
    );

    const aggregatedResult = this.aggregateReviews(reviews);

    await this.saveReviewToDatabase(repoUrl, prNumber, aggregatedResult);

    this.cache.set(cacheKey, aggregatedResult);

    return aggregatedResult;
  }

  private async reviewFile(file: ChangedFile): Promise<CodeReviewResult> {
    const prompt = this.buildReviewPrompt(file);

    const [aiAnalysis, staticAnalysis] = await Promise.all([
      this.performAIAnalysis(prompt, file.language),
      this.performStaticAnalysis(file)
    ]);

    return this.mergeAnalysisResults(aiAnalysis, staticAnalysis);
  }

  private buildReviewPrompt(file: ChangedFile): string {
    return `Perform a comprehensive code review of this ${file.language} file.

Context:
- File: ${file.path}
- Changes: ${file.additions} additions, ${file.deletions} deletions
- Commit Message: ${file.commitMessage}

Code:
\`\`\`${file.language}
${file.content}
\`\`\`

Previous Version:
\`\`\`${file.language}
${file.previousContent}
\`\`\`

Analyze for:
1. **Logic Errors & Bugs**: Race conditions, null pointers, off-by-one errors
2. **Security Vulnerabilities**: SQL injection, XSS, authentication issues, data exposure
3. **Performance Issues**: N+1 queries, inefficient algorithms, memory leaks
4. **Code Quality**: Readability, maintainability, adherence to SOLID principles
5. **Best Practices**: Design patterns, error handling, testing opportunities

Return a detailed JSON response with issues, suggestions, and metrics.`;
  }

  private async performAIAnalysis(
    prompt: string,
    language: string
  ): Promise<Partial<CodeReviewResult>> {
    const response = await this.openai.chat.completions.create({
      model: 'gpt-4-turbo',
      messages: [
        {
          role: 'system',
          content: `You are a senior software architect and security expert with 15+ years of experience.
          Specialize in ${language} development. Provide thorough, actionable feedback that helps
          developers improve code quality and security. Be specific about line numbers and provide
          concrete examples of fixes.`
        },
        { role: 'user', content: prompt }
      ],
      temperature: 0.2,
      response_format: { type: 'json_object' }
    });

    return JSON.parse(response.choices[0].message.content!);
  }

  private async performStaticAnalysis(
    file: ChangedFile
  ): Promise<Partial<CodeReviewResult>> {
    // Integration with tools like ESLint, SonarQube, Semgrep
    // This would call external static analysis tools
    return {
      metrics: this.calculateMetrics(file.content),
      issues: this.runLinters(file)
    };
  }

  private calculateMetrics(code: string): CodeMetrics {
    // Simplified implementation - production would use proper AST parsing
    const lines = code.split('\n');
    const complexity = this.calculateCyclomaticComplexity(code);

    return {
      complexity,
      maintainabilityIndex: this.calculateMaintainabilityIndex(code),
      duplicateLines: this.findDuplicateLines(lines),
      linesOfCode: lines.filter(l => l.trim().length > 0).length
    };
  }

  private calculateCyclomaticComplexity(code: string): number {
    // Count decision points: if, while, for, case, &&, ||, ?
    const patterns = [
      /\bif\b/g,
      /\bwhile\b/g,
      /\bfor\b/g,
      /\bcase\b/g,
      /&&/g,
      /\|\|/g,
      /\?/g
    ];

    let complexity = 1; // Base complexity
    patterns.forEach(pattern => {
      const matches = code.match(pattern);
      complexity += matches ? matches.length : 0;
    });

    return complexity;
  }

  private aggregateReviews(
    reviews: CodeReviewResult[]
  ): CodeReviewResult {
    const allIssues = reviews.flatMap(r => r.issues);
    const allSuggestions = reviews.flatMap(r => r.suggestions);
    const allSecurityRisks = reviews.flatMap(r => r.securityRisks);

    // Sort by severity
    const sortedIssues = allIssues.sort((a, b) => {
      const severityOrder = { critical: 0, high: 1, medium: 2, low: 3, info: 4 };
      return severityOrder[a.severity] - severityOrder[b.severity];
    });

    return {
      summary: this.generateSummary(sortedIssues, allSecurityRisks),
      issues: sortedIssues,
      suggestions: this.prioritizeSuggestions(allSuggestions),
      securityRisks: allSecurityRisks,
      metrics: this.aggregateMetrics(reviews.map(r => r.metrics)),
      confidence: this.calculateConfidence(reviews)
    };
  }

  private generateSummary(
    issues: CodeIssue[],
    risks: SecurityRisk[]
  ): string {
    const criticalIssues = issues.filter(i => i.severity === 'critical').length;
    const highIssues = issues.filter(i => i.severity === 'high').length;
    const securityIssues = risks.filter(r => r.severity === 'critical' || r.severity === 'high').length;

    if (criticalIssues > 0 || securityIssues > 0) {
      return `⚠️ CRITICAL: This PR has ${criticalIssues} critical issues and ${securityIssues} serious security vulnerabilities. Review required before merge.`;
    }

    if (highIssues > 3) {
      return `⚡ This PR needs attention: ${highIssues} high-priority issues found. Address these before merging.`;
    }

    return `✅ Code quality looks good! ${issues.length} minor suggestions for improvement.`;
  }

  async saveReviewToDatabase(
    repoUrl: string,
    prNumber: number,
    result: CodeReviewResult
  ): Promise<void> {
    await this.prisma.codeReview.create({
      data: {
        repoUrl,
        prNumber,
        summary: result.summary,
        confidence: result.confidence,
        issuesCount: result.issues.length,
        criticalIssuesCount: result.issues.filter(i => i.severity === 'critical').length,
        securityRisksCount: result.securityRisks.length,
        complexityScore: result.metrics.complexity,
        reviewedAt: new Date()
      }
    });
  }
}

// Initialize the reviewer
const reviewer = new AICodeReviewer(process.env.OPENAI_API_KEY!);

// Review a pull request
const result = await reviewer.reviewPullRequest(
  'https://github.com/company/project',
  1234,
  changedFiles
);

// Display results
console.log(result.summary);
console.log(`\nFound ${result.issues.length} issues:`);

result.issues.forEach(issue => {
  const icon = {
    critical: '🔴',
    high: '🟠',
    medium: '🟡',
    low: '🔵',
    info: '⚪'
  }[issue.severity];

  console.log(`${icon} Line ${issue.line}: [${issue.category}] ${issue.message}`);
  console.log(`   ${issue.explanation}`);

  if (issue.suggestedFix) {
    console.log(`   💡 Fix: ${issue.suggestedFix}`);
  }
});

// Security risks
if (result.securityRisks.length > 0) {
  console.log(`\n🔒 Security Risks:`);
  result.securityRisks.forEach(risk => {
    console.log(`${risk.severity.toUpperCase()}: ${risk.vulnerability}`);
    console.log(`Mitigation: ${risk.mitigation}`);
  });
}