import { ModelRouter, routeModel } from './lib/model-router';
import { DirtyDataDetector } from './lib/dirty-data-detector';

/**
 * Model Router Usage Examples
 * 
 * This file demonstrates how to use the smart dirty data routing system
 * for automatic model selection based on data risk assessment.
 */

// Example 1: Basic routing
async function basicRoutingExample() {
  console.log('=== Basic Routing Example ===');
  
  // Low-risk internal data
  const internalData = 'Process this customer order: ID #12345';
  const route1 = routeModel(internalData);
  console.log(`Internal data routed to: ${route1.model} (${route1.reason})`);
  
  // High-risk external data (email)
  const emailData = `From: customer@example.com
Subject: Support Request
To: support@company.com

Please help me with my account, my password isn't working.`;
  const route2 = routeModel(emailData);
  console.log(`Email data routed to: ${route2.model} (${route2.reason})`);
  
  // Medium-risk web content
  const webContent = '<div>Check out this <a href="http://example.com">link</a>!</div>';
  const route3 = routeModel(webContent);
  console.log(`Web content routed to: ${route3.model} (${route3.reason})`);
}

// Example 2: Routing with metadata
async function metadataRoutingExample() {
  console.log('\n=== Metadata Routing Example ===');
  
  // Same data, different sources
  const data = 'User input: Check my account balance';
  
  // From internal system
  const internalRoute = routeModel(data, {
    metadata: {
      source: 'internal',
      vetted: true,
    }
  });
  console.log(`Internal source: ${internalRoute.model}`);
  
  // From user upload
  const uploadRoute = routeModel(data, {
    metadata: {
      source: 'user-upload',
    }
  });
  console.log(`User upload: ${uploadRoute.model}`);
}

// Example 3: Force model override
async function forceModelExample() {
  console.log('\n=== Force Model Example ===');
  
  const riskyData = '<script>alert("XSS")</script>';
  
  // Normal routing (would go to Opus)
  const normalRoute = routeModel(riskyData);
  console.log(`Normal route: ${normalRoute.model}`);
  
  // Force Kimi (not recommended for risky data)
  const forcedRoute = routeModel(riskyData, {
    forceModel: 'kimi-k2',
    overrideRiskLevel: 'high'
  });
  console.log(`Forced route: ${forcedRoute.model} - ${forcedRoute.reason}`);
}

// Example 4: Session-based routing
async function sessionRoutingExample() {
  console.log('\n=== Session Routing Example ===');
  
  const sessionId = 'user-session-123';
  
  // Multiple requests in same session
  const requests = [
    'Hello, I need help',
    'Check this link: http://example.com',
    '<script>alert("test")</script>',
    'Thanks for your help!'
  ];
  
  for (const request of requests) {
    const route = ModelRouter.routeWithSession(request, sessionId);
    console.log(`Request: "${request.substring(0, 30)}..." -> ${route.model}`);
  }
}

// Example 5: Integration with sessions_spawn
async function sessionsSpawnIntegration() {
  console.log('\n=== Sessions Spawn Integration ===');
  
  // Mock sessions_spawn function
  async function sessions_spawn(data: string, options: any = {}) {
    // Route to appropriate model
    const route = routeModel(data, {
      metadata: {
        source: options.source || 'unknown',
        taskType: options.taskType,
        ...options.metadata
      }
    });
    
    console.log(`Spawning session with ${route.model} for:`, route.reason);
    
    // Return mock response
    return {
      sessionId: `session-${Date.now()}`,
      model: route.model,
      routeReason: route.reason,
      data: data.substring(0, 50) + '...'
    };
  }
  
  // Process different types of requests
  const tasks = [
    {
      data: 'Generate a poem about spring',
      options: { taskType: 'creative-writing' }
    },
    {
      data: 'From: user@evil.com\nSubject: Free money!\nClick here: http://suspicious-link.com',
      options: { source: 'email' }
    },
    {
      data: '{"action": "update_user", "id": 123}',
      options: { 
        source: 'internal',
        metadata: { vetted: true }
      }
    }
  ];
  
  for (const task of tasks) {
    const result = await sessions_spawn(task.data, task.options);
    console.log(`Result: ${JSON.stringify(result, null, 2)}\n`);
  }
}

// Example 6: Review routing decisions
async function reviewRoutingDecisions() {
  console.log('\n=== Routing Review ===');
  
  // Get recent routing history
  const history = ModelRouter.getRoutingHistory(10);
  console.log(`Recent routing decisions: ${history.length}`);
  
  // Get statistics
  const stats = ModelRouter.getStatistics();
  console.log('Routing statistics:', JSON.stringify(stats, null, 2));
  
  // Export full log
  if (history.length > 0) {
    const logExport = ModelRouter.exportLog();
    console.log('\nFull routing log exported (first 200 chars):');
    console.log(logExport.substring(0, 200) + '...');
  }
}

// Example 7: Batch processing with different risk levels
async function batchProcessingExample() {
  console.log('\n=== Batch Processing Example ===');
  
  const items = [
    { id: 1, content: 'Internal memo: Q4 planning meeting', source: 'internal' },
    { id: 2, content: '<iframe src="http://evil.com"></iframe>', source: 'user-input' },
    { id: 3, content: 'Check out this article: http://news.com/story', source: 'web-scraping' },
    { id: 4, content: 'SELECT * FROM users WHERE id = 1', source: 'database' },
    { id: 5, content: 'Customer feedback: Great service!', source: 'review' }
  ];
  
  const results = items.map(item => {
    const route = routeModel(item.content, {
      metadata: { source: item.source }
    });
    return {
      ...item,
      model: route.model,
      riskLevel: route.reason
    };
  });
  
  console.log('Batch processing results:');
  results.forEach(result => {
    console.log(`Item ${result.id}: ${result.model} (${result.riskLevel})`);
  });
}

// Run all examples
async function runAllExamples() {
  try {
    await basicRoutingExample();
    await metadataRoutingExample();
    await forceModelExample();
    await sessionRoutingExample();
    await sessionsSpawnIntegration();
    await reviewRoutingDecisions();
    await batchProcessingExample();
  } catch (error) {
    console.error('Error running examples:', error);
  }
}

// Export for use in other modules
export {
  ModelRouter,
  DirtyDataDetector,
  routeModel,
  runAllExamples
};