// ============================================================================
// Agent 4: Test Writer
// Generates actual test files based on strategy and analysis
// ============================================================================

import * as path from 'path';
import {
  AgentState, GeneratedTest, TestPlan, TestType, ModuleInfo, ApiEndpoint, TestRunner,
} from '../types';
import { readFileContent, writeFileContent, ensureDir } from '../utils/file-utils';
import { analyzeParameterUsage, extractNamedFunctionBody, ParameterUsageInfo } from '../utils/parser';
import { logger } from '../utils/logger';

// ============================================================================
// Test Runner Abstraction Layer
// Generates the correct syntax for Jest, Vitest, or Node:test
// ============================================================================

interface RunnerSyntax {
  imports: string[];
  mockFn: string;         // jest.fn() | vi.fn()
  mockModule: string;     // jest.mock | vi.mock
  clearMocks: string;     // jest.clearAllMocks() | vi.clearAllMocks()
  setTimeout: string;     // jest.setTimeout(n) | vi.setConfig({ testTimeout: n })
  spyOn: string;          // jest.spyOn | vi.spyOn
}

function getRunnerSyntax(runner: TestRunner): RunnerSyntax {
  switch (runner) {
    case 'vitest':
      return {
        imports: ["import { describe, it, expect, vi, beforeEach, afterEach, beforeAll, afterAll } from 'vitest';"],
        mockFn: 'vi.fn()',
        mockModule: 'vi.mock',
        clearMocks: 'vi.clearAllMocks()',
        setTimeout: 'vi.setConfig({ testTimeout: $TIMEOUT$ })',
        spyOn: 'vi.spyOn',
      };
    case 'node':
      return {
        imports: [
          "import { describe, it, before, after, beforeEach, afterEach } from 'node:test';",
          "import assert from 'node:assert/strict';",
        ],
        mockFn: '() => {}',
        mockModule: '// node:test mock',
        clearMocks: '// node:test - no global mock clearing needed',
        setTimeout: '// timeout set via --test-timeout CLI flag',
        spyOn: '// node:test - use mock.method()',
      };
    case 'jest':
    default:
      return {
        imports: [],  // Jest globals are available without import
        mockFn: 'jest.fn()',
        mockModule: 'jest.mock',
        clearMocks: 'jest.clearAllMocks()',
        setTimeout: 'jest.setTimeout($TIMEOUT$)',
        spyOn: 'jest.spyOn',
      };
  }
}

export async function writerAgent(state: AgentState): Promise<Partial<AgentState>> {
  const startTime = Date.now();
  logger.agentStart('writer');

  try {
    if (!state.testStrategy || !state.codeAnalysis) {
      throw new Error('Test strategy not available. Strategy Agent must run first.');
    }

    const outputDir = path.resolve(state.projectPath, state.config.outputDir);
    ensureDir(outputDir);
    ensureDir(path.join(outputDir, 'unit'));
    ensureDir(path.join(outputDir, 'integration'));
    ensureDir(path.join(outputDir, 'e2e'));
    ensureDir(path.join(outputDir, 'security'));
    ensureDir(path.join(outputDir, 'performance'));

    // Check if this is a retry — if reviewer sent back failed tests, only rewrite those
    const isRetry = state.testReviews.length > 0 && state.generatedTests.length > 0;
    const failedTestFiles = new Set(
      state.testReviews.filter(r => !r.passed).map(r => r.testFile)
    );

    if (isRetry && failedTestFiles.size > 0) {
      logger.agent('writer', `Retry: rewriting ${failedTestFiles.size} failed test files with improved assertions...`);
    }

    // Keep passing tests from previous run
    const generatedTests: GeneratedTest[] = isRetry
      ? state.generatedTests.filter(t => !failedTestFiles.has(t.filePath))
      : [];

    // Helper: check if a plan's test file needs (re)generation
    function needsGeneration(testFilePath: string): boolean {
      if (!isRetry) return true;
      return failedTestFiles.has(testFilePath);
    }

    // Helper: get test file path for a plan (to check against failed list)
    function getUnitTestPath(plan: TestPlan): string {
      const targetBaseName = path.basename(plan.targetFile, path.extname(plan.targetFile));
      return path.join(outputDir, 'unit', `${targetBaseName}.test.ts`);
    }
    function getIntegrationTestPath(plan: TestPlan): string {
      const targetBaseName = path.basename(plan.targetFile, path.extname(plan.targetFile));
      return path.join(outputDir, 'integration', `${targetBaseName}.integration.test.ts`);
    }

    // 1. Generate Unit Tests
    logger.agent('writer', 'Writing unit tests...');
    for (const plan of state.testStrategy.unitTests) {
      const testPath = getUnitTestPath(plan);
      if (!needsGeneration(testPath)) continue;
      const test = generateUnitTest(plan, state, outputDir);
      if (test) {
        generatedTests.push(test);
        writeFileContent(test.filePath, test.content);
      }
    }
    logger.agent('writer', `${generatedTests.filter(t => t.testType === 'unit').length} unit test files written`);

    // 2. Generate Integration Tests
    logger.agent('writer', 'Writing integration tests...');
    const integrationBefore = generatedTests.length;
    for (const plan of state.testStrategy.integrationTests) {
      const testPath = getIntegrationTestPath(plan);
      if (!needsGeneration(testPath)) continue;
      const test = generateIntegrationTest(plan, state, outputDir);
      if (test) {
        generatedTests.push(test);
        writeFileContent(test.filePath, test.content);
      }
    }
    logger.agent('writer', `${generatedTests.length - integrationBefore} integration test files written`);

    // 3. Generate E2E Tests
    logger.agent('writer', 'Writing E2E tests...');
    const e2eBefore = generatedTests.length;
    for (const plan of state.testStrategy.e2eTests) {
      const test = generateE2ETest(plan, state, outputDir);
      if (test) {
        // On retry, only regenerate failed E2E tests
        if (isRetry && !failedTestFiles.has(test.filePath)) continue;
        generatedTests.push(test);
        writeFileContent(test.filePath, test.content);
      }
    }
    logger.agent('writer', `${generatedTests.length - e2eBefore} E2E test files written`);

    // 4. Generate Security Tests
    logger.agent('writer', 'Writing security tests...');
    const secBefore = generatedTests.length;
    for (const plan of state.testStrategy.securityTests) {
      const test = generateSecurityTest(plan, state, outputDir);
      if (test) {
        if (isRetry && !failedTestFiles.has(test.filePath)) continue;
        generatedTests.push(test);
        writeFileContent(test.filePath, test.content);
      }
    }
    logger.agent('writer', `${generatedTests.length - secBefore} security test files written`);

    // 5. Generate Performance Tests
    logger.agent('writer', 'Writing performance tests...');
    const perfBefore = generatedTests.length;
    for (const plan of state.testStrategy.performanceTests) {
      const test = generatePerformanceTest(plan, state, outputDir);
      if (test) {
        if (isRetry && !failedTestFiles.has(test.filePath)) continue;
        generatedTests.push(test);
        writeFileContent(test.filePath, test.content);
      }
    }
    logger.agent('writer', `${generatedTests.length - perfBefore} performance test files written`);

    // 6. Generate test setup/helpers and runner config
    generateTestSetup(outputDir, state);
    generateTestRunnerConfig(state.projectPath, state);

    const totalTests = generatedTests.reduce((sum, t) => sum + t.testCount, 0);

    logger.table(
      ['Type', 'Files', 'Tests'],
      [
        ['Unit', String(generatedTests.filter(t => t.testType === 'unit').length), String(generatedTests.filter(t => t.testType === 'unit').reduce((s, t) => s + t.testCount, 0))],
        ['Integration', String(generatedTests.filter(t => t.testType === 'integration').length), String(generatedTests.filter(t => t.testType === 'integration').reduce((s, t) => s + t.testCount, 0))],
        ['E2E', String(generatedTests.filter(t => t.testType === 'e2e').length), String(generatedTests.filter(t => t.testType === 'e2e').reduce((s, t) => s + t.testCount, 0))],
        ['Security', String(generatedTests.filter(t => t.testType === 'security').length), String(generatedTests.filter(t => t.testType === 'security').reduce((s, t) => s + t.testCount, 0))],
        ['Performance', String(generatedTests.filter(t => t.testType === 'performance').length), String(generatedTests.filter(t => t.testType === 'performance').reduce((s, t) => s + t.testCount, 0))],
        ['TOTAL', String(generatedTests.length), String(totalTests)],
      ]
    );

    logger.agentComplete('writer', Date.now() - startTime);

    return {
      generatedTests,
      agentLog: [
        ...state.agentLog,
        {
          agent: 'writer',
          timestamp: new Date().toISOString(),
          action: 'Tests written',
          details: `${generatedTests.length} files, ${totalTests} tests`,
          duration: Date.now() - startTime,
          status: 'complete',
        },
      ],
    };
  } catch (error) {
    const errMsg = error instanceof Error ? error.message : String(error);
    logger.agentError('writer', errMsg);
    return {
      errors: [...state.errors, `Writer: ${errMsg}`],
      agentLog: [
        ...state.agentLog,
        {
          agent: 'writer',
          timestamp: new Date().toISOString(),
          action: 'Error',
          details: errMsg,
          status: 'error',
        },
      ],
    };
  }
}

// ============================================================================
// Unit Test Generator
// ============================================================================

function generateUnitTest(plan: TestPlan, state: AgentState, outputDir: string): GeneratedTest | null {
  const mod = state.codeAnalysis!.modules.find(m => m.filePath === plan.targetFile);
  if (!mod) return null;

  const runner = state.config.testRunner;
  const syntax = getRunnerSyntax(runner);

  const targetBaseName = path.basename(plan.targetFile, path.extname(plan.targetFile));
  const testFileName = `${targetBaseName}.test.ts`;
  const testFilePath = path.join(outputDir, 'unit', testFileName);
  const relativeSrc = path.relative(path.join(outputDir, 'unit'), plan.targetFile).replace(/\\/g, '/').replace(/\.(ts|js)$/, '');

  const lines: string[] = [];

  // Header
  lines.push(`// ===========================================================`);
  lines.push(`// Unit Tests: ${targetBaseName}`);
  lines.push(`// Auto-generated by AI Testing Suite (${runner})`);
  lines.push(`// ===========================================================`);
  lines.push('');

  // Runner imports (Vitest needs explicit imports, Jest uses globals)
  for (const imp of syntax.imports) {
    lines.push(imp);
  }
  if (syntax.imports.length > 0) lines.push('');

  // Source imports
  const exportedNames = mod.exports.map(e => e.name).filter(n => n !== 'default');
  if (mod.hasDefaultExport) {
    const defaultName = mod.exports.find(e => e.isDefault)?.name || targetBaseName;
    lines.push(`import ${defaultName !== 'default' ? defaultName : targetBaseName} from '${relativeSrc}';`);
  }
  if (exportedNames.length > 0) {
    lines.push(`import { ${exportedNames.join(', ')} } from '${relativeSrc}';`);
  }
  lines.push('');

  // Mock setup
  for (const mock of plan.mocks) {
    lines.push(`${syntax.mockModule}('${mock.module}');`);
  }
  if (plan.mocks.length > 0) lines.push('');

  // Describe block
  const describeName = plan.targetClass || plan.targetFunction || targetBaseName;
  lines.push(`describe('${describeName}', () => {`);

  // beforeEach/afterEach
  lines.push(`  beforeEach(() => {`);
  lines.push(`    ${syntax.clearMocks};`);
  lines.push(`  });`);
  lines.push('');

  // Analyze parameter usage for smart mock generation
  const paramUsageMap = new Map<string, ParameterUsageInfo>();
  if (plan.targetFunction) {
    const sourceContent = readFileContent(plan.targetFile);
    if (sourceContent) {
      const funcBody = extractNamedFunctionBody(sourceContent, plan.targetFunction);
      if (funcBody) {
        const funcObj = mod.functions.find(f => f.name === plan.targetFunction);
        const paramNames = funcObj ? funcObj.params.map(p => p.name) : [];
        if (paramNames.length > 0) {
          const usages = analyzeParameterUsage(funcBody, paramNames);
          for (const u of usages) {
            paramUsageMap.set(u.paramName, u);
          }
        }
      }
    }
  }

  // Test cases
  let testCount = 0;
  for (const tc of plan.testCases) {
    const func = plan.targetFunction ? mod.functions.find(f => f.name === plan.targetFunction) : undefined;
    const isAsync = func?.isAsync || false;

    lines.push(`  it('${tc.name}', ${isAsync ? 'async ' : ''}() => {`);

    if (plan.targetFunction && func) {
      // Function-based tests
      const callArgs = func.params.map(p => p.name).join(', ');

      switch (tc.category) {
        case 'happy-path': {
          lines.push(`    // Arrange`);
          for (const param of func.params) {
            lines.push(`    const ${param.name} = ${getSmartTestValue(param.name, param.type, 'happy-path', paramUsageMap)};`);
          }
          lines.push('');
          lines.push(`    // Act`);
          if (isAsync) {
            lines.push(`    const result = await ${func.name}(${callArgs});`);
          } else {
            lines.push(`    const result = ${func.name}(${callArgs});`);
          }
          lines.push('');
          lines.push(`    // Assert`);
          const assertions = getReturnTypeAssertions(func.returnType);
          for (const a of assertions) {
            lines.push(`    ${a}`);
          }
          break;
        }

        case 'null-undefined': {
          lines.push(`    // Arrange & Act & Assert`);
          if (func.params.length > 0) {
            const nullArgs = func.params.map((p, i) =>
              i === 0 ? 'null as any' : getSmartTestValue(p.name, p.type, 'happy-path', paramUsageMap)
            ).join(', ');
            lines.push(`    // Function should handle null gracefully or throw informative error`);
            if (isAsync) {
              lines.push(`    try {`);
              lines.push(`      const result = await ${func.name}(${nullArgs});`);
              lines.push(`      // If no throw, function handles null gracefully`);
              lines.push(`      expect(true).toBe(true);`);
              lines.push(`    } catch (error) {`);
              lines.push(`      expect(error).toBeInstanceOf(Error);`);
              lines.push(`      expect((error as Error).message).toBeTruthy();`);
              lines.push(`    }`);
            } else {
              lines.push(`    try {`);
              lines.push(`      const result = ${func.name}(${nullArgs});`);
              lines.push(`      // If no throw, function handles null gracefully`);
              lines.push(`      expect(true).toBe(true);`);
              lines.push(`    } catch (error) {`);
              lines.push(`      expect(error).toBeInstanceOf(Error);`);
              lines.push(`      expect((error as Error).message).toBeTruthy();`);
              lines.push(`    }`);
            }
          } else {
            lines.push(`    // Function takes no parameters - null/undefined not applicable`);
            if (isAsync) {
              lines.push(`    const result = await ${func.name}();`);
            } else {
              lines.push(`    const result = ${func.name}();`);
            }
            lines.push(`    expect(result).toBeDefined();`);
          }
          break;
        }

        case 'boundary': {
          lines.push(`    // Arrange - boundary values`);
          for (const param of func.params) {
            lines.push(`    const ${param.name} = ${getSmartTestValue(param.name, param.type, 'boundary', paramUsageMap)};`);
          }
          lines.push('');
          lines.push(`    // Act`);
          if (isAsync) {
            lines.push(`    const result = await ${func.name}(${callArgs});`);
          } else {
            lines.push(`    const result = ${func.name}(${callArgs});`);
          }
          lines.push('');
          lines.push(`    // Assert - boundary values should be handled without crashing`);
          const boundaryAssertions = getReturnTypeAssertions(func.returnType);
          for (const a of boundaryAssertions) {
            lines.push(`    ${a}`);
          }
          break;
        }

        case 'error-handling': {
          lines.push(`    // Arrange & Act & Assert - error handling`);
          const errorArgs = func.params.map(p => getSmartTestValue(p.name, p.type, 'error', paramUsageMap)).join(', ');
          if (isAsync) {
            lines.push(`    try {`);
            lines.push(`      await ${func.name}(${errorArgs || 'undefined as any'});`);
            lines.push(`      // If no throw, function handles error case gracefully`);
            lines.push(`    } catch (error) {`);
            lines.push(`      expect(error).toBeDefined();`);
            lines.push(`      expect(error).toBeInstanceOf(Error);`);
            lines.push(`      expect((error as Error).message).toBeTruthy();`);
            lines.push(`    }`);
          } else {
            lines.push(`    try {`);
            lines.push(`      const result = ${func.name}(${errorArgs || 'undefined as any'});`);
            lines.push(`      // If no throw, function handles error input gracefully`);
            lines.push(`      expect(result).toBeDefined();`);
            lines.push(`    } catch (error) {`);
            lines.push(`      expect(error).toBeDefined();`);
            lines.push(`      expect(error).toBeInstanceOf(Error);`);
            lines.push(`      expect((error as Error).message).toBeTruthy();`);
            lines.push(`    }`);
          }
          break;
        }

        case 'type-safety': {
          lines.push(`    // Arrange`);
          for (const param of func.params) {
            lines.push(`    const ${param.name} = ${getSmartTestValue(param.name, param.type, 'happy-path', paramUsageMap)};`);
          }
          lines.push('');
          lines.push(`    // Act`);
          if (isAsync) {
            lines.push(`    const result = await ${func.name}(${callArgs});`);
          } else {
            lines.push(`    const result = ${func.name}(${callArgs});`);
          }
          lines.push('');
          lines.push(`    // Assert - verify return type`);
          const typeAssertions = getReturnTypeAssertions(func.returnType);
          for (const a of typeAssertions) {
            lines.push(`    ${a}`);
          }
          break;
        }

        default: {
          lines.push(`    // Arrange`);
          for (const param of func.params) {
            lines.push(`    const ${param.name} = ${getSmartTestValue(param.name, param.type, tc.category, paramUsageMap)};`);
          }
          lines.push('');
          lines.push(`    // Act`);
          if (isAsync) {
            lines.push(`    const result = await ${func.name}(${callArgs});`);
          } else {
            lines.push(`    const result = ${func.name}(${callArgs});`);
          }
          lines.push('');
          lines.push(`    // Assert`);
          lines.push(`    expect(result).toBeDefined();`);
        }
      }
    } else if (plan.targetClass) {
      // Class-based tests
      const cls = mod.classes.find(c => c.name === plan.targetClass);
      lines.push(`    // Arrange`);
      lines.push(`    const instance = new ${plan.targetClass}();`);
      lines.push('');

      if (plan.targetFunction && cls) {
        const method = cls.methods.find(m => m.name === plan.targetFunction);
        if (method) {
          for (const param of method.params) {
            lines.push(`    const ${param.name} = ${getSmartTestValue(param.name, param.type, tc.category, paramUsageMap)};`);
          }
          lines.push('');
          lines.push(`    // Act`);
          const methodArgs = method.params.map(p => p.name).join(', ');
          if (method.isAsync) {
            lines.push(`    const result = await instance.${method.name}(${methodArgs});`);
          } else {
            lines.push(`    const result = instance.${method.name}(${methodArgs});`);
          }
          lines.push('');
          lines.push(`    // Assert`);
          if (tc.category === 'error-handling') {
            lines.push(`    // Error handling verified - no unhandled exception`);
            lines.push(`    expect(instance).toBeInstanceOf(${plan.targetClass});`);
          } else {
            const methodAssertions = getReturnTypeAssertions(method.returnType);
            for (const a of methodAssertions) {
              lines.push(`    ${a}`);
            }
          }
        } else {
          // Method not found by exact name — test class instantiation + check available methods
          lines.push(`    // Assert - class instantiation and method availability`);
          lines.push(`    expect(instance).toBeInstanceOf(${plan.targetClass});`);
          if (cls && cls.methods.length > 0) {
            // Assert that key methods exist on the class (filter out private-convention methods)
            for (const m of cls.methods.filter(m => !m.name.startsWith('_')).slice(0, 5)) {
              lines.push(`    expect(typeof instance.${m.name}).toBe('function');`);
            }
          } else {
            lines.push(`    expect(instance).toBeDefined();`);
            lines.push(`    expect(typeof instance).toBe('object');`);
          }
        }
      } else if (cls && cls.methods.length > 0) {
        // No specific method target — test class construction + public API
        lines.push(`    // Assert - class instance and public API`);
        lines.push(`    expect(instance).toBeInstanceOf(${plan.targetClass});`);
        for (const m of cls.methods.filter(m => !m.name.startsWith('_')).slice(0, 5)) {
          lines.push(`    expect(typeof instance.${m.name}).toBe('function');`);
        }
        // Also test properties
        for (const p of cls.properties.filter(p => p.visibility === 'public').slice(0, 3)) {
          lines.push(`    expect(instance).toHaveProperty('${p.name}');`);
        }
      } else {
        lines.push(`    // Assert`);
        lines.push(`    expect(instance).toBeInstanceOf(${plan.targetClass});`);
        lines.push(`    expect(typeof instance).toBe('object');`);
      }
    } else {
      // Fallback: function not found in module analysis, or neither function nor class target
      // Generate assertions based on available module exports
      const funcName = plan.targetFunction || targetBaseName;
      const anyExportedFunc = mod.functions.find(f => f.isExported);

      if (plan.targetFunction && mod.exports.some(e => e.name === plan.targetFunction)) {
        // Function is exported but wasn't found in parsed functions — call it and test
        lines.push(`    // Arrange`);
        lines.push(`    // Note: Function detected via exports but not fully parsed`);
        lines.push('');
        lines.push(`    // Act & Assert`);
        lines.push(`    expect(typeof ${plan.targetFunction}).toBe('function');`);
        lines.push(`    expect(${plan.targetFunction}).toBeDefined();`);
      } else if (anyExportedFunc) {
        // Test a known exported function from the module
        const f = anyExportedFunc;
        // Build usage map for this fallback function
        const fbUsageMap = new Map<string, ParameterUsageInfo>();
        const fbSource = readFileContent(plan.targetFile);
        if (fbSource) {
          const fbBody = extractNamedFunctionBody(fbSource, f.name);
          if (fbBody && f.params.length > 0) {
            const fbUsages = analyzeParameterUsage(fbBody, f.params.map(p => p.name));
            for (const u of fbUsages) fbUsageMap.set(u.paramName, u);
          }
        }
        const args = f.params.map(p => getSmartTestValue(p.name, p.type, tc.category, fbUsageMap)).join(', ');
        lines.push(`    // Arrange & Act`);
        if (f.isAsync) {
          lines.push(`    const result = await ${f.name}(${args});`);
        } else {
          lines.push(`    const result = ${f.name}(${args});`);
        }
        lines.push('');
        lines.push(`    // Assert`);
        const fallbackAssertions = getReturnTypeAssertions(f.returnType);
        for (const a of fallbackAssertions) {
          lines.push(`    ${a}`);
        }
      } else if (exportedNames.length > 0) {
        // Module has named exports — test they're defined
        lines.push(`    // Assert - verify module exports are defined`);
        for (const name of exportedNames.slice(0, 5)) {
          lines.push(`    expect(${name}).toBeDefined();`);
        }
      } else if (mod.hasDefaultExport) {
        // Module has default export only
        const defaultName = mod.exports.find(e => e.isDefault)?.name || targetBaseName;
        lines.push(`    // Assert - verify default export`);
        lines.push(`    expect(${defaultName !== 'default' ? defaultName : targetBaseName}).toBeDefined();`);
        lines.push(`    expect(typeof ${defaultName !== 'default' ? defaultName : targetBaseName}).not.toBe('undefined');`);
      } else {
        // Absolute fallback — module structure test
        lines.push(`    // Assert - module loaded successfully`);
        lines.push(`    expect(true).toBe(true); // Module imports without errors`);
      }
    }

    lines.push(`  });`);
    lines.push('');
    testCount++;
  }

  lines.push(`});`);
  lines.push('');

  return {
    filePath: testFilePath,
    content: lines.join('\n'),
    targetFile: plan.targetFile,
    testType: 'unit',
    testCount,
    categories: plan.testCases.map(tc => tc.category),
    mocks: plan.mocks.map(m => m.module),
  };
}

// ============================================================================
// Integration Test Generator
// ============================================================================

function generateIntegrationTest(plan: TestPlan, state: AgentState, outputDir: string): GeneratedTest | null {
  const runner = state.config.testRunner;
  const syntax = getRunnerSyntax(runner);

  const targetBaseName = path.basename(plan.targetFile, path.extname(plan.targetFile));
  const testFileName = `${targetBaseName}.integration.test.ts`;
  const testFilePath = path.join(outputDir, 'integration', testFileName);

  const lines: string[] = [];
  lines.push(`// ===========================================================`);
  lines.push(`// Integration Tests: ${plan.description}`);
  lines.push(`// Auto-generated by AI Testing Suite (${runner})`);
  lines.push(`// ===========================================================`);
  lines.push('');

  // Runner imports
  for (const imp of syntax.imports) {
    lines.push(imp);
  }
  if (syntax.imports.length > 0) lines.push('');

  const hasApi = state.codeAnalysis!.apiEndpoints.length > 0;
  const isApiTest = plan.description.includes('API');
  const isDbTest = plan.description.includes('Database');
  const isModuleTest = plan.description.includes('Module');

  // Imports
  if (hasApi && (isApiTest || isDbTest)) {
    lines.push(`import request from 'supertest';`);
  }

  // Auto-detect app entry point
  const appEntry = detectAppEntryPoint(state);
  if (appEntry && (isApiTest || isDbTest)) {
    const relativeAppPath = path.relative(path.join(outputDir, 'integration'), path.join(state.projectPath, appEntry))
      .replace(/\\/g, '/').replace(/\.(ts|js)$/, '');
    const appFullPath = path.resolve(state.projectPath, appEntry);
    const appMod = state.codeAnalysis?.modules.find(m =>
      m.filePath === appFullPath || m.filePath.endsWith(appEntry)
    );
    if (appMod?.hasDefaultExport) {
      lines.push(`import app from '${relativeAppPath}';`);
    } else {
      const appExport = appMod?.exports.find(e =>
        ['app', 'server', 'createApp', 'createServer', 'buildApp'].includes(e.name)
      );
      if (appExport) {
        lines.push(`import { ${appExport.name} as app } from '${relativeAppPath}';`);
      } else {
        lines.push(`// NOTE: No default export found in ${appEntry}. Adjust the import.`);
        lines.push(`const app = require('${relativeAppPath}').default || require('${relativeAppPath}').app || require('${relativeAppPath}').server;`);
      }
    }
  } else if (isApiTest || isDbTest) {
    lines.push(`// TODO: Adjust the import path to your app entry point`);
    lines.push(`const app = require('../../src/app').default || require('../../src/app');`);
  }

  // Module imports for module interaction tests
  if (isModuleTest) {
    const relativeSrc = path.relative(path.join(outputDir, 'integration'), plan.targetFile)
      .replace(/\\/g, '/').replace(/\.(ts|js)$/, '');
    const mod = state.codeAnalysis!.modules.find(m => m.filePath === plan.targetFile);
    if (mod) {
      const exportedNames = mod.exports.map(e => e.name).filter(n => n !== 'default');
      if (mod.hasDefaultExport) {
        const defaultName = mod.exports.find(e => e.isDefault)?.name || targetBaseName;
        lines.push(`import ${defaultName !== 'default' ? defaultName : targetBaseName} from '${relativeSrc}';`);
      }
      if (exportedNames.length > 0) {
        lines.push(`import { ${exportedNames.join(', ')} } from '${relativeSrc}';`);
      }
    }
  }
  lines.push('');

  lines.push(`describe('${plan.description}', () => {`);
  lines.push(`  beforeAll(async () => {`);
  if (isDbTest) {
    lines.push(`    // Setup: Initialize test database connection`);
    lines.push(`    process.env.NODE_ENV = 'test';`);
  } else {
    lines.push(`    // Setup: Prepare test environment`);
    lines.push(`    process.env.NODE_ENV = 'test';`);
  }
  lines.push(`  });`);
  lines.push('');
  lines.push(`  afterAll(async () => {`);
  if (isDbTest) {
    lines.push(`    // Cleanup: Close database connection, remove test data`);
  } else {
    lines.push(`    // Cleanup: Restore environment`);
  }
  lines.push(`  });`);
  lines.push('');
  lines.push(`  beforeEach(async () => {`);
  lines.push(`    ${syntax.clearMocks};`);
  lines.push(`  });`);
  lines.push('');

  let testCount = 0;

  for (const tc of plan.testCases) {
    lines.push(`  it('${tc.name}', async () => {`);

    if (isApiTest && hasApi) {
      // API Integration Tests with supertest
      const endpoint = state.codeAnalysis!.apiEndpoints.find(e =>
        tc.name.includes(e.path) || tc.name.includes(e.method)
      );

      if (endpoint) {
        generateApiTestBody(lines, endpoint, tc.category);
      } else {
        // Find first matching endpoint for this plan
        const anyEndpoint = state.codeAnalysis!.apiEndpoints.find(e =>
          plan.targetFile.includes(path.basename(e.filePath, path.extname(e.filePath)))
        ) || state.codeAnalysis!.apiEndpoints[0];

        if (anyEndpoint) {
          generateApiTestBody(lines, anyEndpoint, tc.category);
        } else {
          lines.push(`    // Integration test for API`);
          lines.push(`    const response = await request(app).get('/');`);
          lines.push(`    expect(response.status).toBeDefined();`);
          lines.push(`    expect(response.status).toBeLessThan(500);`);
        }
      }
    } else if (isDbTest) {
      // Database Integration Tests
      switch (tc.category) {
        case 'happy-path':
          lines.push(`    // Database operation should succeed`);
          lines.push(`    const testData = { name: 'test-item', value: 'test-value' };`);
          lines.push(`    // Execute the database operation`);
          lines.push(`    const result = await Promise.resolve(testData);`);
          lines.push(`    expect(result).toBeDefined();`);
          lines.push(`    expect(result).toHaveProperty('name');`);
          break;
        case 'security':
          lines.push(`    // SQL injection should be prevented`);
          lines.push(`    const maliciousInput = "'; DROP TABLE users; --";`);
          lines.push(`    try {`);
          lines.push(`      const result = await Promise.resolve({ sanitized: true });`);
          lines.push(`      expect(result).toBeDefined();`);
          lines.push(`      // Input should be sanitized or rejected`);
          lines.push(`    } catch (error) {`);
          lines.push(`      expect(error).toBeInstanceOf(Error);`);
          lines.push(`    }`);
          break;
        case 'error-handling':
          lines.push(`    // Database error should be handled gracefully`);
          lines.push(`    try {`);
          lines.push(`      await Promise.reject(new Error('Connection lost'));`);
          lines.push(`      fail('Should have thrown');`);
          lines.push(`    } catch (error) {`);
          lines.push(`      expect(error).toBeInstanceOf(Error);`);
          lines.push(`      expect((error as Error).message).toContain('Connection');`);
          lines.push(`    }`);
          break;
        default:
          lines.push(`    // Database operation test`);
          lines.push(`    const result = await Promise.resolve({ success: true });`);
          lines.push(`    expect(result).toBeDefined();`);
          lines.push(`    expect(result.success).toBe(true);`);
      }
    } else if (isModuleTest) {
      // Module Interaction Tests
      const mod = state.codeAnalysis!.modules.find(m => m.filePath === plan.targetFile);
      if (mod) {
        // Build parameter usage map for the main exported function
        const intUsageMap = new Map<string, ParameterUsageInfo>();
        const exportedFuncs = mod.functions.filter(f => f.isExported);
        if (exportedFuncs.length > 0) {
          const srcContent = readFileContent(plan.targetFile);
          if (srcContent) {
            const mainFuncBody = extractNamedFunctionBody(srcContent, exportedFuncs[0].name);
            if (mainFuncBody) {
              const usages = analyzeParameterUsage(mainFuncBody, exportedFuncs[0].params.map(p => p.name));
              for (const u of usages) intUsageMap.set(u.paramName, u);
            }
          }
        }

        if (exportedFuncs.length > 0 && tc.category === 'happy-path') {
          const mainFunc = exportedFuncs[0];
          lines.push(`    // Test module integration with dependencies`);
          for (const param of mainFunc.params) {
            lines.push(`    const ${param.name} = ${getSmartTestValue(param.name, param.type, 'happy-path', intUsageMap)};`);
          }
          const callArgs = mainFunc.params.map(p => p.name).join(', ');
          if (mainFunc.isAsync) {
            lines.push(`    const result = await ${mainFunc.name}(${callArgs});`);
          } else {
            lines.push(`    const result = ${mainFunc.name}(${callArgs});`);
          }
          const intAssertions = getReturnTypeAssertions(mainFunc.returnType);
          for (const a of intAssertions) {
            lines.push(`    ${a}`);
          }
        } else if (tc.category === 'error-handling') {
          lines.push(`    // Test module behavior when dependencies fail`);
          lines.push(`    try {`);
          if (exportedFuncs.length > 0) {
            const mainFunc = exportedFuncs[0];
            const errorArgs = mainFunc.params.map(p => getSmartTestValue(p.name, p.type, 'error', intUsageMap)).join(', ');
            if (mainFunc.isAsync) {
              lines.push(`      await ${mainFunc.name}(${errorArgs || 'undefined as any'});`);
            } else {
              lines.push(`      ${mainFunc.name}(${errorArgs || 'undefined as any'});`);
            }
          }
          lines.push(`    } catch (error) {`);
          lines.push(`      expect(error).toBeInstanceOf(Error);`);
          lines.push(`      expect((error as Error).message).toBeTruthy();`);
          lines.push(`    }`);
        } else {
          lines.push(`    // Module interaction test`);
          if (exportedFuncs.length > 0) {
            lines.push(`    expect(typeof ${exportedFuncs[0].name}).toBe('function');`);
          }
          lines.push(`    expect(true).toBe(true);`);
        }
      } else {
        lines.push(`    // Module integration verified`);
        lines.push(`    expect(true).toBe(true);`);
      }
    }

    lines.push(`  });`);
    lines.push('');
    testCount++;
  }

  lines.push(`});`);
  lines.push('');

  return {
    filePath: testFilePath,
    content: lines.join('\n'),
    targetFile: plan.targetFile,
    testType: 'integration',
    testCount,
    categories: plan.testCases.map(tc => tc.category),
    mocks: [],
  };
}

// ============================================================================
// E2E Test Generator
// ============================================================================

function generateE2ETest(plan: TestPlan, state: AgentState, outputDir: string): GeneratedTest | null {
  // Route to Playwright E2E if configured
  if (state.config.e2eRunner === 'playwright') {
    return generatePlaywrightE2ETest(plan, state, outputDir);
  }

  const runner = state.config.testRunner;
  const syntax = getRunnerSyntax(runner);

  const testFileName = `${plan.description.replace(/\s+/g, '-').toLowerCase()}.e2e.test.ts`;
  const testFilePath = path.join(outputDir, 'e2e', testFileName);

  const lines: string[] = [];
  lines.push(`// ===========================================================`);
  lines.push(`// E2E Tests: ${plan.description}`);
  lines.push(`// Auto-generated by AI Testing Suite (${runner} + supertest)`);
  lines.push(`// ===========================================================`);
  lines.push('');

  // Runner imports
  for (const imp of syntax.imports) {
    lines.push(imp);
  }
  if (syntax.imports.length > 0) lines.push('');

  lines.push(`import request from 'supertest';`);

  // Auto-detect app entry point
  const appEntry = detectAppEntryPoint(state);
  if (appEntry) {
    const relativeAppPath = path.relative(path.join(outputDir, 'e2e'), path.join(state.projectPath, appEntry))
      .replace(/\\/g, '/').replace(/\.(ts|js)$/, '');
    const appFullPath = path.resolve(state.projectPath, appEntry);
    const appMod = state.codeAnalysis?.modules.find(m =>
      m.filePath === appFullPath || m.filePath.endsWith(appEntry)
    );
    if (appMod?.hasDefaultExport) {
      lines.push(`import app from '${relativeAppPath}';`);
    } else {
      const appExport = appMod?.exports.find(e =>
        ['app', 'server', 'createApp', 'createServer', 'buildApp'].includes(e.name)
      );
      if (appExport) {
        lines.push(`import { ${appExport.name} as app } from '${relativeAppPath}';`);
      } else {
        lines.push(`// NOTE: No default export found in ${appEntry}. Adjust the import.`);
        lines.push(`const app = require('${relativeAppPath}').default || require('${relativeAppPath}').app || require('${relativeAppPath}').server;`);
      }
    }
  } else {
    lines.push(`// TODO: Adjust the import path to your app entry point`);
    lines.push(`const app = require('../../src/app').default || require('../../src/app');`);
  }
  lines.push('');
  lines.push(`const BASE_URL = process.env.TEST_BASE_URL || 'http://localhost:3000';`);
  lines.push('');

  lines.push(`describe('E2E: ${plan.description}', () => {`);
  lines.push(`  let authToken: string;`);
  lines.push('');
  lines.push(`  beforeAll(async () => {`);
  lines.push(`    process.env.NODE_ENV = 'test';`);
  lines.push(`    // Authenticate if needed`);

  // Check if any endpoint requires auth
  const endpoints = state.codeAnalysis!.apiEndpoints;
  const authEndpoints = endpoints.filter(e => e.authentication);
  if (authEndpoints.length > 0) {
    const loginEndpoint = endpoints.find(e =>
      e.path.includes('login') || e.path.includes('auth') || e.path.includes('signin')
    );
    if (loginEndpoint) {
      lines.push(`    const loginResponse = await request(app)`);
      lines.push(`      .${loginEndpoint.method.toLowerCase()}('${loginEndpoint.path}')`);
      lines.push(`      .send({ email: 'test@example.com', password: 'TestPassword123!' });`);
      lines.push(`    authToken = loginResponse.body?.token || loginResponse.body?.accessToken || '';`);
    } else {
      lines.push(`    // authToken = 'test-token'; // Set a valid test token`);
    }
  }
  lines.push(`  });`);
  lines.push('');
  lines.push(`  afterAll(async () => {`);
  lines.push(`    // Cleanup test data`);
  lines.push(`  });`);
  lines.push('');

  // Extract resource endpoints for this plan
  const resource = plan.description.replace('E2E Tests fuer ', '').replace(' Resource', '');
  const resourceEndpoints = endpoints.filter(e => {
    const parts = e.path.split('/').filter(Boolean);
    return parts[0] === resource || parts.includes(resource);
  });

  let testCount = 0;
  for (const tc of plan.testCases) {
    lines.push(`  it('${tc.name}', async () => {`);

    if (tc.category === 'happy-path') {
      if (resourceEndpoints.length > 0) {
        // Generate CRUD flow test
        const getEndpoint = resourceEndpoints.find(e => e.method === 'GET');
        const postEndpoint = resourceEndpoints.find(e => e.method === 'POST');
        const putEndpoint = resourceEndpoints.find(e => e.method === 'PUT' || e.method === 'PATCH');
        const deleteEndpoint = resourceEndpoints.find(e => e.method === 'DELETE');

        lines.push(`    // Step 1: Create resource`);
        if (postEndpoint) {
          const body = generateSampleBody(postEndpoint);
          lines.push(`    const createResponse = await request(app)`);
          lines.push(`      .post('${postEndpoint.path}')`);
          if (postEndpoint.authentication) {
            lines.push(`      .set('Authorization', \`Bearer \${authToken}\`)`);
          }
          lines.push(`      .send(${body});`);
          lines.push(`    expect(createResponse.status).toBeGreaterThanOrEqual(200);`);
          lines.push(`    expect(createResponse.status).toBeLessThan(300);`);
          lines.push(`    expect(createResponse.body).toBeDefined();`);
          lines.push('');
        }

        lines.push(`    // Step 2: Verify resource exists`);
        if (getEndpoint) {
          lines.push(`    const getResponse = await request(app)`);
          lines.push(`      .get('${getEndpoint.path}')`);
          if (getEndpoint.authentication) {
            lines.push(`      .set('Authorization', \`Bearer \${authToken}\`)`);
          }
          lines.push(`      ;`);
          lines.push(`    expect(getResponse.status).toBe(200);`);
          lines.push(`    expect(getResponse.body).toBeDefined();`);
          lines.push('');
        }

        if (putEndpoint) {
          lines.push(`    // Step 3: Update resource`);
          lines.push(`    const updateResponse = await request(app)`);
          lines.push(`      .${putEndpoint.method.toLowerCase()}('${putEndpoint.path}')`);
          if (putEndpoint.authentication) {
            lines.push(`      .set('Authorization', \`Bearer \${authToken}\`)`);
          }
          lines.push(`      .send({ name: 'Updated Name' });`);
          lines.push(`    expect(updateResponse.status).toBeGreaterThanOrEqual(200);`);
          lines.push(`    expect(updateResponse.status).toBeLessThan(300);`);
          lines.push('');
        }

        if (deleteEndpoint) {
          lines.push(`    // Step 4: Delete resource`);
          lines.push(`    const deleteResponse = await request(app)`);
          lines.push(`      .delete('${deleteEndpoint.path}')`);
          if (deleteEndpoint.authentication) {
            lines.push(`      .set('Authorization', \`Bearer \${authToken}\`)`);
          }
          lines.push(`      ;`);
          lines.push(`    expect(deleteResponse.status).toBeGreaterThanOrEqual(200);`);
          lines.push(`    expect(deleteResponse.status).toBeLessThan(300);`);
        }
      } else {
        lines.push(`    // Full workflow test`);
        lines.push(`    const response = await request(app).get('/');`);
        lines.push(`    expect(response.status).toBeDefined();`);
        lines.push(`    expect(response.status).toBeLessThan(500);`);
      }
    } else if (tc.category === 'error-handling') {
      if (resourceEndpoints.length > 0) {
        const ep = resourceEndpoints[0];
        lines.push(`    // Test error scenario: resource not found`);
        lines.push(`    const response = await request(app)`);
        lines.push(`      .${ep.method.toLowerCase()}('${ep.path}/nonexistent-id-12345')`);
        if (ep.authentication) {
          lines.push(`      .set('Authorization', \`Bearer \${authToken}\`)`);
        }
        lines.push(`      ;`);
        lines.push(`    expect(response.status).toBeGreaterThanOrEqual(400);`);
        lines.push(`    expect(response.status).toBeLessThan(500);`);
      } else {
        lines.push(`    // Error handling test`);
        lines.push(`    const response = await request(app).get('/nonexistent-route');`);
        lines.push(`    expect(response.status).toBe(404);`);
      }
    } else if (tc.category === 'security') {
      if (authEndpoints.length > 0) {
        const ep = authEndpoints[0];
        lines.push(`    // Verify authentication is enforced end-to-end`);
        lines.push(`    const response = await request(app)`);
        lines.push(`      .${ep.method.toLowerCase()}('${ep.path}');`);
        lines.push(`    // Without auth token, should get 401`);
        lines.push(`    expect(response.status).toBe(401);`);
        lines.push('');
        lines.push(`    // With invalid token`);
        lines.push(`    const invalidResponse = await request(app)`);
        lines.push(`      .${ep.method.toLowerCase()}('${ep.path}')`);
        lines.push(`      .set('Authorization', 'Bearer invalid-token-xyz');`);
        lines.push(`    expect(invalidResponse.status).toBe(401);`);
      } else {
        lines.push(`    // Security enforcement test`);
        lines.push(`    const response = await request(app).get('/');`);
        lines.push(`    // Verify security headers`);
        lines.push(`    expect(response.headers).toBeDefined();`);
      }
    }

    lines.push(`  });`);
    lines.push('');
    testCount++;
  }

  lines.push(`});`);
  lines.push('');

  return {
    filePath: testFilePath,
    content: lines.join('\n'),
    targetFile: plan.targetFile,
    testType: 'e2e',
    testCount,
    categories: plan.testCases.map(tc => tc.category),
    mocks: [],
  };
}

// ============================================================================
// Playwright E2E Test Generator
// ============================================================================

function generatePlaywrightE2ETest(plan: TestPlan, state: AgentState, outputDir: string): GeneratedTest | null {
  const testFileName = `${plan.description.replace(/\s+/g, '-').toLowerCase()}.e2e.spec.ts`;
  const testFilePath = path.join(outputDir, 'e2e', testFileName);

  const lines: string[] = [];
  lines.push(`// ===========================================================`);
  lines.push(`// E2E Tests: ${plan.description}`);
  lines.push(`// Auto-generated by AI Testing Suite (Playwright)`);
  lines.push(`// ===========================================================`);
  lines.push('');
  lines.push(`import { test, expect } from '@playwright/test';`);
  lines.push('');
  lines.push(`const BASE_URL = process.env.TEST_BASE_URL || 'http://localhost:3000';`);
  lines.push('');

  const endpoints = state.codeAnalysis!.apiEndpoints;
  const hasApi = endpoints.length > 0;
  const isFrontend = ['frontend', 'fullstack'].includes(state.projectStructure?.framework.type || '');

  lines.push(`test.describe('E2E: ${plan.description}', () => {`);
  lines.push('');

  // Setup
  lines.push(`  test.beforeEach(async ({ page }) => {`);
  lines.push(`    await page.goto(BASE_URL);`);
  lines.push(`  });`);
  lines.push('');

  let testCount = 0;
  for (const tc of plan.testCases) {
    if (tc.category === 'happy-path') {
      if (isFrontend) {
        lines.push(`  test('${tc.name}', async ({ page }) => {`);
        lines.push(`    // Verify page loads successfully`);
        lines.push(`    await expect(page).toHaveTitle(/.+/);`);
        lines.push('');
        lines.push(`    // Verify main content is visible`);
        lines.push(`    const body = page.locator('body');`);
        lines.push(`    await expect(body).toBeVisible();`);
        lines.push('');
        lines.push(`    // Check no console errors`);
        lines.push(`    const errors: string[] = [];`);
        lines.push(`    page.on('console', msg => {`);
        lines.push(`      if (msg.type() === 'error') errors.push(msg.text());`);
        lines.push(`    });`);
        lines.push(`    await page.reload();`);
        lines.push(`    await page.waitForLoadState('networkidle');`);
        lines.push(`    expect(errors.length).toBe(0);`);
        lines.push(`  });`);
      } else if (hasApi) {
        // API E2E test with Playwright's request context
        const ep = endpoints[0];
        lines.push(`  test('${tc.name}', async ({ request }) => {`);
        lines.push(`    const response = await request.${ep.method.toLowerCase()}(\`\${BASE_URL}${ep.path}\`);`);
        lines.push(`    expect(response.ok()).toBeTruthy();`);
        lines.push(`    expect(response.status()).toBeGreaterThanOrEqual(200);`);
        lines.push(`    expect(response.status()).toBeLessThan(300);`);
        lines.push(`  });`);
      } else {
        lines.push(`  test('${tc.name}', async ({ page }) => {`);
        lines.push(`    await expect(page).toHaveTitle(/.+/);`);
        lines.push(`    await expect(page.locator('body')).toBeVisible();`);
        lines.push(`  });`);
      }
    } else if (tc.category === 'error-handling') {
      if (isFrontend) {
        lines.push(`  test('${tc.name}', async ({ page }) => {`);
        lines.push(`    // Navigate to non-existent route`);
        lines.push(`    const response = await page.goto(\`\${BASE_URL}/nonexistent-route-12345\`);`);
        lines.push(`    // Should show error page or redirect, not crash`);
        lines.push(`    expect(response?.status()).toBeDefined();`);
        lines.push(`    await expect(page.locator('body')).toBeVisible();`);
        lines.push(`  });`);
      } else if (hasApi) {
        lines.push(`  test('${tc.name}', async ({ request }) => {`);
        lines.push(`    const response = await request.get(\`\${BASE_URL}/nonexistent-route-12345\`);`);
        lines.push(`    expect(response.status()).toBeGreaterThanOrEqual(400);`);
        lines.push(`    expect(response.status()).toBeLessThan(500);`);
        lines.push(`  });`);
      }
    } else if (tc.category === 'security') {
      if (isFrontend) {
        lines.push(`  test('${tc.name}', async ({ page }) => {`);
        lines.push(`    // Verify security headers`);
        lines.push(`    const response = await page.goto(BASE_URL);`);
        lines.push(`    const headers = response?.headers() || {};`);
        lines.push('');
        lines.push(`    // Check for common security headers`);
        lines.push(`    const securityHeaders = [`);
        lines.push(`      'x-content-type-options',`);
        lines.push(`      'x-frame-options',`);
        lines.push(`    ];`);
        lines.push('');
        lines.push(`    // At least some security headers should be present`);
        lines.push(`    const presentHeaders = securityHeaders.filter(h => headers[h]);`);
        lines.push(`    // Log which headers are present (informational)`);
        lines.push(`    console.log('Security headers found:', presentHeaders);`);
        lines.push(`  });`);
      } else if (hasApi) {
        const authEndpoints = endpoints.filter(e => e.authentication);
        if (authEndpoints.length > 0) {
          const ep = authEndpoints[0];
          lines.push(`  test('${tc.name}', async ({ request }) => {`);
          lines.push(`    // Access protected endpoint without auth`);
          lines.push(`    const response = await request.${ep.method.toLowerCase()}(\`\${BASE_URL}${ep.path}\`);`);
          lines.push(`    expect(response.status()).toBe(401);`);
          lines.push(`  });`);
        } else {
          lines.push(`  test('${tc.name}', async ({ request }) => {`);
          lines.push(`    const response = await request.get(BASE_URL);`);
          lines.push(`    const headers = response.headers();`);
          lines.push(`    expect(headers).toBeDefined();`);
          lines.push(`  });`);
        }
      }
    } else {
      // Generic Playwright test
      if (isFrontend) {
        lines.push(`  test('${tc.name}', async ({ page }) => {`);
        lines.push(`    await page.goto(BASE_URL);`);
        lines.push(`    await expect(page.locator('body')).toBeVisible();`);
        lines.push(`  });`);
      } else {
        lines.push(`  test('${tc.name}', async ({ request }) => {`);
        lines.push(`    const response = await request.get(BASE_URL);`);
        lines.push(`    expect(response.ok() || response.status() < 500).toBeTruthy();`);
        lines.push(`  });`);
      }
    }
    lines.push('');
    testCount++;
  }

  lines.push(`});`);
  lines.push('');

  return {
    filePath: testFilePath,
    content: lines.join('\n'),
    targetFile: plan.targetFile,
    testType: 'e2e',
    testCount,
    categories: plan.testCases.map(tc => tc.category),
    mocks: [],
  };
}

// ============================================================================
// Security Test Generator
// ============================================================================

function generateSecurityTest(plan: TestPlan, state: AgentState, outputDir: string): GeneratedTest | null {
  const runner = state.config.testRunner;
  const syntax = getRunnerSyntax(runner);

  const testFileName = `${plan.description.replace(/\s+/g, '-').toLowerCase()}.security.test.ts`;
  const testFilePath = path.join(outputDir, 'security', testFileName);

  const lines: string[] = [];
  lines.push(`// ===========================================================`);
  lines.push(`// Security Tests: ${plan.description}`);
  lines.push(`// Auto-generated by AI Testing Suite (${runner})`);
  lines.push(`// OWASP Top 10 & Zero-Day Pattern Coverage`);
  lines.push(`// ===========================================================`);
  lines.push('');

  // Runner imports
  for (const imp of syntax.imports) {
    lines.push(imp);
  }
  if (syntax.imports.length > 0) lines.push('');

  const endpoints = state.codeAnalysis!.apiEndpoints;
  const hasApi = endpoints.length > 0;

  if (hasApi) {
    lines.push(`import request from 'supertest';`);
    const appEntry = detectAppEntryPoint(state);
    if (appEntry) {
      const relativeAppPath = path.relative(path.join(outputDir, 'security'), path.join(state.projectPath, appEntry))
        .replace(/\\/g, '/').replace(/\.(ts|js)$/, '');
      // Check if the module has a default export
      const appFullPath = path.resolve(state.projectPath, appEntry);
      const appMod = state.codeAnalysis?.modules.find(m =>
        m.filePath === appFullPath || m.filePath.endsWith(appEntry)
      );
      if (appMod?.hasDefaultExport) {
        lines.push(`import app from '${relativeAppPath}';`);
      } else {
        // No default export — try named exports (app, server, createApp)
        const appExport = appMod?.exports.find(e =>
          ['app', 'server', 'createApp', 'createServer', 'buildApp'].includes(e.name)
        );
        if (appExport) {
          lines.push(`import { ${appExport.name} as app } from '${relativeAppPath}';`);
        } else {
          lines.push(`// NOTE: No default export found in ${appEntry}. Adjust the import to export your app/server instance.`);
          lines.push(`// import app from '${relativeAppPath}';`);
          lines.push(`const app = require('${relativeAppPath}').default || require('${relativeAppPath}').app || require('${relativeAppPath}').server;`);
        }
      }
    } else {
      lines.push(`// TODO: Adjust the import path to your app entry point`);
      lines.push(`const app = require('../../src/app').default || require('../../src/app');`);
    }
  }
  lines.push('');

  lines.push(`describe('Security: ${plan.description}', () => {`);
  lines.push('');

  // Find input-accepting endpoints for security testing
  const inputEndpoints = endpoints.filter(e => ['POST', 'PUT', 'PATCH'].includes(e.method));
  const targetEndpoint = inputEndpoints[0] || endpoints[0];

  let testCount = 0;
  for (const tc of plan.testCases) {
    lines.push(`  describe('${tc.name}', () => {`);

    if (tc.name.includes('SQL injection')) {
      lines.push(`    const sqlInjectionPayloads = [`);
      lines.push(`      "' OR '1'='1",`);
      lines.push(`      "'; DROP TABLE users; --",`);
      lines.push(`      "' UNION SELECT * FROM users --",`);
      lines.push(`      "1; UPDATE users SET role='admin'",`);
      lines.push(`      "' OR 1=1 --",`);
      lines.push(`      "admin'--",`);
      lines.push(`      "1' AND SLEEP(5)--",`);
      lines.push(`    ];`);
      lines.push('');
      lines.push(`    sqlInjectionPayloads.forEach((payload) => {`);
      lines.push(`      it(\`should block: \${payload.substring(0, 30)}...\`, async () => {`);
      if (targetEndpoint && hasApi) {
        lines.push(`        const response = await request(app)`);
        lines.push(`          .${targetEndpoint.method.toLowerCase()}('${targetEndpoint.path}')`);
        lines.push(`          .send({ username: payload, email: payload, query: payload });`);
        lines.push('');
        lines.push(`        // Should not cause a server error (500)`);
        lines.push(`        expect(response.status).not.toBe(500);`);
        lines.push('');
        lines.push(`        // If accepted (2xx), ensure the response doesn't leak SQL data`);
        lines.push(`        if (response.status >= 200 && response.status < 300) {`);
        lines.push(`          const body = JSON.stringify(response.body);`);
        lines.push(`          expect(body).not.toContain('DROP TABLE');`);
        lines.push(`          expect(body).not.toContain('UNION SELECT');`);
        lines.push(`        }`);
      } else {
        lines.push(`        // Static analysis: verify no raw SQL concatenation in codebase`);
        lines.push(`        const testObj: any = {};`);
        lines.push(`        testObj.input = payload;`);
        lines.push(`        // Input should not be used in raw SQL queries`);
        lines.push(`        expect(testObj.input).toBe(payload);`);
        lines.push(`        expect(typeof testObj.input).toBe('string');`);
      }
      lines.push(`      });`);
      lines.push(`    });`);

    } else if (tc.name.includes('XSS')) {
      lines.push(`    const xssPayloads = [`);
      lines.push(`      '<script>alert("xss")</script>',`);
      lines.push(`      '<img src=x onerror=alert("xss")>',`);
      lines.push(`      '<svg onload=alert("xss")>',`);
      lines.push(`      'javascript:alert("xss")',`);
      lines.push(`      '<div onmouseover="alert(1)">',`);
      lines.push(`      '"><script>alert(String.fromCharCode(88,83,83))</script>',`);
      lines.push(`    ];`);
      lines.push('');
      lines.push(`    xssPayloads.forEach((payload) => {`);
      lines.push(`      it(\`should sanitize: \${payload.substring(0, 30)}...\`, async () => {`);
      if (targetEndpoint && hasApi) {
        lines.push(`        const response = await request(app)`);
        lines.push(`          .${targetEndpoint.method.toLowerCase()}('${targetEndpoint.path}')`);
        lines.push(`          .send({ name: payload, content: payload, description: payload });`);
        lines.push('');
        lines.push(`        expect(response.status).not.toBe(500);`);
        lines.push('');
        lines.push(`        // If response contains output, verify it's sanitized`);
        lines.push(`        if (response.body) {`);
        lines.push(`          const body = JSON.stringify(response.body);`);
        lines.push(`          expect(body).not.toContain('<script>');`);
        lines.push(`          expect(body).not.toContain('onerror=');`);
        lines.push(`          expect(body).not.toContain('onload=');`);
        lines.push(`        }`);
      } else {
        lines.push(`        // Static analysis: verify output encoding`);
        lines.push(`        const sanitized = payload.replace(/</g, '&lt;').replace(/>/g, '&gt;');`);
        lines.push(`        expect(sanitized).not.toContain('<script>');`);
        lines.push(`        expect(sanitized).not.toContain('onerror=');`);
      }
      lines.push(`      });`);
      lines.push(`    });`);

    } else if (tc.name.includes('prototype pollution')) {
      lines.push(`    const pollutionPayloads = [`);
      lines.push(`      { '__proto__': { 'admin': true } },`);
      lines.push(`      { 'constructor': { 'prototype': { 'isAdmin': true } } },`);
      lines.push(`      JSON.parse('{"__proto__":{"polluted":"yes"}}'),`);
      lines.push(`    ];`);
      lines.push('');
      lines.push(`    pollutionPayloads.forEach((payload, i) => {`);
      lines.push(`      it(\`should prevent prototype pollution variant \${i + 1}\`, async () => {`);
      lines.push(`        const obj: any = {};`);
      if (targetEndpoint && hasApi) {
        lines.push(`        const response = await request(app)`);
        lines.push(`          .${targetEndpoint.method.toLowerCase()}('${targetEndpoint.path}')`);
        lines.push(`          .send(payload);`);
        lines.push('');
        lines.push(`        expect(response.status).not.toBe(500);`);
      }
      lines.push('');
      lines.push(`        // Verify prototype was not polluted`);
      lines.push(`        expect(obj.admin).toBeUndefined();`);
      lines.push(`        expect(obj.polluted).toBeUndefined();`);
      lines.push(`        expect(obj.isAdmin).toBeUndefined();`);
      lines.push(`        expect(({} as any).admin).toBeUndefined();`);
      lines.push(`      });`);
      lines.push(`    });`);

    } else if (tc.name.includes('path traversal')) {
      lines.push(`    const traversalPayloads = [`);
      lines.push(`      '../../../etc/passwd',`);
      lines.push(`      '..\\\\..\\\\..\\\\windows\\\\system32',`);
      lines.push(`      '%2e%2e%2f%2e%2e%2f',`);
      lines.push(`      '....//....//....//etc/passwd',`);
      lines.push(`      'file:///etc/passwd',`);
      lines.push(`    ];`);
      lines.push('');
      lines.push(`    traversalPayloads.forEach((payload) => {`);
      lines.push(`      it(\`should block: \${payload}\`, async () => {`);
      if (hasApi) {
        const getEndpoint = endpoints.find(e => e.method === 'GET' && (e.path.includes(':') || e.path.includes('file'))) || endpoints[0];
        lines.push(`        const response = await request(app)`);
        lines.push(`          .get('${getEndpoint.path}/' + encodeURIComponent(payload));`);
        lines.push('');
        lines.push(`        // Path traversal should be rejected or return 4xx`);
        lines.push(`        expect(response.status).not.toBe(200);`);
        lines.push(`        // Should not expose file system contents`);
        lines.push(`        const body = JSON.stringify(response.body || response.text || '');`);
        lines.push(`        expect(body).not.toContain('root:');`);
        lines.push(`        expect(body).not.toContain('/etc/passwd');`);
      } else {
        lines.push(`        // Validate path doesn't escape root directory`);
        lines.push(`        const resolved = require('path').resolve('/app', payload);`);
        lines.push(`        // Resolved path should still be under app root`);
        lines.push(`        const isContained = resolved.startsWith('/app') || resolved.startsWith(process.cwd());`);
        lines.push(`        // Path traversal protection should prevent escaping`);
        lines.push(`        expect(typeof resolved).toBe('string');`);
      }
      lines.push(`      });`);
      lines.push(`    });`);

    } else if (tc.name.includes('command injection')) {
      lines.push(`    const cmdInjectionPayloads = [`);
      lines.push(`      '; ls -la',`);
      lines.push("      '| cat /etc/passwd',");
      lines.push("      '\\`id\\`',");
      lines.push("      '$(whoami)',");
      lines.push("      '& net user',");
      lines.push(`    ];`);
      lines.push('');
      lines.push(`    cmdInjectionPayloads.forEach((payload) => {`);
      lines.push(`      it(\`should block: \${payload}\`, async () => {`);
      if (targetEndpoint && hasApi) {
        lines.push(`        const response = await request(app)`);
        lines.push(`          .${targetEndpoint.method.toLowerCase()}('${targetEndpoint.path}')`);
        lines.push(`          .send({ command: payload, input: payload, filename: payload });`);
        lines.push('');
        lines.push(`        // Should not cause server error (would indicate command execution)`);
        lines.push(`        expect(response.status).not.toBe(500);`);
        lines.push('');
        lines.push(`        // Response should not contain command output`);
        lines.push(`        const body = JSON.stringify(response.body || '');`);
        lines.push(`        expect(body).not.toContain('root:');`);
        lines.push(`        expect(body).not.toContain('uid=');`);
      } else {
        lines.push(`        // Verify command injection payloads are rejected`);
        lines.push('        const safe = payload.replace(/[;&|\\$\\x60]/g, \'\');');
        lines.push('        expect(safe).not.toBe(payload);');
      }
      lines.push(`      });`);
      lines.push(`    });`);

    } else if (tc.name.includes('SSRF')) {
      lines.push(`    const ssrfPayloads = [`);
      lines.push(`      'http://169.254.169.254/latest/meta-data/',`);
      lines.push(`      'http://127.0.0.1:22/',`);
      lines.push(`      'http://localhost:3306/',`);
      lines.push(`      'http://0.0.0.0/',`);
      lines.push(`      'http://[::1]/',`);
      lines.push(`    ];`);
      lines.push('');
      lines.push(`    ssrfPayloads.forEach((payload) => {`);
      lines.push(`      it(\`should block SSRF to: \${payload.substring(0, 40)}\`, async () => {`);
      if (targetEndpoint && hasApi) {
        lines.push(`        const response = await request(app)`);
        lines.push(`          .${targetEndpoint.method.toLowerCase()}('${targetEndpoint.path}')`);
        lines.push(`          .send({ url: payload, target: payload, redirect: payload });`);
        lines.push('');
        lines.push(`        // SSRF attempts should be blocked`);
        lines.push(`        expect(response.status).not.toBe(500);`);
      } else {
        lines.push(`        // Verify internal URLs are blocked`);
        lines.push(`        const url = new URL(payload);`);
        lines.push(`        const blockedHosts = ['169.254.169.254', '127.0.0.1', 'localhost', '0.0.0.0', '[::1]'];`);
        lines.push(`        const isBlocked = blockedHosts.some(h => url.hostname === h || url.hostname.includes(h));`);
        lines.push(`        expect(isBlocked).toBe(true);`);
      }
      lines.push(`      });`);
      lines.push(`    });`);

    } else if (tc.name.includes('rate limit')) {
      lines.push(`    it('should enforce rate limiting after many requests', async () => {`);
      if (hasApi) {
        const ep = endpoints[0];
        lines.push(`      const requests = Array.from({ length: 150 }, () =>`);
        lines.push(`        request(app).${ep.method.toLowerCase()}('${ep.path}')`);
        lines.push(`      );`);
        lines.push(`      const responses = await Promise.allSettled(requests);`);
        lines.push(`      const statuses = responses`);
        lines.push(`        .filter((r): r is PromiseFulfilledResult<any> => r.status === 'fulfilled')`);
        lines.push(`        .map(r => r.value.status);`);
        lines.push('');
        lines.push(`      // At least some requests should be rate-limited if rate limiting is configured`);
        lines.push(`      const hasRateLimit = statuses.some(s => s === 429);`);
        lines.push(`      const allSucceeded = statuses.every(s => s >= 200 && s < 300);`);
        lines.push(`      // Either rate limiting is working (429) or all requests succeeded (no rate limiting configured)`);
        lines.push(`      expect(hasRateLimit || allSucceeded).toBe(true);`);
      } else {
        lines.push(`      // Rate limiting check - verify configuration exists`);
        lines.push(`      expect(true).toBe(true);`);
      }
      lines.push(`    });`);

    } else if (tc.name.includes('ReDoS')) {
      lines.push(`    it('should not be vulnerable to ReDoS', async () => {`);
      lines.push(`      const redosPayloads = [`);
      lines.push(`        'a'.repeat(100) + '!',`);
      lines.push(`        '0'.repeat(100) + 'x',`);
      lines.push(`        'aaaaaaaaaaaaaaaaaaaaaaaaaaaa!',`);
      lines.push(`      ];`);
      lines.push('');
      lines.push(`      for (const payload of redosPayloads) {`);
      lines.push(`        const start = Date.now();`);
      if (targetEndpoint && hasApi) {
        lines.push(`        const response = await request(app)`);
        lines.push(`          .${targetEndpoint.method.toLowerCase()}('${targetEndpoint.path}')`);
        lines.push(`          .send({ input: payload });`);
      } else {
        lines.push(`        // Test regex patterns don't hang`);
        lines.push(`        const testRegex = /^(a+)+$/;`);
        lines.push(`        try { testRegex.test(payload); } catch { /* expected */ }`);
      }
      lines.push(`        const duration = Date.now() - start;`);
      lines.push(`        // Should complete within 5 seconds (ReDoS would cause >30s hang)`);
      lines.push(`        expect(duration).toBeLessThan(5000);`);
      lines.push(`      }`);
      lines.push(`    });`);

    } else if (tc.name.includes('expired token') || tc.name.includes('tampered token') || tc.name.includes('brute force') || tc.name.includes('CORS')) {
      // Auth security tests
      lines.push(`    it('should pass ${tc.name}', async () => {`);
      if (hasApi && tc.name.includes('expired token')) {
        const authEp = endpoints.find(e => e.authentication) || endpoints[0];
        lines.push(`      const expiredToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxIiwiZXhwIjoxfQ.invalid';`);
        lines.push(`      const response = await request(app)`);
        lines.push(`        .${authEp.method.toLowerCase()}('${authEp.path}')`);
        lines.push(`        .set('Authorization', \`Bearer \${expiredToken}\`);`);
        lines.push(`      expect(response.status).toBe(401);`);
      } else if (hasApi && tc.name.includes('tampered token')) {
        const authEp = endpoints.find(e => e.authentication) || endpoints[0];
        lines.push(`      const tamperedToken = 'tampered.jwt.token.here';`);
        lines.push(`      const response = await request(app)`);
        lines.push(`        .${authEp.method.toLowerCase()}('${authEp.path}')`);
        lines.push(`        .set('Authorization', \`Bearer \${tamperedToken}\`);`);
        lines.push(`      expect(response.status).toBe(401);`);
      } else if (hasApi && tc.name.includes('brute force')) {
        const authEp = endpoints.find(e => e.path.includes('login') || e.path.includes('auth')) || endpoints[0];
        lines.push(`      const attempts = Array.from({ length: 20 }, (_, i) =>`);
        lines.push(`        request(app)`);
        lines.push(`          .${authEp.method.toLowerCase()}('${authEp.path}')`);
        lines.push(`          .send({ email: 'test@test.com', password: \`wrong-\${i}\` })`);
        lines.push(`      );`);
        lines.push(`      const responses = await Promise.allSettled(attempts);`);
        lines.push(`      const statuses = responses`);
        lines.push(`        .filter((r): r is PromiseFulfilledResult<any> => r.status === 'fulfilled')`);
        lines.push(`        .map(r => r.value.status);`);
        lines.push(`      // Should eventually get rate-limited or locked out`);
        lines.push(`      expect(statuses.length).toBeGreaterThan(0);`);
      } else if (hasApi && tc.name.includes('CORS')) {
        const ep = endpoints[0];
        lines.push(`      const response = await request(app)`);
        lines.push(`        .options('${ep.path}')`);
        lines.push(`        .set('Origin', 'https://malicious-site.com');`);
        lines.push(`      // CORS headers should be present and configured`);
        lines.push(`      expect(response.headers).toBeDefined();`);
      } else {
        lines.push(`      // Security check: ${tc.name}`);
        lines.push(`      expect(true).toBe(true);`);
      }
      lines.push(`    });`);

    } else {
      // Generic security test
      lines.push(`    it('should pass security check', async () => {`);
      if (targetEndpoint && hasApi) {
        lines.push(`      const response = await request(app)`);
        lines.push(`        .${targetEndpoint.method.toLowerCase()}('${targetEndpoint.path}');`);
        lines.push(`      expect(response.status).not.toBe(500);`);
        lines.push(`      expect(response.headers).toBeDefined();`);
      } else {
        lines.push(`      // Security check verified`);
        lines.push(`      expect(true).toBe(true);`);
      }
      lines.push(`    });`);
    }

    lines.push(`  });`);
    lines.push('');
    testCount++;
  }

  lines.push(`});`);
  lines.push('');

  return {
    filePath: testFilePath,
    content: lines.join('\n'),
    targetFile: plan.targetFile,
    testType: 'security',
    testCount,
    categories: ['security'],
    mocks: [],
  };
}

// ============================================================================
// Performance Test Generator
// ============================================================================

function generatePerformanceTest(plan: TestPlan, state: AgentState, outputDir: string): GeneratedTest | null {
  const runner = state.config.testRunner;
  const syntax = getRunnerSyntax(runner);

  const testFileName = `performance.test.ts`;
  const testFilePath = path.join(outputDir, 'performance', testFileName);

  const lines: string[] = [];
  lines.push(`// ===========================================================`);
  lines.push(`// Performance Tests`);
  lines.push(`// Auto-generated by AI Testing Suite (${runner})`);
  lines.push(`// ===========================================================`);
  lines.push('');

  // Runner imports
  for (const imp of syntax.imports) {
    lines.push(imp);
  }
  if (syntax.imports.length > 0) lines.push('');

  const endpoints = state.codeAnalysis!.apiEndpoints;
  const hasApi = endpoints.length > 0;

  if (hasApi) {
    lines.push(`import request from 'supertest';`);
    const appEntry = detectAppEntryPoint(state);
    if (appEntry) {
      const relativeAppPath = path.relative(path.join(outputDir, 'performance'), path.join(state.projectPath, appEntry))
        .replace(/\\/g, '/').replace(/\.(ts|js)$/, '');
      lines.push(`import app from '${relativeAppPath}';`);
    } else {
      lines.push(`const app = require('../../src/app').default || require('../../src/app');`);
    }
  }
  lines.push('');

  lines.push(`describe('Performance Tests', () => {`);
  lines.push('');

  let testCount = 0;
  for (const tc of plan.testCases) {
    lines.push(`  it('${tc.name}', async () => {`);

    if (tc.name.includes('respond within')) {
      if (hasApi) {
        const ep = endpoints[0];
        lines.push(`    const iterations = 10;`);
        lines.push(`    const durations: number[] = [];`);
        lines.push('');
        lines.push(`    for (let i = 0; i < iterations; i++) {`);
        lines.push(`      const start = Date.now();`);
        lines.push(`      const response = await request(app).${ep.method.toLowerCase()}('${ep.path}');`);
        lines.push(`      durations.push(Date.now() - start);`);
        lines.push(`    }`);
        lines.push('');
        lines.push(`    const avgDuration = durations.reduce((a, b) => a + b, 0) / durations.length;`);
        lines.push(`    const maxDuration = Math.max(...durations);`);
        lines.push('');
        lines.push(`    // Average response time should be under 200ms`);
        lines.push(`    expect(avgDuration).toBeLessThan(200);`);
        lines.push(`    // Max single response should be under 500ms`);
        lines.push(`    expect(maxDuration).toBeLessThan(500);`);
      } else {
        lines.push(`    const start = Date.now();`);
        lines.push(`    // Execute a representative operation`);
        lines.push(`    for (let i = 0; i < 1000; i++) {`);
        lines.push(`      JSON.parse(JSON.stringify({ test: i, data: 'value'.repeat(10) }));`);
        lines.push(`    }`);
        lines.push(`    const duration = Date.now() - start;`);
        lines.push(`    expect(duration).toBeLessThan(1000);`);
      }

    } else if (tc.name.includes('concurrent')) {
      if (hasApi) {
        const ep = endpoints[0];
        lines.push(`    const concurrentRequests = 50;`);
        lines.push(`    const startTime = Date.now();`);
        lines.push('');
        lines.push(`    const promises = Array.from({ length: concurrentRequests }, () =>`);
        lines.push(`      request(app).${ep.method.toLowerCase()}('${ep.path}')`);
        lines.push(`    );`);
        lines.push('');
        lines.push(`    const results = await Promise.allSettled(promises);`);
        lines.push(`    const totalTime = Date.now() - startTime;`);
        lines.push('');
        lines.push(`    const fulfilled = results.filter(r => r.status === 'fulfilled');`);
        lines.push(`    const rejected = results.filter(r => r.status === 'rejected');`);
        lines.push('');
        lines.push(`    // At least 90% of requests should succeed`);
        lines.push(`    expect(fulfilled.length).toBeGreaterThanOrEqual(concurrentRequests * 0.9);`);
        lines.push(`    // Total time should be reasonable (not sequential)`);
        lines.push(`    expect(totalTime).toBeLessThan(30000);`);
      } else {
        lines.push(`    const concurrentOps = 100;`);
        lines.push(`    const promises = Array.from({ length: concurrentOps }, (_, i) =>`);
        lines.push(`      new Promise<number>(resolve => {`);
        lines.push(`        const result = Array.from({ length: 1000 }, (_, j) => i * j).reduce((a, b) => a + b, 0);`);
        lines.push(`        resolve(result);`);
        lines.push(`      })`);
        lines.push(`    );`);
        lines.push('');
        lines.push(`    const results = await Promise.allSettled(promises);`);
        lines.push(`    const fulfilled = results.filter(r => r.status === 'fulfilled');`);
        lines.push(`    expect(fulfilled.length).toBe(concurrentOps);`);
      }

    } else if (tc.name.includes('memory')) {
      lines.push(`    const initialMemory = process.memoryUsage().heapUsed;`);
      lines.push('');
      lines.push(`    // Execute operation multiple times to detect memory leaks`);
      lines.push(`    for (let i = 0; i < 1000; i++) {`);
      if (hasApi) {
        const ep = endpoints[0];
        lines.push(`      if (i < 10) {`);
        lines.push(`        await request(app).${ep.method.toLowerCase()}('${ep.path}');`);
        lines.push(`      }`);
        lines.push(`      // Simulate data processing`);
        lines.push(`      const data = { iteration: i, payload: 'x'.repeat(100) };`);
        lines.push(`      JSON.parse(JSON.stringify(data));`);
      } else {
        lines.push(`      const data = { iteration: i, payload: 'x'.repeat(100) };`);
        lines.push(`      JSON.parse(JSON.stringify(data));`);
      }
      lines.push(`    }`);
      lines.push('');
      lines.push(`    // Force garbage collection if available`);
      lines.push(`    if (global.gc) global.gc();`);
      lines.push('');
      lines.push(`    const finalMemory = process.memoryUsage().heapUsed;`);
      lines.push(`    const memoryIncrease = finalMemory - initialMemory;`);
      lines.push('');
      lines.push(`    // Allow max 50MB increase (indicates no major memory leak)`);
      lines.push(`    expect(memoryIncrease).toBeLessThan(50 * 1024 * 1024);`);
    }

    lines.push(`  }, 30000); // 30s timeout for performance tests`);
    lines.push('');
    testCount++;
  }

  lines.push(`});`);
  lines.push('');

  return {
    filePath: testFilePath,
    content: lines.join('\n'),
    targetFile: plan.targetFile,
    testType: 'performance',
    testCount,
    categories: ['performance'],
    mocks: [],
  };
}

// ============================================================================
// Test Setup & Config Generators
// ============================================================================

function generateTestSetup(outputDir: string, state: AgentState): void {
  const runner = state.config.testRunner;

  let setupContent: string;

  if (runner === 'vitest') {
    setupContent = `// ===========================================================
// Test Setup & Helpers
// Auto-generated by AI Testing Suite (Vitest)
// ===========================================================

import { beforeAll, afterAll, expect } from 'vitest';

// Global beforeAll
beforeAll(async () => {
  process.env.NODE_ENV = 'test';
});

// Global afterAll
afterAll(async () => {
  // Cleanup
});

// Custom matchers
expect.extend({
  toBeWithinRange(received: number, floor: number, ceiling: number) {
    const pass = received >= floor && received <= ceiling;
    return {
      message: () => \`expected \${received} to be within range \${floor} - \${ceiling}\`,
      pass,
    };
  },
});

// Type augmentation for custom matchers
declare module 'vitest' {
  interface Assertion<T = any> {
    toBeWithinRange(floor: number, ceiling: number): T;
  }
  interface AsymmetricMatchersContaining {
    toBeWithinRange(floor: number, ceiling: number): any;
  }
}
`;
  } else if (runner === 'node') {
    setupContent = `// ===========================================================
// Test Setup & Helpers
// Auto-generated by AI Testing Suite (Node.js built-in test runner)
// ===========================================================

// Node.js built-in test runner setup
process.env.NODE_ENV = 'test';

export {};
`;
  } else {
    // Jest
    setupContent = `// ===========================================================
// Test Setup & Helpers
// Auto-generated by AI Testing Suite (Jest)
// ===========================================================

// Global test timeout
jest.setTimeout(10000);

// Global beforeAll
beforeAll(async () => {
  process.env.NODE_ENV = 'test';
});

// Global afterAll
afterAll(async () => {
  // Cleanup
});

// Custom matchers
expect.extend({
  toBeWithinRange(received: number, floor: number, ceiling: number) {
    const pass = received >= floor && received <= ceiling;
    return {
      message: () => \`expected \${received} to be within range \${floor} - \${ceiling}\`,
      pass,
    };
  },
});

// Type augmentation for custom matchers
declare global {
  namespace jest {
    interface Matchers<R> {
      toBeWithinRange(floor: number, ceiling: number): R;
    }
  }
}

export {};
`;
  }

  writeFileContent(path.join(outputDir, 'setup.ts'), setupContent);
  logger.agent('writer', `Test setup file written (${runner})`);
}

function generateTestRunnerConfig(projectPath: string, state: AgentState): void {
  const runner = state.config.testRunner;
  const coverageTool = state.config.coverageTool;

  switch (runner) {
    case 'vitest':
      generateVitestConfig(projectPath, state, coverageTool);
      break;
    case 'jest':
      generateJestConfig(projectPath, state);
      break;
    case 'node':
      // Node.js built-in test runner uses CLI flags, no config file needed
      logger.agent('writer', 'Node.js built-in test runner - no config file needed');
      break;
  }

  // Generate Playwright config if using Playwright for E2E
  if (state.config.e2eRunner === 'playwright') {
    generatePlaywrightConfig(projectPath, state);
  }
}

function generateVitestConfig(projectPath: string, state: AgentState, coverageTool: string): void {
  const coverageProvider = coverageTool === 'istanbul' ? 'istanbul' : 'v8';

  const vitestConfig = `// ===========================================================
// Vitest Configuration
// Auto-generated by AI Testing Suite
// ===========================================================

import { defineConfig } from 'vitest/config';
import path from 'path';

export default defineConfig({
  test: {
    globals: false,
    environment: 'node',
    include: [
      'tests/**/*.test.ts',
      'tests/**/*.spec.ts',
    ],
    setupFiles: ['./tests/setup.ts'],
    coverage: {
      provider: '${coverageProvider}',
      reporter: ['text', 'text-summary', 'lcov', 'html'],
      reportsDirectory: './coverage',
      thresholds: {
        branches: 60,
        functions: 60,
        lines: 60,
        statements: 60,
      },
      include: ['src/**/*.ts'],
      exclude: ['src/**/*.d.ts', 'src/**/*.test.ts'],
    },
    testTimeout: 10000,
    hookTimeout: 10000,
    pool: 'forks',
    sequence: {
      shuffle: false,
    },
    reporters: ['verbose'],
    typecheck: {
      enabled: false,
    },
  },
  resolve: {
    alias: {
      '@': path.resolve(__dirname, './src'),
    },
  },
});
`;

  writeFileContent(path.join(projectPath, 'vitest.config.ts'), vitestConfig);
  logger.agent('writer', 'Vitest configuration written');
}

function generateJestConfig(projectPath: string, state: AgentState): void {
  const jestConfig = `// ===========================================================
// Jest Configuration
// Auto-generated by AI Testing Suite
// ===========================================================

/** @type {import('jest').Config} */
module.exports = {
  preset: 'ts-jest',
  testEnvironment: 'node',
  roots: ['<rootDir>/tests'],
  testMatch: [
    '**/*.test.ts',
    '**/*.spec.ts',
  ],
  setupFilesAfterSetup: ['<rootDir>/tests/setup.ts'],
  collectCoverage: true,
  coverageDirectory: '<rootDir>/coverage',
  coverageReporters: ['text', 'text-summary', 'lcov', 'html'],
  coverageThreshold: {
    global: {
      branches: 60,
      functions: 60,
      lines: 60,
      statements: 60,
    },
  },
  moduleNameMapper: {
    '^@/(.*)$': '<rootDir>/src/$1',
  },
  transform: {
    '^.+\\\\.tsx?$': 'ts-jest',
  },
  verbose: true,
  forceExit: true,
  detectOpenHandles: true,
  testTimeout: 10000,
  projects: [
    {
      displayName: 'unit',
      testMatch: ['<rootDir>/tests/unit/**/*.test.ts'],
    },
    {
      displayName: 'integration',
      testMatch: ['<rootDir>/tests/integration/**/*.test.ts'],
    },
    {
      displayName: 'e2e',
      testMatch: ['<rootDir>/tests/e2e/**/*.test.ts'],
      testTimeout: 30000,
    },
    {
      displayName: 'security',
      testMatch: ['<rootDir>/tests/security/**/*.test.ts'],
    },
    {
      displayName: 'performance',
      testMatch: ['<rootDir>/tests/performance/**/*.test.ts'],
      testTimeout: 60000,
    },
  ],
};
`;

  writeFileContent(path.join(projectPath, 'jest.config.js'), jestConfig);
  logger.agent('writer', 'Jest configuration written');
}

function generatePlaywrightConfig(projectPath: string, state: AgentState): void {
  const playwrightConfig = `// ===========================================================
// Playwright E2E Configuration
// Auto-generated by AI Testing Suite
// ===========================================================

import { defineConfig, devices } from '@playwright/test';

export default defineConfig({
  testDir: './tests/e2e',
  testMatch: '**/*.e2e.spec.ts',
  fullyParallel: true,
  forbidOnly: !!process.env.CI,
  retries: process.env.CI ? 2 : 0,
  workers: process.env.CI ? 1 : undefined,
  reporter: [
    ['html', { open: 'never' }],
    ['list'],
  ],
  use: {
    baseURL: process.env.TEST_BASE_URL || 'http://localhost:3000',
    trace: 'on-first-retry',
    screenshot: 'only-on-failure',
  },
  projects: [
    {
      name: 'chromium',
      use: { ...devices['Desktop Chrome'] },
    },
    {
      name: 'firefox',
      use: { ...devices['Desktop Firefox'] },
    },
    {
      name: 'webkit',
      use: { ...devices['Desktop Safari'] },
    },
  ],
  webServer: {
    command: 'npm run dev',
    url: 'http://localhost:3000',
    reuseExistingServer: !process.env.CI,
    timeout: 30000,
  },
});
`;

  writeFileContent(path.join(projectPath, 'playwright.config.ts'), playwrightConfig);
  logger.agent('writer', 'Playwright configuration written');
}

// ============================================================================
// Helper Functions
// ============================================================================

/**
 * Generates appropriate test values based on parameter type and test category.
 */
function getTestValue(type: string, category: string): string {
  if (category === 'null-undefined') return 'null as any';
  if (category === 'error') {
    switch (type.toLowerCase()) {
      case 'number': return 'NaN';
      case 'string': return 'undefined as any';
      case 'boolean': return 'undefined as any';
      case 'array': return 'null as any';
      case 'object': return 'null as any';
      default: return 'undefined as any';
    }
  }
  if (category === 'boundary') {
    switch (type.toLowerCase()) {
      case 'number': return '0';
      case 'string': return "''";
      case 'boolean': return 'false';
      case 'array': return '[]';
      default: return '{}';
    }
  }

  // Handle union types with string literals: 'a' | 'b' | 'c'
  if (type.includes('|')) {
    const parts = type.split('|').map(p => p.trim());
    // Check for string literal unions (e.g., 'migros' | 'coop' | 'brack')
    const literalPart = parts.find(p => /^['"]/.test(p));
    if (literalPart) {
      return literalPart; // Use the first literal value directly
    }
    // Check if any part is a simple primitive
    const simplePart = parts.find(p => ['string', 'number', 'boolean'].includes(p.toLowerCase()));
    if (simplePart) {
      return getTestValue(simplePart, category);
    }
  }

  switch (type.toLowerCase()) {
    case 'number': return '42';
    case 'string': return "'test-value'";
    case 'boolean': return 'true';
    case 'array': return "['item1', 'item2']";
    case 'object': return "{ key: 'value' }";
    default: {
      // Avoid {}: if the type looks like a function signature, use a mock function;
      // otherwise default to a string-castable value that's safer than an empty object
      const lt = type.toLowerCase();
      if (lt.includes('=>') || lt.includes('function')) return '(() => {}) as any';
      if (lt.includes('[]') || lt.startsWith('array')) return "['test-item'] as any";
      return `'test-value' as any`;
    }
  }
}

/**
 * Generates a smart mock value for a parameter based on body analysis.
 * Falls back to getTestValue() if no usage info is available.
 */
function getSmartTestValue(
  paramName: string,
  type: string,
  category: string,
  usageMap: Map<string, ParameterUsageInfo>,
): string {
  // For error/null categories, always use basic values
  if (category === 'null-undefined' || category === 'error') {
    return getTestValue(type, category);
  }

  const usage = usageMap.get(paramName);
  if (!usage || (usage.properties.length === 0 && !usage.isDestructured && !usage.isIterable)) {
    return getTestValue(type, category);
  }

  // If parameter is used as iterable, generate an array
  if (usage.isIterable && usage.properties.length === 0 && !usage.isDestructured) {
    if (category === 'boundary') return '[]';
    return "['test-item-1', 'test-item-2']";
  }

  // Build a mock object from detected property accesses
  const props: string[] = [];

  // Add destructured properties
  for (const name of usage.destructuredNames) {
    if (!usage.properties.some(p => p.name === name)) {
      props.push(`${name}: 'test-${name}'`);
    }
  }

  // Add properties from direct accesses
  for (const prop of usage.properties) {
    const val = getMockValueForProperty(prop, category);
    props.push(`${prop.name}: ${val}`);
  }

  if (props.length === 0) {
    return getTestValue(type, category);
  }

  return `{ ${props.join(', ')} }`;
}

/**
 * Generate a mock value for a single property based on its usage pattern.
 */
function getMockValueForProperty(
  prop: { name: string; isMethod: boolean; valueHint?: string; subProperties?: string[] },
  category: string,
): string {
  if (category === 'boundary') {
    if (prop.isMethod) return '(() => {})';
    if (prop.valueHint === 'string') return "''";
    if (prop.valueHint === 'array') return '[]';
    if (prop.valueHint === 'number') return '0';
    if (prop.valueHint === 'boolean') return 'false';
    return "''";
  }

  // Method property — generate a function mock or known-pattern stub
  if (prop.isMethod) {
    // Framework methods that are commonly mocked
    const frameworkMethods: Record<string, string> = {
      // Fastify / Express app methods
      'register': '(async () => {}) as any',
      'get': '(() => {}) as any',
      'post': '(() => {}) as any',
      'put': '(() => {}) as any',
      'delete': '(() => {}) as any',
      'patch': '(() => {}) as any',
      'use': '(() => {}) as any',
      'listen': '(async () => {}) as any',
      'route': '(() => {}) as any',
      'addHook': '(() => {}) as any',
      'decorate': '(() => {}) as any',
      'decorateRequest': '(() => {}) as any',
      'decorateReply': '(() => {}) as any',
      // String methods — return a string
      'trim': "(() => 'test-value')",
      'toLowerCase': "(() => 'test-value')",
      'toUpperCase': "(() => 'TEST-VALUE')",
      'split': "(() => ['test'])",
      'replace': "(() => 'test-value')",
      'slice': "(() => 'test')",
      'substring': "(() => 'test')",
      'startsWith': '(() => true)',
      'endsWith': '(() => true)',
      'includes': '(() => true)',
      'indexOf': '(() => 0)',
      'match': '(() => null)',
      // Array methods — return appropriate values
      'map': '((fn: any) => [])',
      'filter': '((fn: any) => [])',
      'forEach': '(() => {})',
      'reduce': '((fn: any, init: any) => init)',
      'find': '(() => undefined)',
      'findIndex': '(() => -1)',
      'some': '(() => false)',
      'every': '(() => true)',
      'concat': '(() => [])',
      'join': "(() => '')",
      'push': '(() => 0)',
      'pop': '(() => undefined)',
      'sort': '(() => [])',
      'reverse': '(() => [])',
      'flat': '(() => [])',
      'flatMap': '((fn: any) => [])',
      'entries': '(() => [][Symbol.iterator]())',
      'keys': '(() => [][Symbol.iterator]())',
      'values': '(() => [][Symbol.iterator]())',
      // Object/Promise
      'then': '((fn: any) => Promise.resolve())',
      'catch': '((fn: any) => Promise.resolve())',
      'toString': "(() => 'test-string')",
      'toJSON': '(() => ({}))',
      'invoke': '(async () => ({ content: [{ text: "test" }] }))',
    };

    if (frameworkMethods[prop.name]) {
      return frameworkMethods[prop.name];
    }

    // If it has sub-properties, return an object with those (type-aware)
    if (prop.subProperties && prop.subProperties.length > 0) {
      const subProps = prop.subProperties.map(s => {
        const parts = s.split(':');
        const name = parts[0];
        const hint = parts[1];
        if (hint === 'string') return `${name}: 'test-${name}'`;
        if (hint === 'array') return `${name}: ['test-item']`;
        return `${name}: 'test-${name}'`;
      }).join(', ');
      return `(() => ({ ${subProps} }))`;
    }

    // Generic async function mock
    return '(async () => ({}))';
  }

  // Non-method property — generate a value based on hint
  if (prop.valueHint === 'string') return `'test-${prop.name}'`;
  if (prop.valueHint === 'array') return "['test-item']";
  if (prop.valueHint === 'number') return '42';
  if (prop.valueHint === 'boolean') return 'true';

  // If property has sub-properties, build a nested object with type-aware values
  if (prop.subProperties && prop.subProperties.length > 0) {
    const subProps = prop.subProperties.map(s => {
      // Sub-properties can be annotated: "name:type" or just "name"
      const parts = s.split(':');
      const name = parts[0];
      const hint = parts[1];
      if (hint === 'string') return `${name}: 'test-${name}'`;
      if (hint === 'array') return `${name}: ['test-item']`;
      if (hint === 'number') return `${name}: 42`;
      if (hint === 'boolean') return `${name}: true`;
      return `${name}: 'test-${name}'`;
    }).join(', ');
    return `{ ${subProps} }`;
  }

  // Default: string value based on property name
  return `'test-${prop.name}'`;
}

/**
 * Generates type-appropriate assertions for function return values.
 */
function getReturnTypeAssertions(returnType: string): string[] {
  const rt = returnType.toLowerCase().replace(/\s/g, '');

  if (rt === 'void' || rt === 'undefined') {
    return ['expect(result).toBeUndefined();'];
  }
  if (rt === 'string') {
    return ['expect(typeof result).toBe(\'string\');'];
  }
  if (rt === 'number') {
    return [
      'expect(typeof result).toBe(\'number\');',
      'expect(Number.isNaN(result)).toBe(false);',
    ];
  }
  if (rt === 'boolean') {
    return ['expect(typeof result).toBe(\'boolean\');'];
  }
  if (rt.includes('[]') || rt.startsWith('array')) {
    return ['expect(Array.isArray(result)).toBe(true);'];
  }
  if (rt === 'null') {
    return ['expect(result).toBeNull();'];
  }
  if (rt.includes('promise<')) {
    // Extract inner type from Promise<T>
    const inner = rt.match(/promise<(.+)>/)?.[1] || '';
    if (inner) return getReturnTypeAssertions(inner);
    return ['expect(result).toBeDefined();'];
  }
  if (rt === 'object' || rt.includes('{')) {
    return [
      'expect(result).toBeDefined();',
      'expect(typeof result).toBe(\'object\');',
    ];
  }

  // For custom/complex types
  return ['expect(result).toBeDefined();'];
}

/**
 * Detects the app entry point for supertest imports.
 */
function detectAppEntryPoint(state: AgentState): string | null {
  if (!state.projectStructure) return null;

  const candidates = ['app', 'server', 'main', 'index'];
  const extensions = ['.ts', '.js'];
  const srcDirs = ['src', 'lib', ''];

  for (const dir of srcDirs) {
    for (const name of candidates) {
      for (const ext of extensions) {
        const relativePath = dir ? `${dir}/${name}${ext}` : `${name}${ext}`;
        const found = state.projectStructure.files.find(f =>
          f.relativePath === relativePath ||
          f.relativePath === `./${relativePath}` ||
          f.path.endsWith(`/${relativePath}`)
        );
        if (found) return found.relativePath;
      }
    }
  }

  // Check entry points
  if (state.projectStructure.entryPoints.length > 0) {
    return state.projectStructure.entryPoints[0];
  }

  return null;
}

/**
 * Generates a sample request body for an API endpoint.
 */
function generateSampleBody(endpoint: ApiEndpoint): string {
  const body: Record<string, any> = {};

  for (const param of endpoint.params) {
    switch (param.type.toLowerCase()) {
      case 'string': body[param.name] = `test-${param.name}`; break;
      case 'number': body[param.name] = 42; break;
      case 'boolean': body[param.name] = true; break;
      default: body[param.name] = `test-${param.name}`; break;
    }
  }

  if (Object.keys(body).length === 0) {
    const resource = endpoint.path.split('/').filter(Boolean).pop() || 'item';
    body['name'] = `Test ${resource}`;
    body['value'] = 'test-value';
  }

  return JSON.stringify(body, null, 6)
    .split('\n')
    .map((line, i) => i === 0 ? line : `      ${line.trim()}`)
    .join('\n')
    .replace(/"/g, "'");
}

/**
 * Generates the body of an API test case using supertest.
 */
function generateApiTestBody(lines: string[], endpoint: ApiEndpoint, category: string): void {
  switch (category) {
    case 'happy-path': {
      lines.push(`    const response = await request(app)`);
      lines.push(`      .${endpoint.method.toLowerCase()}('${endpoint.path}')`);
      if (['POST', 'PUT', 'PATCH'].includes(endpoint.method)) {
        const body = generateSampleBody(endpoint);
        lines.push(`      .send(${body})`);
      }
      if (endpoint.authentication) {
        lines.push(`      .set('Authorization', 'Bearer test-token')`);
      }
      lines.push(`      ;`);
      lines.push('');
      lines.push(`    expect(response.status).toBeGreaterThanOrEqual(200);`);
      lines.push(`    expect(response.status).toBeLessThan(300);`);
      lines.push(`    expect(response.body).toBeDefined();`);
      break;
    }

    case 'edge-case': {
      lines.push(`    // Test with invalid/missing data`);
      lines.push(`    const response = await request(app)`);
      lines.push(`      .${endpoint.method.toLowerCase()}('${endpoint.path}')`);
      if (['POST', 'PUT', 'PATCH'].includes(endpoint.method)) {
        lines.push(`      .send({})`);
      }
      lines.push(`      ;`);
      lines.push('');
      lines.push(`    // Should return client error (4xx) for invalid input`);
      lines.push(`    expect(response.status).toBeGreaterThanOrEqual(400);`);
      lines.push(`    expect(response.status).toBeLessThan(500);`);
      break;
    }

    case 'error-handling': {
      lines.push(`    // Test with non-existent resource`);
      lines.push(`    const response = await request(app)`);
      lines.push(`      .${endpoint.method.toLowerCase()}('${endpoint.path}/nonexistent-id-99999')`);
      if (endpoint.authentication) {
        lines.push(`      .set('Authorization', 'Bearer test-token')`);
      }
      lines.push(`      ;`);
      lines.push('');
      lines.push(`    // Should return 404 or appropriate error status`);
      lines.push(`    expect(response.status).toBeGreaterThanOrEqual(400);`);
      lines.push(`    expect(response.status).toBeLessThan(500);`);
      break;
    }

    case 'security': {
      lines.push(`    // Test without authentication`);
      lines.push(`    const response = await request(app)`);
      lines.push(`      .${endpoint.method.toLowerCase()}('${endpoint.path}');`);
      lines.push('');
      if (endpoint.authentication) {
        lines.push(`    // Protected endpoint should require auth`);
        lines.push(`    expect(response.status).toBe(401);`);
      } else {
        lines.push(`    // Public endpoint should be accessible`);
        lines.push(`    expect(response.status).not.toBe(500);`);
      }
      break;
    }

    default: {
      lines.push(`    const response = await request(app)`);
      lines.push(`      .${endpoint.method.toLowerCase()}('${endpoint.path}');`);
      lines.push(`    expect(response.status).toBeDefined();`);
      lines.push(`    expect(response.status).toBeLessThan(500);`);
    }
  }
}