import { test, expect } from '@playwright/test';
import { TestCoverageReporter, testCoverageReporter } from '../core/test-coverage-reporter';

test.describe('TestCoverageReporter - 测试覆盖率报告生成器', () => {
  
  test('应该能够初始化覆盖率报告器', () => {
    const reporter = new TestCoverageReporter();
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(0);
    expect(coverage.passedTests).toBe(0);
    expect(coverage.failedTests).toBe(0);
    expect(coverage.skippedTests).toBe(0);
    expect(coverage.passRate).toBe(0);
    expect(coverage.testSuites).toHaveLength(0);
  });

  test('应该能够记录测试结果', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('LoginTests', '登录功能测试', 'passed', 1000, ['@smoke', '@critical'], 'login.spec.ts');
    reporter.recordTestResult('LoginTests', '登出功能测试', 'passed', 500, ['@smoke'], 'login.spec.ts');
    reporter.recordTestResult('LoginTests', '权限验证测试', 'failed', 2000, ['@critical'], 'login.spec.ts');
    reporter.recordTestResult('LoginTests', '表单验证测试', 'skipped', 0, ['@normal'], 'login.spec.ts');
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(4);
    expect(coverage.passedTests).toBe(2);
    expect(coverage.failedTests).toBe(1);
    expect(coverage.skippedTests).toBe(1);
    expect(coverage.passRate).toBe(50);
    expect(coverage.testSuites).toHaveLength(1);
  });

  test('应该能够计算套件覆盖率', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('LoginTests', '测试1', 'passed', 1000, ['@smoke'], 'login.spec.ts');
    reporter.recordTestResult('LoginTests', '测试2', 'passed', 1000, ['@smoke'], 'login.spec.ts');
    reporter.recordTestResult('DashboardTests', '测试1', 'passed', 1000, ['@regression'], 'dashboard.spec.ts');
    reporter.recordTestResult('DashboardTests', '测试2', 'failed', 1000, ['@regression'], 'dashboard.spec.ts');
    reporter.recordTestResult('UserManagementTests', '测试1', 'passed', 1000, ['@full'], 'user.spec.ts');
    reporter.recordTestResult('UserManagementTests', '测试2', 'passed', 1000, ['@full'], 'user.spec.ts');
    reporter.recordTestResult('UserManagementTests', '测试3', 'skipped', 0, ['@full'], 'user.spec.ts');
    
    const coverage = reporter.getCoverage();
    const loginSuite = coverage.testSuites.find(s => s.name === 'LoginTests');
    const dashboardSuite = coverage.testSuites.find(s => s.name === 'DashboardTests');
    const userManagementSuite = coverage.testSuites.find(s => s.name === 'UserManagementTests');
    
    expect(loginSuite).toBeDefined();
    expect(loginSuite?.totalTests).toBe(2);
    expect(loginSuite?.passedTests).toBe(2);
    expect(loginSuite?.failedTests).toBe(0);
    expect(loginSuite?.skippedTests).toBe(0);
    expect(loginSuite?.passRate).toBe(100);
    
    expect(dashboardSuite).toBeDefined();
    expect(dashboardSuite?.totalTests).toBe(2);
    expect(dashboardSuite?.passedTests).toBe(1);
    expect(dashboardSuite?.failedTests).toBe(1);
    expect(dashboardSuite?.skippedTests).toBe(0);
    expect(dashboardSuite?.passRate).toBe(50);
    
    expect(userManagementSuite).toBeDefined();
    expect(userManagementSuite?.totalTests).toBe(3);
    expect(userManagementSuite?.passedTests).toBe(2);
    expect(userManagementSuite?.failedTests).toBe(0);
    expect(userManagementSuite?.skippedTests).toBe(1);
    expect(userManagementSuite?.passRate).toBeCloseTo(66.67, 2);
  });

  test('应该能够生成JSON格式报告', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('TestSuite', '测试用例', 'passed', 1000, ['@smoke'], 'test.spec.ts');
    
    const jsonReport = reporter.exportCoverage('json');
    const coverageData = JSON.parse(jsonReport);
    
    expect(coverageData).toHaveProperty('totalTests');
    expect(coverageData).toHaveProperty('passedTests');
    expect(coverageData).toHaveProperty('failedTests');
    expect(coverageData).toHaveProperty('skippedTests');
    expect(coverageData).toHaveProperty('passRate');
    expect(coverageData).toHaveProperty('testSuites');
    expect(coverageData).toHaveProperty('executionTime');
    expect(coverageData).toHaveProperty('timestamp');
  });

  test('应该能够生成HTML格式报告', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('TestSuite', '测试用例', 'passed', 1000, ['@smoke'], 'test.spec.ts');
    
    const htmlReport = reporter.exportCoverage('html');
    
    expect(htmlReport).toContain('<!DOCTYPE html>');
    expect(htmlReport).toContain('<html');
    expect(htmlReport).toContain('测试覆盖率报告');
    expect(htmlReport).toContain('总测试数');
    expect(htmlReport).toContain('通过测试');
    expect(htmlReport).toContain('失败测试');
    expect(htmlReport).toContain('跳过测试');
    expect(htmlReport).toContain('通过率');
  });

  test('应该能够生成Markdown格式报告', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('TestSuite', '测试用例', 'passed', 1000, ['@smoke'], 'test.spec.ts');
    
    const markdownReport = reporter.exportCoverage('markdown');
    
    expect(markdownReport).toContain('# 测试覆盖率报告');
    expect(markdownReport).toContain('## 概要');
    expect(markdownReport).toContain('总测试数');
    expect(markdownReport).toContain('通过测试');
    expect(markdownReport).toContain('失败测试');
    expect(markdownReport).toContain('跳过测试');
    expect(markdownReport).toContain('通过率');
  });

  test('应该能够获取套件覆盖率', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('LoginTests', '测试1', 'passed', 1000, ['@smoke'], 'login.spec.ts');
    reporter.recordTestResult('LoginTests', '测试2', 'passed', 1000, ['@smoke'], 'login.spec.ts');
    reporter.recordTestResult('DashboardTests', '测试1', 'passed', 1000, ['@regression'], 'dashboard.spec.ts');
    
    const loginSuite = reporter.getSuiteCoverage('LoginTests');
    const dashboardSuite = reporter.getSuiteCoverage('DashboardTests');
    const nonExistentSuite = reporter.getSuiteCoverage('NonExistentTests');
    
    expect(loginSuite).toBeDefined();
    expect(loginSuite?.name).toBe('LoginTests');
    expect(loginSuite?.totalTests).toBe(2);
    
    expect(dashboardSuite).toBeDefined();
    expect(dashboardSuite?.name).toBe('DashboardTests');
    expect(dashboardSuite?.totalTests).toBe(1);
    
    expect(nonExistentSuite).toBeUndefined();
  });

  test('应该能够处理空测试结果', () => {
    const reporter = new TestCoverageReporter();
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(0);
    expect(coverage.passedTests).toBe(0);
    expect(coverage.failedTests).toBe(0);
    expect(coverage.skippedTests).toBe(0);
    expect(coverage.passRate).toBe(0);
    expect(coverage.testSuites).toHaveLength(0);
  });

  test('应该能够处理全部通过的测试', () => {
    const reporter = new TestCoverageReporter();
    
    for (let i = 0; i < 10; i++) {
      reporter.recordTestResult('TestSuite', `测试${i}`, 'passed', 1000, ['@smoke'], 'test.spec.ts');
    }
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(10);
    expect(coverage.passedTests).toBe(10);
    expect(coverage.failedTests).toBe(0);
    expect(coverage.skippedTests).toBe(0);
    expect(coverage.passRate).toBe(100);
  });

  test('应该能够处理全部失败的测试', () => {
    const reporter = new TestCoverageReporter();
    
    for (let i = 0; i < 5; i++) {
      reporter.recordTestResult('TestSuite', `测试${i}`, 'failed', 1000, ['@critical'], 'test.spec.ts');
    }
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(5);
    expect(coverage.passedTests).toBe(0);
    expect(coverage.failedTests).toBe(5);
    expect(coverage.skippedTests).toBe(0);
    expect(coverage.passRate).toBe(0);
  });

  test('应该能够处理全部跳过的测试', () => {
    const reporter = new TestCoverageReporter();
    
    for (let i = 0; i < 3; i++) {
      reporter.recordTestResult('TestSuite', `测试${i}`, 'skipped', 0, ['@normal'], 'test.spec.ts');
    }
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(3);
    expect(coverage.passedTests).toBe(0);
    expect(coverage.failedTests).toBe(0);
    expect(coverage.skippedTests).toBe(3);
    expect(coverage.passRate).toBe(0);
  });

  test('应该能够处理混合状态的测试', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('TestSuite', '测试1', 'passed', 1000, ['@smoke'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '测试2', 'failed', 2000, ['@critical'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '测试3', 'skipped', 0, ['@normal'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '测试4', 'passed', 1500, ['@regression'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '测试5', 'failed', 3000, ['@regression'], 'test.spec.ts');
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(5);
    expect(coverage.passedTests).toBe(2);
    expect(coverage.failedTests).toBe(2);
    expect(coverage.skippedTests).toBe(1);
    expect(coverage.passRate).toBe(40);
  });

  test('应该能够正确计算执行时间', async () => {
    const reporter = new TestCoverageReporter();
    
    reporter.startCoverage();
    
    await new Promise(resolve => setTimeout(resolve, 100));
    
    reporter.recordTestResult('TestSuite', '测试1', 'passed', 50, ['@smoke'], 'test.spec.ts');
    
    await new Promise(resolve => setTimeout(resolve, 100));
    
    reporter.recordTestResult('TestSuite', '测试2', 'passed', 50, ['@smoke'], 'test.spec.ts');
    
    reporter.endCoverage();
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.executionTime).toBeGreaterThan(200);
    expect(coverage.executionTime).toBeLessThan(500);
  });

  test('应该能够处理多个测试套件', () => {
    const reporter = new TestCoverageReporter();
    
    const suites = ['LoginTests', 'DashboardTests', 'UserManagementTests', 'RoleManagementTests', 'MenuManagementTests'];
    
    suites.forEach((suite, index) => {
      reporter.recordTestResult(suite, `测试${index + 1}`, 'passed', 1000, ['@smoke'], `${suite.toLowerCase()}.spec.ts`);
    });
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(5);
    expect(coverage.testSuites).toHaveLength(5);
    expect(coverage.passRate).toBe(100);
    
    coverage.testSuites.forEach(suite => {
      expect(suite.totalTests).toBe(1);
      expect(suite.passedTests).toBe(1);
      expect(suite.failedTests).toBe(0);
      expect(suite.skippedTests).toBe(0);
      expect(suite.passRate).toBe(100);
    });
  });

  test('应该能够处理不同标签的测试', () => {
    const reporter = new TestCoverageReporter();
    
    reporter.recordTestResult('TestSuite', '冒烟测试', 'passed', 1000, ['@smoke'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '回归测试', 'passed', 1000, ['@regression'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '完整测试', 'passed', 1000, ['@full'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '关键测试', 'passed', 1000, ['@critical'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '普通测试', 'passed', 1000, ['@normal'], 'test.spec.ts');
    reporter.recordTestResult('TestSuite', '无标签测试', 'passed', 1000, [], 'test.spec.ts');
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(6);
    expect(coverage.passedTests).toBe(6);
    
    const testCases = coverage.testSuites[0].tests;
    expect(testCases[0].tags).toEqual(['@smoke']);
    expect(testCases[1].tags).toEqual(['@regression']);
    expect(testCases[2].tags).toEqual(['@full']);
    expect(testCases[3].tags).toEqual(['@critical']);
    expect(testCases[4].tags).toEqual(['@normal']);
    expect(testCases[5].tags).toEqual([]);
  });

  test('应该能够处理长测试名称', () => {
    const reporter = new TestCoverageReporter();
    
    const longName = '这是一个非常非常非常长的测试用例名称，用于测试系统是否能够正确处理长名称的情况';
    reporter.recordTestResult('TestSuite', longName, 'passed', 1000, ['@smoke'], 'test.spec.ts');
    
    const coverage = reporter.getCoverage();
    const testCase = coverage.testSuites[0].tests[0];
    
    expect(testCase.name).toBe(longName);
    expect(testCase.name.length).toBeGreaterThan(50);
  });

  test('应该能够处理特殊字符的测试名称', () => {
    const reporter = new TestCoverageReporter();
    
    const specialNames = ['测试<test>', '测试"test"', '测试\'test\'', '测试&test&', '测试#test#'];
    
    specialNames.forEach((name, index) => {
      reporter.recordTestResult('TestSuite', name, 'passed', 1000, ['@smoke'], 'test.spec.ts');
    });
    
    const coverage = reporter.getCoverage();
    
    expect(coverage.totalTests).toBe(5);
    expect(coverage.passedTests).toBe(5);
    
    coverage.testSuites[0].tests.forEach((testCase, index) => {
      expect(testCase.name).toBe(specialNames[index]);
    });
  });
});