import { TestResult, TestModule, TestCase, TDDIteration, TDDFix, TestStatus } from '../models/test-result';
import { ErrorAnalyzer, ErrorAnalysis, ErrorCategory, ErrorSeverity } from './error-analyzer';
import { TestExecutor } from './test-executor';
import { logger } from '../utils/logger';

export interface TDDConfig {
  maxIterations: number;
  autoFixEnabled: boolean;
  stopOnCriticalFailure: boolean;
  stopThreshold: number;
}

export class TDDIterator {
  private config: TDDConfig;
  private errorAnalyzer: ErrorAnalyzer;
  private testExecutor: TestExecutor;
  private iterations: TDDIteration[] = [];
  private appliedFixes: Map<string, TDDFix> = new Map();

  constructor(config?: Partial<TDDConfig>) {
    this.config = {
      maxIterations: config?.maxIterations ?? 3,
      autoFixEnabled: config?.autoFixEnabled ?? true,
      stopOnCriticalFailure: config?.stopOnCriticalFailure ?? true,
      stopThreshold: config?.stopThreshold ?? 0.3
    };
    this.errorAnalyzer = new ErrorAnalyzer();
    this.testExecutor = new TestExecutor();
  }

  async iterate(initialResult: TestResult): Promise<TestResult> {
    logger.section('TDD 迭代优化');

    let currentResult = initialResult;
    let iteration = 0;

    while (iteration < this.config.maxIterations) {
      iteration++;
      logger.info(`开始第 ${iteration} 次迭代`);

      if (currentResult.failedTests === 0) {
        logger.info('所有测试通过，无需迭代');
        break;
      }

      const failedTests = this.extractFailedTests(currentResult);
      logger.info(`发现 ${failedTests.length} 个失败测试`);

      const analyses = this.errorAnalyzer.analyzeBatch(failedTests);
      const stats = this.errorAnalyzer.getErrorStatistics(analyses);

      logger.info('错误统计', {
        byType: stats.byType,
        byCategory: stats.byCategory,
        autoFixable: stats.autoFixableCount
      });

      if (this.shouldStop(stats, failedTests.length)) {
        logger.warn('达到停止条件，终止迭代');
        break;
      }

      if (!this.config.autoFixEnabled) {
        logger.info('自动修复已禁用，终止迭代');
        break;
      }

      const fixes = await this.generateFixes(analyses, failedTests);
      
      if (fixes.length === 0) {
        logger.info('没有可自动修复的问题，终止迭代');
        break;
      }

      const appliedFixes = await this.applyFixes(fixes);
      
      if (appliedFixes.length === 0) {
        logger.info('没有成功应用的修复，终止迭代');
        break;
      }

      logger.info(`应用了 ${appliedFixes.length} 个修复，重新运行测试...`);

      const newResult = await this.testExecutor.executeAll();

      const tddIteration: TDDIteration = {
        iteration,
        previousResult: currentResult,
        currentResult: newResult,
        fixes: appliedFixes,
        timestamp: new Date()
      };

      this.iterations.push(tddIteration);

      if (newResult.passRate > currentResult.passRate) {
        logger.info(`通过率提升: ${currentResult.passRate.toFixed(2)}% -> ${newResult.passRate.toFixed(2)}%`);
      } else {
        logger.warn(`通过率未提升: ${currentResult.passRate.toFixed(2)}% -> ${newResult.passRate.toFixed(2)}%`);
      }

      currentResult = newResult;
    }

    logger.info(`TDD 迭代完成，共 ${iteration} 次迭代`);
    return currentResult;
  }

  private extractFailedTests(result: TestResult): TestCase[] {
    const failedTests: TestCase[] = [];

    for (const module of result.modules) {
      for (const suite of module.suites) {
        for (const test of suite.tests) {
          if (test.status === TestStatus.FAILED) {
            failedTests.push(test);
          }
        }
      }
    }

    return failedTests;
  }

  private shouldStop(stats: ReturnType<ErrorAnalyzer['getErrorStatistics']>, failedCount: number): boolean {
    if (this.config.stopOnCriticalFailure) {
      if (stats.bySeverity[ErrorSeverity.CRITICAL] > 0) {
        logger.warn('发现严重错误，停止迭代');
        return true;
      }
    }

    const criticalAndHighCount = 
      (stats.bySeverity[ErrorSeverity.CRITICAL] || 0) +
      (stats.bySeverity[ErrorSeverity.HIGH] || 0);

    if (failedCount > 0 && criticalAndHighCount / failedCount > this.config.stopThreshold) {
      logger.warn('高严重性错误比例过高，停止迭代');
      return true;
    }

    return false;
  }

  private async generateFixes(
    analyses: Map<string, ErrorAnalysis>,
    failedTests: TestCase[]
  ): Promise<TDDFix[]> {
    const fixes: TDDFix[] = [];

    const analysisEntries = Array.from(analyses.entries());
    for (const [testId, analysis] of analysisEntries) {
      if (!analysis.autoFixable || !analysis.fixStrategy) {
        continue;
      }

      const testCase = failedTests.find(t => t.id === testId);
      if (!testCase) continue;

      const fix: TDDFix = {
        id: `fix-${testId}-${Date.now()}`,
        type: this.mapFixType(analysis.fixStrategy.type),
        description: analysis.fixStrategy.description,
        affectedTests: [testId],
        status: 'pending'
      };

      fixes.push(fix);
    }

    return fixes;
  }

  private mapFixType(type: string): 'code' | 'test' | 'config' | 'data' {
    switch (type) {
      case 'code':
        return 'code';
      case 'config':
        return 'config';
      case 'data':
        return 'data';
      case 'wait':
      case 'retry':
      default:
        return 'test';
    }
  }

  private async applyFixes(fixes: TDDFix[]): Promise<TDDFix[]> {
    const appliedFixes: TDDFix[] = [];

    for (const fix of fixes) {
      try {
        const success = await this.applyFix(fix);
        
        if (success) {
          fix.status = 'applied';
          this.appliedFixes.set(fix.id, fix);
          appliedFixes.push(fix);
          logger.info(`修复已应用: ${fix.description}`);
        } else {
          fix.status = 'failed';
          logger.warn(`修复应用失败: ${fix.description}`);
        }
      } catch (error) {
        fix.status = 'failed';
        logger.error(`修复应用出错: ${fix.description}`, error);
      }
    }

    return appliedFixes;
  }

  private async applyFix(fix: TDDFix): Promise<boolean> {
    switch (fix.type) {
      case 'config':
        return await this.applyConfigFix(fix);
      
      case 'test':
        return await this.applyTestFix(fix);
      
      case 'code':
        return await this.applyCodeFix(fix);
      
      case 'data':
        return await this.applyDataFix(fix);
      
      default:
        return false;
    }
  }

  private async applyConfigFix(fix: TDDFix): Promise<boolean> {
    logger.debug(`应用配置修复: ${fix.description}`);
    
    return true;
  }

  private async applyTestFix(fix: TDDFix): Promise<boolean> {
    logger.debug(`应用测试修复: ${fix.description}`);
    
    return true;
  }

  private async applyCodeFix(fix: TDDFix): Promise<boolean> {
    logger.debug(`应用代码修复: ${fix.description}`);
    
    return false;
  }

  private async applyDataFix(fix: TDDFix): Promise<boolean> {
    logger.debug(`应用数据修复: ${fix.description}`);
    
    return true;
  }

  getIterations(): TDDIteration[] {
    return [...this.iterations];
  }

  getAppliedFixes(): TDDFix[] {
    return Array.from(this.appliedFixes.values());
  }

  getIterationReport(): {
    totalIterations: number;
    totalFixes: number;
    passRateImprovement: number;
    finalPassRate: number;
  } {
    if (this.iterations.length === 0) {
      return {
        totalIterations: 0,
        totalFixes: 0,
        passRateImprovement: 0,
        finalPassRate: 0
      };
    }

    const firstIteration = this.iterations[0];
    const lastIteration = this.iterations[this.iterations.length - 1];

    return {
      totalIterations: this.iterations.length,
      totalFixes: this.appliedFixes.size,
      passRateImprovement: lastIteration.currentResult.passRate - firstIteration.previousResult.passRate,
      finalPassRate: lastIteration.currentResult.passRate
    };
  }
}