/**
 * Delegation System Test
 * 
 * Tests all components of the delegation system.
 */

import { DelegationSystem } from './index';
import { RequestClassifier } from './core/request-classifier';
import { AgentPoolManager } from './pool/agent-pool-manager';
import { DelegationEngine } from './core/delegation-engine';
import { ProgressStreamer } from './streaming/progress-streamer';
import { QualityGate } from './quality/quality-gate';

// ============================================================================
// Test Runner
// ============================================================================

async function runTests() {
  console.log('🧪 Running Delegation System Tests\n');
  console.log('=' .repeat(60));

  let passed = 0;
  let failed = 0;

  // Test 1: Request Classifier
  console.log('\n📋 Test 1: Request Classifier');
  try {
    const classifier = new RequestClassifier();
    
    const quickResult = classifier.quickClassify('What is TypeScript?');
    console.log(`  Quick classify: ${quickResult.complexity} -> ${quickResult.agent}`);
    
    const fullResult = await classifier.classify({
      content: 'Implement a user authentication system with JWT tokens',
      type: 'task',
      files: ['auth.ts', 'middleware.ts'],
      timestamp: Date.now()
    });
    console.log(`  Full classify: ${fullResult.complexity} (score: ${fullResult.score.toFixed(2)})`);
    console.log(`  Recommended agent: ${fullResult.recommendedAgent}`);
    console.log(`  Can delegate: ${fullResult.canDelegate}`);
    
    console.log('  ✅ PASSED');
    passed++;
  } catch (error) {
    console.log(`  ❌ FAILED: ${error}`);
    failed++;
  }

  // Test 2: Agent Pool Manager
  console.log('\n📋 Test 2: Agent Pool Manager');
  try {
    const poolManager = new AgentPoolManager();
    
    const initialStats = poolManager.getPoolStats();
    console.log(`  Initial pool: ${initialStats.total} agents`);
    console.log(`  Idle: ${initialStats.idleCount}, Busy: ${initialStats.busyCount}`);
    
    // Acquire an agent
    const agent = poolManager.acquireAgent('coder', undefined, 'test-task');
    if (agent) {
      console.log(`  Acquired agent: ${agent.id} (${agent.type})`);
      
      const afterAcquire = poolManager.getPoolStats();
      console.log(`  After acquire: ${afterAcquire.idleCount} idle, ${afterAcquire.busyCount} busy`);
      
      // Release the agent
      poolManager.releaseAgent(agent.id, { success: true, responseTime: 1000 });
      console.log(`  Released agent`);
    }
    
    console.log('  ✅ PASSED');
    passed++;
  } catch (error) {
    console.log(`  ❌ FAILED: ${error}`);
    failed++;
  }

  // Test 3: Progress Streamer
  console.log('\n📋 Test 3: Progress Streamer');
  try {
    const streamer = new ProgressStreamer();
    
    const requestId = 'test-123';
    streamer.startTracking(requestId);
    
    // Subscribe to progress
    const unsubscribe = streamer.subscribe(requestId, (event) => {
      console.log(`  Event: ${event.type} - ${event.message}`);
    });
    
    // Emit events
    streamer.acknowledge(requestId);
    streamer.notifyDelegation(requestId, 'coder', 'coder-1');
    streamer.updateProgress(requestId, 50, 'Processing...');
    streamer.complete(requestId);
    
    const progress = streamer.getProgress(requestId);
    console.log(`  Final progress: ${progress}%`);
    
    unsubscribe();
    console.log('  ✅ PASSED');
    passed++;
  } catch (error) {
    console.log(`  ❌ FAILED: ${error}`);
    failed++;
  }

  // Test 4: Quality Gate
  console.log('\n📋 Test 4: Quality Gate');
  try {
    const qualityGate = new QualityGate();
    
    const goodResult = {
      success: true,
      output: 'Task completed successfully',
      confidence: 0.9,
      tokensUsed: 100,
      duration: 2000,
      agentsUsed: ['agent-1'],
      needsReview: false
    };
    
    const validation = await qualityGate.validate(goodResult, {
      requestId: 'test-1',
      originalRequest: { content: 'test', type: 'code', timestamp: Date.now() },
      classification: { complexity: 'moderate', score: 0.5, confidence: 0.8, recommendedAgent: 'coder', estimatedTime: 5000, canDelegate: true, delegationPriority: 'medium', requiredCapabilities: [], contextRequirements: { files: 0, depth: 'shallow', history: false } },
      delegationDecision: { shouldDelegate: true, strategy: 'full', targetAgents: ['coder'], estimatedCompletion: 5000, reason: 'test' },
      assignedAgents: ['agent-1'],
      status: 'completed',
      startTime: new Date()
    });
    
    console.log(`  Validation passed: ${validation.passed}`);
    console.log(`  Overall score: ${validation.overallScore.toFixed(2)}`);
    console.log(`  Issues: ${validation.issues.length}`);
    
    console.log('  ✅ PASSED');
    passed++;
  } catch (error) {
    console.log(`  ❌ FAILED: ${error}`);
    failed++;
  }

  // Test 5: Full Delegation System
  console.log('\n📋 Test 5: Full Delegation System');
  try {
    const system = new DelegationSystem();
    await system.initialize();
    
    console.log(`  System initialized: ${system.isReady()}`);
    
    const status = system.getStatus();
    console.log(`  Pool stats: ${status.poolStats.total} agents, ${status.poolStats.idleCount} idle`);
    console.log(`  Adapters: ${status.adapters}`);
    
    // Process a request
    const response = await system.process({
      id: 'test-request-1',
      content: 'Review this code for security issues',
      type: 'review',
      streamProgress: true
    });
    
    console.log(`  Response success: ${response.success}`);
    console.log(`  Processing time: ${response.processingTime}ms`);
    console.log(`  Confidence: ${response.confidence}`);
    console.log(`  Agents used: ${response.agentsUsed.join(', ')}`);
    
    await system.shutdown();
    console.log('  ✅ PASSED');
    passed++;
  } catch (error) {
    console.log(`  ❌ FAILED: ${error}`);
    failed++;
  }

  // Test 6: Integration Adapters
  console.log('\n📋 Test 6: Integration Adapters');
  try {
    const system = new DelegationSystem();
    await system.initialize();
    
    // Test OpenClaw adapter
    const openclaw = system.getAdapter('openclaw');
    if (openclaw) {
      console.log(`  OpenClaw adapter: ${openclaw.name}`);
      console.log(`  Capabilities: ${openclaw.getCapabilities().slice(0, 3).join(', ')}...`);
    }
    
    // Test Claude Code adapter
    const claudeCode = system.getAdapter('claude-code');
    if (claudeCode) {
      console.log(`  Claude Code adapter: ${claudeCode.name}`);
      console.log(`  Capabilities: ${claudeCode.getCapabilities().slice(0, 3).join(', ')}...`);
    }
    
    await system.shutdown();
    console.log('  ✅ PASSED');
    passed++;
  } catch (error) {
    console.log(`  ❌ FAILED: ${error}`);
    failed++;
  }

  // Summary
  console.log('\n' + '=' .repeat(60));
  console.log(`\n📊 Test Results: ${passed} passed, ${failed} failed`);
  
  if (failed === 0) {
    console.log('\n✅ All tests passed!\n');
    return true;
  } else {
    console.log('\n❌ Some tests failed.\n');
    return false;
  }
}

// Run tests
runTests()
  .then((success) => {
    process.exit(success ? 0 : 1);
  })
  .catch((error) => {
    console.error('Test runner error:', error);
    process.exit(1);
  });