cli/ts/mod_format/classes.formatstats.ts

import * as plugins from './mod.plugins.js';
import { logger } from '../gitzone.logging.js';

export interface IModuleStats {
  name: string;
  filesProcessed: number;
  executionTime: number;
  errors: number;
  successes: number;
  filesCreated: number;
  filesModified: number;
  filesDeleted: number;
}

export interface IFormatStats {
  totalExecutionTime: number;
  startTime: number;
  endTime: number;
  moduleStats: Map<string, IModuleStats>;
  overallStats: {
    totalFiles: number;
    totalCreated: number;
    totalModified: number;
    totalDeleted: number;
    totalErrors: number;
    cacheHits: number;
    cacheMisses: number;
  };
}

export class FormatStats {
  private stats: IFormatStats;
  
  constructor() {
    this.stats = {
      totalExecutionTime: 0,
      startTime: Date.now(),
      endTime: 0,
      moduleStats: new Map(),
      overallStats: {
        totalFiles: 0,
        totalCreated: 0,
        totalModified: 0,
        totalDeleted: 0,
        totalErrors: 0,
        cacheHits: 0,
        cacheMisses: 0
      }
    };
  }
  
  startModule(moduleName: string): void {
    this.stats.moduleStats.set(moduleName, {
      name: moduleName,
      filesProcessed: 0,
      executionTime: 0,
      errors: 0,
      successes: 0,
      filesCreated: 0,
      filesModified: 0,
      filesDeleted: 0
    });
  }
  
  moduleStartTime(moduleName: string): number {
    return Date.now();
  }
  
  endModule(moduleName: string, startTime: number): void {
    const moduleStats = this.stats.moduleStats.get(moduleName);
    if (moduleStats) {
      moduleStats.executionTime = Date.now() - startTime;
    }
  }
  
  recordFileOperation(moduleName: string, operation: 'create' | 'modify' | 'delete', success: boolean = true): void {
    const moduleStats = this.stats.moduleStats.get(moduleName);
    if (!moduleStats) return;
    
    moduleStats.filesProcessed++;
    
    if (success) {
      moduleStats.successes++;
      this.stats.overallStats.totalFiles++;
      
      switch (operation) {
        case 'create':
          moduleStats.filesCreated++;
          this.stats.overallStats.totalCreated++;
          break;
        case 'modify':
          moduleStats.filesModified++;
          this.stats.overallStats.totalModified++;
          break;
        case 'delete':
          moduleStats.filesDeleted++;
          this.stats.overallStats.totalDeleted++;
          break;
      }
    } else {
      moduleStats.errors++;
      this.stats.overallStats.totalErrors++;
    }
  }
  
  recordCacheHit(): void {
    this.stats.overallStats.cacheHits++;
  }
  
  recordCacheMiss(): void {
    this.stats.overallStats.cacheMisses++;
  }
  
  finish(): void {
    this.stats.endTime = Date.now();
    this.stats.totalExecutionTime = this.stats.endTime - this.stats.startTime;
  }
  
  displayStats(): void {
    console.log('\n📊 Format Operation Statistics:');
    console.log('═'.repeat(50));
    
    // Overall stats
    console.log('\nOverall Summary:');
    console.log(`  Total Execution Time: ${this.formatDuration(this.stats.totalExecutionTime)}`);
    console.log(`  Files Processed: ${this.stats.overallStats.totalFiles}`);
    console.log(`    • Created: ${this.stats.overallStats.totalCreated}`);
    console.log(`    • Modified: ${this.stats.overallStats.totalModified}`);
    console.log(`    • Deleted: ${this.stats.overallStats.totalDeleted}`);
    console.log(`  Errors: ${this.stats.overallStats.totalErrors}`);
    
    if (this.stats.overallStats.cacheHits > 0 || this.stats.overallStats.cacheMisses > 0) {
      const cacheHitRate = this.stats.overallStats.cacheHits / 
        (this.stats.overallStats.cacheHits + this.stats.overallStats.cacheMisses) * 100;
      console.log(`  Cache Hit Rate: ${cacheHitRate.toFixed(1)}%`);
      console.log(`    • Hits: ${this.stats.overallStats.cacheHits}`);
      console.log(`    • Misses: ${this.stats.overallStats.cacheMisses}`);
    }
    
    // Module stats
    console.log('\nModule Breakdown:');
    console.log('─'.repeat(50));
    
    const sortedModules = Array.from(this.stats.moduleStats.values())
      .sort((a, b) => b.filesProcessed - a.filesProcessed);
    
    for (const moduleStats of sortedModules) {
      console.log(`\n${this.getModuleIcon(moduleStats.name)} ${moduleStats.name}:`);
      console.log(`  Execution Time: ${this.formatDuration(moduleStats.executionTime)}`);
      console.log(`  Files Processed: ${moduleStats.filesProcessed}`);
      
      if (moduleStats.filesCreated > 0) {
        console.log(`    • Created: ${moduleStats.filesCreated}`);
      }
      if (moduleStats.filesModified > 0) {
        console.log(`    • Modified: ${moduleStats.filesModified}`);
      }
      if (moduleStats.filesDeleted > 0) {
        console.log(`    • Deleted: ${moduleStats.filesDeleted}`);
      }
      
      if (moduleStats.errors > 0) {
        console.log(`  ❌ Errors: ${moduleStats.errors}`);
      }
    }
    
    console.log('\n' + '═'.repeat(50));
  }
  
  async saveReport(outputPath: string): Promise<void> {
    const report = {
      timestamp: new Date().toISOString(),
      executionTime: this.stats.totalExecutionTime,
      overallStats: this.stats.overallStats,
      moduleStats: Array.from(this.stats.moduleStats.values())
    };
    
    await plugins.smartfile.memory.toFs(JSON.stringify(report, null, 2), outputPath);
    logger.log('info', `Statistics report saved to ${outputPath}`);
  }
  
  private formatDuration(ms: number): string {
    if (ms < 1000) {
      return `${ms}ms`;
    } else if (ms < 60000) {
      return `${(ms / 1000).toFixed(1)}s`;
    } else {
      const minutes = Math.floor(ms / 60000);
      const seconds = Math.floor((ms % 60000) / 1000);
      return `${minutes}m ${seconds}s`;
    }
  }
  
  private getModuleIcon(module: string): string {
    const icons: Record<string, string> = {
      'packagejson': '📦',
      'license': '📝',
      'tsconfig': '🔧',
      'cleanup': '🚮',
      'gitignore': '🔒',
      'prettier': '✨',
      'readme': '📖',
      'templates': '📄',
      'npmextra': '⚙️',
      'copy': '📋'
    };
    return icons[module] || '📁';
  }
}