// Deliberate Technical Debt - Conscious shortcuts for speed
class QuickOrderProcessor {
  // TODO: TECH DEBT - Hardcoded tax calculation for MVP
  // Ticket: ORD-123 - Implement proper tax service integration
  // Priority: High (target: Sprint 15)
  // Effort: 3 story points
  calculateTax(amount: number, region: string): number {
    return amount * 0.08; // Hardcoded 8% tax rate
  }

  // Deliberate simplification - will need proper error handling
  async processOrder(order: Order): Promise<void> {
    try {
      await this.orderService.create(order);
      // TODO: Add retry logic, dead letter queue, and monitoring
    } catch (error) {
      console.error('Order processing failed:', error);
      throw error; // Simplified error handling for now
    }
  }
}

// Inadvertent Technical Debt - Code that accumulated over time
class LegacyUserService {
  // Multiple responsibilities - violates SRP
  async processUser(userData: any): Promise<any> {
    // Validation logic mixed with business logic
    if (!userData.email || !userData.email.includes('@')) {
      throw new Error('Invalid email');
    }

    // Direct database access in service layer
    const user = await this.db.query('INSERT INTO users...');
    
    // Email sending logic in wrong place
    await this.emailService.sendWelcomeEmail(user.email);
    
    // Audit logging mixed with business logic
    await this.auditLogger.log('User created', user.id);
    
    return user;
  }
}

interface TechnicalDebtItem {
  id: string;
  type: DebtType;
  severity: DebtSeverity;
  component: string;
  description: string;
  impact: DebtImpact;
  effort: EstimatedEffort;
  createdAt: Date;
  targetResolutionDate?: Date;
  businessJustification?: string;
}

enum DebtType {
  DESIGN_DEBT = 'design_debt',           // Architectural issues
  CODE_DEBT = 'code_debt',               // Code quality issues
  TEST_DEBT = 'test_debt',               // Missing or inadequate tests
  DOCUMENTATION_DEBT = 'doc_debt',       // Missing documentation
  INFRASTRUCTURE_DEBT = 'infra_debt',    // Infrastructure shortcuts
  DEPENDENCY_DEBT = 'dependency_debt'     // Outdated dependencies
}

enum DebtSeverity {
  CRITICAL = 'critical',    // Blocks development or causes outages
  HIGH = 'high',           // Significantly impacts velocity
  MEDIUM = 'medium',       // Moderate impact on development
  LOW = 'low'              // Minor inconvenience
}

interface DebtImpact {
  developmentVelocity: number;    // 1-10 scale
  maintenanceCost: number;        // 1-10 scale
  riskToProduction: number;       // 1-10 scale
  teamMorale: number;             // 1-10 scale
}

interface EstimatedEffort {
  storyPoints: number;
  engineeringDays: number;
  riskLevel: 'low' | 'medium' | 'high';
  dependencies: string[];
}

class TechnicalDebtTracker {
  private debtItems: Map<string, TechnicalDebtItem> = new Map();

  addDebtItem(item: Omit<TechnicalDebtItem, 'id' | 'createdAt'>): string {
    const id = this.generateId();
    const debtItem: TechnicalDebtItem = {
      ...item,
      id,
      createdAt: new Date()
    };

    this.debtItems.set(id, debtItem);
    this.notifyTeam(debtItem);
    
    return id;
  }

  prioritizeDebt(): TechnicalDebtItem[] {
    const items = Array.from(this.debtItems.values());
    
    return items.sort((a, b) => {
      // Calculate priority score based on impact vs effort
      const scoreA = this.calculatePriorityScore(a);
      const scoreB = this.calculatePriorityScore(b);
      
      return scoreB - scoreA; // Higher score = higher priority
    });
  }

  private calculatePriorityScore(item: TechnicalDebtItem): number {
    const impact = (
      item.impact.developmentVelocity +
      item.impact.maintenanceCost +
      item.impact.riskToProduction +
      item.impact.teamMorale
    ) / 4;

    const effortMultiplier = item.effort.storyPoints <= 3 ? 1.5 : 
                           item.effort.storyPoints <= 8 ? 1.0 : 0.5;

    const severityMultiplier = {
      [DebtSeverity.CRITICAL]: 3.0,
      [DebtSeverity.HIGH]: 2.0,
      [DebtSeverity.MEDIUM]: 1.0,
      [DebtSeverity.LOW]: 0.5
    }[item.severity];

    return impact * effortMultiplier * severityMultiplier;
  }

  generateDebtReport(): DebtReport {
    const items = Array.from(this.debtItems.values());
    
    return {
      totalItems: items.length,
      byType: this.groupByType(items),
      bySeverity: this.groupBySeverity(items),
      totalEffort: items.reduce((sum, item) => sum + item.effort.storyPoints, 0),
      averageAge: this.calculateAverageAge(items),
      trends: this.calculateTrends(items)
    };
  }

  private generateId(): string {
    return `DEBT-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
  }

  private notifyTeam(item: TechnicalDebtItem): void {
    if (item.severity === DebtSeverity.CRITICAL) {
      // Send immediate notification for critical debt
      console.log(`🚨 CRITICAL Technical Debt Added: ${item.description}`);
    }
  }

  private groupByType(items: TechnicalDebtItem[]): Record<DebtType, number> {
    return items.reduce((acc, item) => {
      acc[item.type] = (acc[item.type] || 0) + 1;
      return acc;
    }, {} as Record<DebtType, number>);
  }

  private groupBySeverity(items: TechnicalDebtItem[]): Record<DebtSeverity, number> {
    return items.reduce((acc, item) => {
      acc[item.severity] = (acc[item.severity] || 0) + 1;
      return acc;
    }, {} as Record<DebtSeverity, number>);
  }

  private calculateAverageAge(items: TechnicalDebtItem[]): number {
    if (items.length === 0) return 0;
    
    const now = new Date();
    const totalAge = items.reduce((sum, item) => {
      const ageInDays = (now.getTime() - item.createdAt.getTime()) / (1000 * 60 * 60 * 24);
      return sum + ageInDays;
    }, 0);

    return totalAge / items.length;
  }

  private calculateTrends(items: TechnicalDebtItem[]): DebtTrends {
    // Implementation for trend analysis
    return {
      creationRate: 0, // Items created per week
      resolutionRate: 0, // Items resolved per week
      netChange: 0 // Net change in debt items
    };
  }
}

interface DebtReport {
  totalItems: number;
  byType: Record<DebtType, number>;
  bySeverity: Record<DebtSeverity, number>;
  totalEffort: number;
  averageAge: number;
  trends: DebtTrends;
}

interface DebtTrends {
  creationRate: number;
  resolutionRate: number;
  netChange: number;
}

// ESLint custom rules for debt detection
import { ESLintUtils } from '@typescript-eslint/utils';

const createRule = ESLintUtils.RuleCreator(
  name => `https://your-docs.com/eslint-rules/${name}`
);

// Detect overly complex functions
export const complexityDebtRule = createRule({
  name: 'complexity-debt',
  meta: {
    type: 'suggestion',
    docs: {
      description: 'Detect functions with high cyclomatic complexity',
      recommended: 'error'
    },
    messages: {
      tooComplex: 'Function "{{name}}" has complexity {{complexity}}, consider refactoring (threshold: {{threshold}})'
    },
    schema: [{
      type: 'object',
      properties: {
        threshold: { type: 'number', minimum: 1 }
      },
      additionalProperties: false
    }]
  },
  defaultOptions: [{ threshold: 10 }],
  create(context, [options]) {
    const threshold = options.threshold;

    function analyzeComplexity(node: any): number {
      // Simplified complexity calculation
      let complexity = 1; // Base complexity

      // Add complexity for control structures
      const complexityNodes = [
        'IfStatement', 'ConditionalExpression', 'SwitchCase',
        'ForStatement', 'ForInStatement', 'ForOfStatement',
        'WhileStatement', 'DoWhileStatement',
        'LogicalExpression'
      ];

      function traverse(node: any): void {
        if (complexityNodes.includes(node.type)) {
          complexity++;
        }
        
        if (node.children) {
          node.children.forEach(traverse);
        }
      }

      traverse(node);
      return complexity;
    }

    return {
      FunctionDeclaration(node) {
        const complexity = analyzeComplexity(node);
        
        if (complexity > threshold) {
          context.report({
            node,
            messageId: 'tooComplex',
            data: {
              name: node.id?.name || 'anonymous',
              complexity: complexity.toString(),
              threshold: threshold.toString()
            }
          });
        }
      }
    };
  }
});

// Detect outdated TODO comments
export const todoDebtRule = createRule({
  name: 'todo-debt',
  meta: {
    type: 'suggestion',
    docs: {
      description: 'Track TODO comments as technical debt',
      recommended: 'warn'
    },
    messages: {
      oldTodo: 'TODO comment is {{days}} days old: {{comment}}',
      untracked: 'TODO comment should include ticket reference: {{comment}}'
    },
    schema: [{
      type: 'object',
      properties: {
        maxAge: { type: 'number', minimum: 1 }
      },
      additionalProperties: false
    }]
  },
  defaultOptions: [{ maxAge: 30 }],
  create(context, [options]) {
    const maxAge = options.maxAge;
    const sourceCode = context.getSourceCode();

    return {
      Program() {
        const comments = sourceCode.getAllComments();
        
        comments.forEach(comment => {
          const todoMatch = comment.value.match(/TODO:?\s*(.+)/i);
          if (!todoMatch) return;

          const todoText = todoMatch[1].trim();
          
          // Check if TODO has ticket reference
          const hasTicket = /(?:TICKET|ISSUE|JIRA|#)\s*[A-Z]+-\d+/i.test(todoText);
          if (!hasTicket) {
            context.report({
              node: comment as any,
              messageId: 'untracked',
              data: { comment: todoText }
            });
            return;
          }

          // Check age (would need additional tooling to track creation date)
          // This is a simplified example
          const ageInDays = this.calculateCommentAge(comment);
          if (ageInDays > maxAge) {
            context.report({
              node: comment as any,
              messageId: 'oldTodo',
              data: {
                days: ageInDays.toString(),
                comment: todoText
              }
            });
          }
        });
      }
    };
  }
});

import * as fs from 'fs';
import * as path from 'path';
import { Project, SourceFile } from 'ts-morph';

interface CodeMetrics {
  file: string;
  linesOfCode: number;
  cyclomaticComplexity: number;
  functionCount: number;
  classCount: number;
  duplicateBlocks: number;
  testCoverage: number;
  lastModified: Date;
  maintainabilityIndex: number;
}

class CodeMetricsCollector {
  private project: Project;

  constructor(tsConfigPath: string) {
    this.project = new Project({
      tsConfigFilePath: tsConfigPath
    });
  }

  collectMetrics(): CodeMetrics[] {
    const sourceFiles = this.project.getSourceFiles();
    return sourceFiles.map(file => this.analyzeFile(file));
  }

  private analyzeFile(sourceFile: SourceFile): CodeMetrics {
    const filePath = sourceFile.getFilePath();
    
    return {
      file: filePath,
      linesOfCode: this.calculateLinesOfCode(sourceFile),
      cyclomaticComplexity: this.calculateCyclomaticComplexity(sourceFile),
      functionCount: sourceFile.getFunctions().length,
      classCount: sourceFile.getClasses().length,
      duplicateBlocks: this.detectDuplication(sourceFile),
      testCoverage: this.getTestCoverage(filePath),
      lastModified: this.getLastModified(filePath),
      maintainabilityIndex: this.calculateMaintainabilityIndex(sourceFile)
    };
  }

  private calculateLinesOfCode(sourceFile: SourceFile): number {
    const text = sourceFile.getFullText();
    const lines = text.split('\n');
    
    // Count non-empty, non-comment lines
    return lines.filter(line => {
      const trimmed = line.trim();
      return trimmed.length > 0 && 
             !trimmed.startsWith('//') && 
             !trimmed.startsWith('/*') && 
             !trimmed.startsWith('*');
    }).length;
  }

  private calculateCyclomaticComplexity(sourceFile: SourceFile): number {
    let complexity = 0;

    sourceFile.getFunctions().forEach(func => {
      complexity += this.analyzeComplexity(func);
    });

    sourceFile.getClasses().forEach(cls => {
      cls.getMethods().forEach(method => {
        complexity += this.analyzeComplexity(method);
      });
    });

    return complexity;
  }

  private analyzeComplexity(node: any): number {
    let complexity = 1; // Base complexity

    node.forEachDescendant((descendant: any) => {
      const kind = descendant.getKind();
      
      // Decision points that increase complexity
      if ([
        'IfStatement', 'ConditionalExpression', 'SwitchStatement',
        'ForStatement', 'ForInStatement', 'ForOfStatement',
        'WhileStatement', 'DoWhileStatement', 'CatchClause',
        'ConditionalExpression'
      ].includes(kind)) {
        complexity++;
      }
    });

    return complexity;
  }

  private detectDuplication(sourceFile: SourceFile): number {
    // Simplified duplication detection
    const text = sourceFile.getFullText();
    const lines = text.split('\n').map(line => line.trim()).filter(line => line.length > 10);
    
    const duplicates = new Set<string>();
    const seen = new Set<string>();

    lines.forEach(line => {
      if (seen.has(line)) {
        duplicates.add(line);
      } else {
        seen.add(line);
      }
    });

    return duplicates.size;
  }

  private getTestCoverage(filePath: string): number {
    // Integration with coverage tools (Istanbul, Jest, etc.)
    // This would typically read from coverage reports
    try {
      const coverageData = this.readCoverageData();
      return coverageData[filePath]?.percentage || 0;
    } catch {
      return 0;
    }
  }

  private getLastModified(filePath: string): Date {
    try {
      const stats = fs.statSync(filePath);
      return stats.mtime;
    } catch {
      return new Date();
    }
  }

  private calculateMaintainabilityIndex(sourceFile: SourceFile): number {
    // Simplified maintainability index calculation
    const loc = this.calculateLinesOfCode(sourceFile);
    const complexity = this.calculateCyclomaticComplexity(sourceFile);
    const halsteadVolume = this.calculateHalsteadVolume(sourceFile);

    // Microsoft's maintainability index formula (simplified)
    const mi = Math.max(0, 
      171 - 5.2 * Math.log(halsteadVolume) - 0.23 * complexity - 16.2 * Math.log(loc)
    );

    return Math.round(mi);
  }

  private calculateHalsteadVolume(sourceFile: SourceFile): number {
    // Simplified Halstead volume calculation
    const text = sourceFile.getFullText();
    const operators = text.match(/[+\-*/=<>!&|?:;,(){}[\]]/g) || [];
    const operands = text.match(/\b[a-zA-Z_][a-zA-Z0-9_]*\b/g) || [];
    
    const n1 = new Set(operators).size; // Unique operators
    const n2 = new Set(operands).size;  // Unique operands
    const N1 = operators.length;        // Total operators
    const N2 = operands.length;         // Total operands

    const n = n1 + n2;
    const N = N1 + N2;

    return N * Math.log2(n) || 1;
  }

  private readCoverageData(): Record<string, { percentage: number }> {
    // Read from coverage report file
    try {
      const coverageFile = path.join(process.cwd(), 'coverage', 'coverage-summary.json');
      const data = JSON.parse(fs.readFileSync(coverageFile, 'utf8'));
      return data;
    } catch {
      return {};
    }
  }

  generateTechnicalDebtReport(metrics: CodeMetrics[]): TechnicalDebtReport {
    const highComplexityFiles = metrics.filter(m => m.cyclomaticComplexity > 15);
    const lowCoverageFiles = metrics.filter(m => m.testCoverage < 70);
    const lowMaintainabilityFiles = metrics.filter(m => m.maintainabilityIndex < 60);
    const staleMaintainance = metrics.filter(m => {
      const daysSinceModified = (Date.now() - m.lastModified.getTime()) / (1000 * 60 * 60 * 24);
      return daysSinceModified > 180; // 6 months
    });

    return {
      totalFiles: metrics.length,
      averageComplexity: metrics.reduce((sum, m) => sum + m.cyclomaticComplexity, 0) / metrics.length,
      averageCoverage: metrics.reduce((sum, m) => sum + m.testCoverage, 0) / metrics.length,
      averageMaintainability: metrics.reduce((sum, m) => sum + m.maintainabilityIndex, 0) / metrics.length,
      problemAreas: {
        highComplexity: highComplexityFiles.map(f => f.file),
        lowCoverage: lowCoverageFiles.map(f => f.file),
        lowMaintainability: lowMaintainabilityFiles.map(f => f.file),
        staleMaintenance: staleMaintainance.map(f => f.file)
      },
      recommendations: this.generateRecommendations(metrics)
    };
  }

  private generateRecommendations(metrics: CodeMetrics[]): string[] {
    const recommendations: string[] = [];

    if (metrics.some(m => m.cyclomaticComplexity > 20)) {
      recommendations.push('Consider refactoring functions with complexity > 20 using Extract Method pattern');
    }

    if (metrics.some(m => m.testCoverage < 50)) {
      recommendations.push('Prioritize adding tests to files with coverage < 50%');
    }

    if (metrics.some(m => m.duplicateBlocks > 5)) {
      recommendations.push('Extract common code blocks into reusable functions');
    }

    return recommendations;
  }
}

interface TechnicalDebtReport {
  totalFiles: number;
  averageComplexity: number;
  averageCoverage: number;
  averageMaintainability: number;
  problemAreas: {
    highComplexity: string[];
    lowCoverage: string[];
    lowMaintainability: string[];
    staleMaintenance: string[];
  };
  recommendations: string[];
}

// Strategy Pattern for gradual migration
interface PaymentProcessor {
  processPayment(amount: number, currency: string): Promise<PaymentResult>;
}

class LegacyPaymentProcessor implements PaymentProcessor {
  async processPayment(amount: number, currency: string): Promise<PaymentResult> {
    // Legacy implementation
    return { success: true, transactionId: 'legacy-123' };
  }
}

class ModernPaymentProcessor implements PaymentProcessor {
  async processPayment(amount: number, currency: string): Promise<PaymentResult> {
    // New implementation with better error handling, monitoring, etc.
    return { success: true, transactionId: 'modern-456' };
  }
}

class PaymentService {
  private processors: Map<string, PaymentProcessor> = new Map();
  private migrationConfig: MigrationConfig;

  constructor(migrationConfig: MigrationConfig) {
    this.migrationConfig = migrationConfig;
    this.processors.set('legacy', new LegacyPaymentProcessor());
    this.processors.set('modern', new ModernPaymentProcessor());
  }

  async processPayment(userId: string, amount: number, currency: string): Promise<PaymentResult> {
    const processorType = this.selectProcessor(userId);
    const processor = this.processors.get(processorType)!;

    try {
      const result = await processor.processPayment(amount, currency);
      
      // Track migration metrics
      this.trackMigrationMetrics(processorType, true);
      
      return result;
    } catch (error) {
      this.trackMigrationMetrics(processorType, false);
      
      // Fallback to legacy if modern fails during migration
      if (processorType === 'modern' && this.migrationConfig.fallbackOnError) {
        console.warn('Modern processor failed, falling back to legacy');
        return this.processors.get('legacy')!.processPayment(amount, currency);
      }
      
      throw error;
    }
  }

  private selectProcessor(userId: string): string {
    // Gradual rollout based on user cohorts
    const userHash = this.hashUserId(userId);
    const migrationPercentage = this.migrationConfig.rolloutPercentage;
    
    return userHash % 100 < migrationPercentage ? 'modern' : 'legacy';
  }

  private hashUserId(userId: string): number {
    // Simple hash function for consistent user assignment
    let hash = 0;
    for (let i = 0; i < userId.length; i++) {
      const char = userId.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash; // Convert to 32-bit integer
    }
    return Math.abs(hash);
  }

  private trackMigrationMetrics(processorType: string, success: boolean): void {
    // Send metrics to monitoring system
    console.log(`Payment processor: ${processorType}, success: ${success}`);
  }
}

interface MigrationConfig {
  rolloutPercentage: number; // 0-100
  fallbackOnError: boolean;
}

interface PaymentResult {
  success: boolean;
  transactionId: string;
  error?: string;
}

// Gradual replacement of legacy system
class StranglerFigProxy {
  private legacyService: LegacyUserService;
  private modernService: ModernUserService;
  private routingConfig: RoutingConfig;

  constructor(
    legacyService: LegacyUserService,
    modernService: ModernUserService,
    routingConfig: RoutingConfig
  ) {
    this.legacyService = legacyService;
    this.modernService = modernService;
    this.routingConfig = routingConfig;
  }

  async getUser(userId: string): Promise<User> {
    const route = this.determineRoute('getUser', userId);
    
    if (route === 'modern') {
      try {
        return await this.modernService.getUser(userId);
      } catch (error) {
        if (this.routingConfig.fallbackToLegacy) {
          console.warn('Modern service failed, falling back to legacy');
          return await this.legacyService.getUser(userId);
        }
        throw error;
      }
    }

    return await this.legacyService.getUser(userId);
  }

  async createUser(userData: CreateUserRequest): Promise<User> {
    const route = this.determineRoute('createUser', userData.email);

    if (route === 'modern') {
      try {
        const user = await this.modernService.createUser(userData);
        
        // Dual write during migration phase
        if (this.routingConfig.dualWrite) {
          try {
            await this.legacyService.createUser(userData);
          } catch (error) {
            console.warn('Legacy dual write failed:', error);
            // Don't fail the operation if dual write fails
          }
        }
        
        return user;
      } catch (error) {
        if (this.routingConfig.fallbackToLegacy) {
          return await this.legacyService.createUser(userData);
        }
        throw error;
      }
    }

    const user = await this.legacyService.createUser(userData);
    
    // Forward write to modern system for data sync
    if (this.routingConfig.forwardWrite) {
      try {
        await this.modernService.createUser(userData);
      } catch (error) {
        console.warn('Forward write to modern service failed:', error);
      }
    }

    return user;
  }

  async updateUser(userId: string, updates: Partial<User>): Promise<User> {
    const route = this.determineRoute('updateUser', userId);

    if (route === 'modern') {
      const user = await this.modernService.updateUser(userId, updates);
      
      // Keep legacy in sync during migration
      if (this.routingConfig.syncToLegacy) {
        try {
          await this.legacyService.updateUser(userId, updates);
        } catch (error) {
          console.warn('Legacy sync failed:', error);
        }
      }
      
      return user;
    }

    const user = await this.legacyService.updateUser(userId, updates);
    
    // Sync to modern system
    if (this.routingConfig.syncToModern) {
      try {
        await this.modernService.updateUser(userId, updates);
      } catch (error) {
        console.warn('Modern sync failed:', error);
      }
    }

    return user;
  }

  private determineRoute(operation: string, identifier: string): 'legacy' | 'modern' {
    const config = this.routingConfig.operationRouting[operation];
    if (!config) return 'legacy';

    // Feature flag based routing
    if (config.featureFlag && !this.isFeatureEnabled(config.featureFlag)) {
      return 'legacy';
    }

    // Percentage based routing
    if (config.modernPercentage) {
      const hash = this.hashIdentifier(identifier);
      return hash % 100 < config.modernPercentage ? 'modern' : 'legacy';
    }

    // User whitelist based routing
    if (config.whitelistedUsers?.includes(identifier)) {
      return 'modern';
    }

    return 'legacy';
  }

  private isFeatureEnabled(featureFlag: string): boolean {
    // Check feature flag service
    return process.env[`FEATURE_${featureFlag}`] === 'true';
  }

  private hashIdentifier(identifier: string): number {
    let hash = 0;
    for (let i = 0; i < identifier.length; i++) {
      const char = identifier.charCodeAt(i);
      hash = ((hash << 5) - hash) + char;
      hash = hash & hash;
    }
    return Math.abs(hash);
  }
}

interface RoutingConfig {
  fallbackToLegacy: boolean;
  dualWrite: boolean;
  forwardWrite: boolean;
  syncToLegacy: boolean;
  syncToModern: boolean;
  operationRouting: Record<string, OperationRoutingConfig>;
}

interface OperationRoutingConfig {
  modernPercentage?: number;
  featureFlag?: string;
  whitelistedUsers?: string[];
}

class RefactoringSession {
  private startTime: Date;
  private timeBoxMinutes: number;
  private changesLog: RefactoringChange[] = [];

  constructor(timeBoxMinutes: number = 25) { // Pomodoro technique
    this.timeBoxMinutes = timeBoxMinutes;
    this.startTime = new Date();
  }

  async executeRefactoring<T>(
    description: string,
    refactoringFunction: () => Promise<T>
  ): Promise<T> {
    const changeStartTime = new Date();
    
    if (this.isTimeBoxExpired()) {
      throw new Error(`Time box expired. Consider continuing in next session.`);
    }

    try {
      const result = await refactoringFunction();
      
      this.changesLog.push({
        description,
        startTime: changeStartTime,
        endTime: new Date(),
        success: true,
        linesChanged: await this.calculateLinesChanged()
      });

      return result;
    } catch (error) {
      this.changesLog.push({
        description,
        startTime: changeStartTime,
        endTime: new Date(),
        success: false,
        error: error instanceof Error ? error.message : 'Unknown error'
      });
      throw error;
    }
  }

  generateSessionReport(): RefactoringSessionReport {
    const endTime = new Date();
    const duration = endTime.getTime() - this.startTime.getTime();
    
    return {
      sessionDuration: duration,
      changesAttempted: this.changesLog.length,
      successfulChanges: this.changesLog.filter(c => c.success).length,
      totalLinesChanged: this.changesLog.reduce((sum, c) => sum + (c.linesChanged || 0), 0),
      timeBoxUtilization: (duration / (this.timeBoxMinutes * 60 * 1000)) * 100,
      changes: this.changesLog
    };
  }

  private isTimeBoxExpired(): boolean {
    const elapsed = new Date().getTime() - this.startTime.getTime();
    return elapsed > (this.timeBoxMinutes * 60 * 1000);
  }

  private async calculateLinesChanged(): Promise<number> {
    // In a real implementation, this would integrate with Git
    // to calculate actual lines changed since session start
    return Math.floor(Math.random() * 50) + 1;
  }
}

interface RefactoringChange {
  description: string;
  startTime: Date;
  endTime: Date;
  success: boolean;
  linesChanged?: number;
  error?: string;
}

interface RefactoringSessionReport {
  sessionDuration: number;
  changesAttempted: number;
  successfulChanges: number;
  totalLinesChanged: number;
  timeBoxUtilization: number;
  changes: RefactoringChange[];
}

// Usage example
async function refactorUserService(): Promise<void> {
  const session = new RefactoringSession(25); // 25-minute time box

  try {
    await session.executeRefactoring(
      'Extract validation logic to separate class',
      async () => {
        // Refactoring implementation
        await extractValidationLogic();
      }
    );

    await session.executeRefactoring(
      'Remove duplicate error handling code',
      async () => {
        await consolidateErrorHandling();
      }
    );

    await session.executeRefactoring(
      'Add missing unit tests',
      async () => {
        await addMissingTests();
      }
    );

  } finally {
    const report = session.generateSessionReport();
    console.log('Refactoring session complete:', report);
    
    // Log to tracking system
    await logRefactoringSession(report);
  }
}

// Automatic code improvement during regular development
class BoyScoutRule {
  private improvementTracker: Map<string, number> = new Map();

  async applyBoyScoutRule(
    filePath: string,
    originalFunction: () => Promise<void>
  ): Promise<void> {
    const fileContent = await this.readFile(filePath);
    const originalMetrics = this.analyzeCode(fileContent);

    // Execute the original development task
    await originalFunction();

    // Apply small improvements
    const improvements = await this.identifySmallImprovements(filePath);
    
    for (const improvement of improvements) {
      if (improvement.effort <= 5) { // Only small improvements (max 5 minutes)
        try {
          await this.applyImprovement(improvement);
          this.trackImprovement(filePath, improvement);
        } catch (error) {
          console.warn(`Failed to apply improvement: ${improvement.description}`, error);
        }
      }
    }

    const newFileContent = await this.readFile(filePath);
    const newMetrics = this.analyzeCode(newFileContent);
    
    this.reportImprovements(filePath, originalMetrics, newMetrics);
  }

  private async identifySmallImprovements(filePath: string): Promise<Improvement[]> {
    const improvements: Improvement[] = [];
    const content = await this.readFile(filePath);

    // Check for simple improvements
    if (content.includes('console.log(')) {
      improvements.push({
        type: 'remove-console-logs',
        description: 'Remove console.log statements',
        effort: 2,
        impact: 'low'
      });
    }

    if (content.includes('any;') || content.includes(': any')) {
      improvements.push({
        type: 'add-types',
        description: 'Replace any types with specific types',
        effort: 5,
        impact: 'medium'
      });
    }

    if (this.detectMagicNumbers(content)) {
      improvements.push({
        type: 'extract-constants',
        description: 'Extract magic numbers to named constants',
        effort: 3,
        impact: 'medium'
      });
    }

    if (this.detectDuplicatedCode(content)) {
      improvements.push({
        type: 'extract-function',
        description: 'Extract duplicated code to function',
        effort: 4,
        impact: 'high'
      });
    }

    return improvements;
  }

  private async applyImprovement(improvement: Improvement): Promise<void> {
    switch (improvement.type) {
      case 'remove-console-logs':
        await this.removeConsoleLogs();
        break;
      case 'add-types':
        await this.addMissingTypes();
        break;
      case 'extract-constants':
        await this.extractMagicNumbers();
        break;
      case 'extract-function':
        await this.extractDuplicatedCode();
        break;
    }
  }

  private trackImprovement(filePath: string, improvement: Improvement): void {
    const key = `${filePath}:${improvement.type}`;
    const count = this.improvementTracker.get(key) || 0;
    this.improvementTracker.set(key, count + 1);
  }

  private reportImprovements(
    filePath: string,
    before: CodeMetrics,
    after: CodeMetrics
  ): void {
    const improvements = {
      complexityReduction: before.cyclomaticComplexity - after.cyclomaticComplexity,
      lineReduction: before.linesOfCode - after.linesOfCode,
      maintainabilityImprovement: after.maintainabilityIndex - before.maintainabilityIndex
    };

    if (improvements.complexityReduction > 0 || 
        improvements.maintainabilityImprovement > 0) {
      console.log(`🧹 Boy Scout Rule applied to ${filePath}:`, improvements);
    }
  }

  private detectMagicNumbers(content: string): boolean {
    // Detect numeric literals that aren't 0, 1, or -1
    const magicNumberRegex = /\b(?<![\w.])\d{2,}\b(?![\w.])/g;
    return magicNumberRegex.test(content);
  }

  private detectDuplicatedCode(content: string): boolean {
    // Simple duplication detection
    const lines = content.split('\n').map(line => line.trim()).filter(line => line.length > 5);
    const seen = new Set<string>();
    
    for (const line of lines) {
      if (seen.has(line)) {
        return true;
      }
      seen.add(line);
    }
    
    return false;
  }

  private async readFile(filePath: string): Promise<string> {
    // File reading implementation
    return '';
  }

  private analyzeCode(content: string): CodeMetrics {
    // Code analysis implementation
    return {
      file: '',
      linesOfCode: 0,
      cyclomaticComplexity: 0,
      functionCount: 0,
      classCount: 0,
      duplicateBlocks: 0,
      testCoverage: 0,
      lastModified: new Date(),
      maintainabilityIndex: 0
    };
  }

  private async removeConsoleLogs(): Promise<void> {
    // Implementation to remove console.log statements
  }

  private async addMissingTypes(): Promise<void> {
    // Implementation to add TypeScript types
  }

  private async extractMagicNumbers(): Promise<void> {
    // Implementation to extract magic numbers to constants
  }

  private async extractDuplicatedCode(): Promise<void> {
    // Implementation to extract duplicated code
  }
}

interface Improvement {
  type: string;
  description: string;
  effort: number; // minutes
  impact: 'low' | 'medium' | 'high';
}

interface DefinitionOfDone {
  codeQuality: CodeQualityChecks;
  testing: TestingChecks;
  documentation: DocumentationChecks;
  performance: PerformanceChecks;
  security: SecurityChecks;
}

interface CodeQualityChecks {
  lintingPassed: boolean;
  codeReviewCompleted: boolean;
  complexityWithinLimits: boolean;
  noHardcodedValues: boolean;
  errorHandlingImplemented: boolean;
  loggingAdded: boolean;
}

interface TestingChecks {
  unitTestsWritten: boolean;
  integrationTestsWritten: boolean;
  coverageThresholdMet: boolean;
  edgeCasesConsidered: boolean;
  performanceTestsConsidered: boolean;
}

interface DocumentationChecks {
  apiDocumentationUpdated: boolean;
  readmeUpdated: boolean;
  architectureDocumentUpdated: boolean;
  troubleshootingGuideUpdated: boolean;
}

interface PerformanceChecks {
  performanceImpactAssessed: boolean;
  loadTestingConsidered: boolean;
  monitoringImplemented: boolean;
  alertsConfigured: boolean;
}

interface SecurityChecks {
  securityReviewCompleted: boolean;
  vulnerabilitiesScanned: boolean;
  sensitiveDataProtected: boolean;
  authenticationImplemented: boolean;
}

class DefinitionOfDoneValidator {
  async validateDefinitionOfDone(
    pullRequestId: string,
    workItem: WorkItem
  ): Promise<DefinitionOfDoneResult> {
    const checks: DefinitionOfDone = {
      codeQuality: await this.validateCodeQuality(pullRequestId),
      testing: await this.validateTesting(pullRequestId),
      documentation: await this.validateDocumentation(pullRequestId, workItem),
      performance: await this.validatePerformance(pullRequestId, workItem),
      security: await this.validateSecurity(pullRequestId)
    };

    const violations = this.findViolations(checks);
    
    return {
      passed: violations.length === 0,
      violations,
      checks,
      score: this.calculateComplianceScore(checks)
    };
  }

  private async validateCodeQuality(pullRequestId: string): Promise<CodeQualityChecks> {
    return {
      lintingPassed: await this.checkLintingStatus(pullRequestId),
      codeReviewCompleted: await this.checkCodeReviewStatus(pullRequestId),
      complexityWithinLimits: await this.checkComplexityLimits(pullRequestId),
      noHardcodedValues: await this.checkForHardcodedValues(pullRequestId),
      errorHandlingImplemented: await this.checkErrorHandling(pullRequestId),
      loggingAdded: await this.checkLoggingImplementation(pullRequestId)
    };
  }

  private async validateTesting(pullRequestId: string): Promise<TestingChecks> {
    return {
      unitTestsWritten: await this.checkUnitTests(pullRequestId),
      integrationTestsWritten: await this.checkIntegrationTests(pullRequestId),
      coverageThresholdMet: await this.checkCoverageThreshold(pullRequestId),
      edgeCasesConsidered: await this.checkEdgeCases(pullRequestId),
      performanceTestsConsidered: await this.checkPerformanceTests(pullRequestId)
    };
  }

  private async validateDocumentation(
    pullRequestId: string, 
    workItem: WorkItem
  ): Promise<DocumentationChecks> {
    return {
      apiDocumentationUpdated: await this.checkApiDocumentation(pullRequestId, workItem),
      readmeUpdated: await this.checkReadmeUpdates(pullRequestId, workItem),
      architectureDocumentUpdated: await this.checkArchitectureDocuments(pullRequestId, workItem),
      troubleshootingGuideUpdated: await this.checkTroubleshootingGuide(pullRequestId, workItem)
    };
  }

  private findViolations(checks: DefinitionOfDone): string[] {
    const violations: string[] = [];

    // Check code quality violations
    if (!checks.codeQuality.lintingPassed) {
      violations.push('Linting checks must pass before merge');
    }
    if (!checks.codeQuality.codeReviewCompleted) {
      violations.push('Code review must be completed by at least one senior developer');
    }
    if (!checks.codeQuality.complexityWithinLimits) {
      violations.push('Code complexity exceeds acceptable limits');
    }

    // Check testing violations
    if (!checks.testing.unitTestsWritten) {
      violations.push('Unit tests must be written for new functionality');
    }
    if (!checks.testing.coverageThresholdMet) {
      violations.push('Code coverage must meet the 80% threshold');
    }

    // Check documentation violations
    if (!checks.documentation.apiDocumentationUpdated) {
      violations.push('API documentation must be updated for public API changes');
    }

    return violations;
  }

  private calculateComplianceScore(checks: DefinitionOfDone): number {
    const allChecks = [
      ...Object.values(checks.codeQuality),
      ...Object.values(checks.testing),
      ...Object.values(checks.documentation),
      ...Object.values(checks.performance),
      ...Object.values(checks.security)
    ];

    const passedChecks = allChecks.filter(check => check).length;
    return Math.round((passedChecks / allChecks.length) * 100);
  }

  // Implementation stubs for various checks
  private async checkLintingStatus(pullRequestId: string): Promise<boolean> {
    // Check CI/CD pipeline for linting results
    return true;
  }

  private async checkCodeReviewStatus(pullRequestId: string): Promise<boolean> {
    // Check if code review is completed
    return true;
  }

  private async checkComplexityLimits(pullRequestId: string): Promise<boolean> {
    // Check if complexity metrics are within limits
    return true;
  }

  // ... other check implementations
}

interface WorkItem {
  id: string;
  type: 'feature' | 'bug' | 'refactor' | 'chore';
  affectsPublicApi: boolean;
  requiresDocumentation: boolean;
}

interface DefinitionOfDoneResult {
  passed: boolean;
  violations: string[];
  checks: DefinitionOfDone;
  score: number;
}