import { createOrchestrator } from '@vnbx/intelligent-agent-orchestrator';

// Create orchestrator with defaults
const orchestrator = createOrchestrator({
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
  enableParallelExecution: true,
  enableAutoRecovery: true,
  debug: false
});

// Execute a task with natural language
const result = await orchestrator.executeTask(
  'Fix the API authentication issues in infra-api-gateway'
);

console.log('Success:', result.success);
console.log('Duration:', result.executionTime, 'ms');
console.log('Steps executed:', result.steps.length);

// Analyze without executing
const analysis = await orchestrator.analyzeOnly(
  'Optimize the marketplace app performance'
);

console.log('Intent:', analysis.intent);
console.log('Required agents:', analysis.requiredAgents);
console.log('Confidence:', analysis.metrics.confidenceScore);

// Generate workflow plan
const workflow = await orchestrator.planWorkflow(
  'Deploy new API version with zero downtime'
);

console.log('Steps:', workflow.steps.length);
console.log('Estimated duration:', workflow.estimatedDuration, 'seconds');
console.log('Complexity:', workflow.complexity);

// Execute with event tracking
orchestrator.on('step:start', ({ step }) => {
  console.log(`Starting: ${step.agentId} - ${step.action}`);
});

orchestrator.on('step:complete', ({ result }) => {
  console.log(`Completed: ${result.agentId} in ${result.duration}ms`);
});

const result = await orchestrator.executeTask('Your task here');

// Natural language task
const result = await orchestrator.executeTask(
  'Run health checks on all marketplace apps'
);

if (result.success) {
  console.log('All apps healthy!');
} else {
  console.log('Issues found:', result.errors);
}

// Complex task requiring multiple agents
const result = await orchestrator.executeTask(
  'Implement new business valuation API with ML predictions, add authentication, deploy with monitoring'
);

// AI automatically coordinates:
// 1. Business Logic Architect - Design valuation algorithm
// 2. ML Engineering Specialist - Implement prediction model
// 3. API Developer - Create REST endpoints
// 4. Security Guardian - Add authentication
// 5. DevOps Engineer - Deploy with monitoring
// 6. Test Engineer - Validate implementation

// Orchestrator learns from history
const result = await orchestrator.executeTask(
  'Optimize app performance',
  {
    appId: 'infra-api-gateway',
    previousAttempts: 2,
    targetMetric: 'response_time'
  }
);

// Uses historical data to choose best optimization strategy

// AI determines parallel execution opportunities
const result = await orchestrator.executeTask(
  'Update all marketplace apps to latest React version and run security audits'
);

// Parallel groups:
// Group 1: [Update app 1, Update app 2, Update app 3] (parallel)
// Group 2: [Security audit all apps] (after updates complete)

// Automatic recovery on failures
orchestrator.on('recovery:start', ({ step, attempt }) => {
  console.log(`Retrying ${step.agentId} - Attempt ${attempt}`);
});

const result = await orchestrator.executeTask(
  'Deploy to production'
);

// If deployment fails, orchestrator:
// 1. Attempts retry with exponential backoff
// 2. Falls back to alternative deployment strategy
// 3. Rolls back if all attempts fail

import { IntelligentAgentOrchestrator } from '@vnbx/intelligent-agent-orchestrator';

const orchestrator = new IntelligentAgentOrchestrator({
  // AI Configuration
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
  defaultModel: 'claude-sonnet-4-20250514',

  // Execution Settings
  maxRetries: 3,
  timeout: 30000,

  // Features
  enableParallelExecution: true,  // AI-optimized parallel execution
  enableAutoRecovery: true,        // Automatic error recovery
  enableLearning: true,            // Learn from execution patterns

  // Development
  debug: false,                    // Enable debug logging

  // Paths
  agentsConfigPath: './agents.yaml',
  contextPath: './.agent-context'
});

// Analysis events
orchestrator.on('analysis:start', ({ request }) => {});
orchestrator.on('analysis:complete', (analysis) => {});

// Workflow events
orchestrator.on('workflow:generating', (analysis) => {});
orchestrator.on('workflow:generated', (workflow) => {});
orchestrator.on('workflow:optimized', (workflow) => {});

// Execution events
orchestrator.on('execution:start', ({ workflow }) => {});
orchestrator.on('execution:complete', (result) => {});
orchestrator.on('execution:error', (error) => {});

// Step events
orchestrator.on('step:start', ({ workflowId, step }) => {});
orchestrator.on('step:complete', ({ workflowId, result }) => {});
orchestrator.on('step:error', ({ workflowId, result }) => {});

// Recovery events
orchestrator.on('recovery:start', ({ workflowId, step }) => {});
orchestrator.on('recovery:success', ({ workflowId, step, attempt }) => {});
orchestrator.on('recovery:failed', ({ workflowId, step, maxRetries }) => {});

// Learning events
orchestrator.on('learning:recorded', (learningData) => {});

// Existing agent scripts still work
node scripts/agent-communication.js

// New AI-powered orchestrator adds capabilities
const orchestrator = createOrchestrator();
await orchestrator.executeTask('Same task, smarter execution');

// Solution: Set API key explicitly
const orchestrator = createOrchestrator({
  anthropicApiKey: 'your-key-here'
});

// Solution: Reduce timeout or disable parallelization
const orchestrator = createOrchestrator({
  timeout: 60000,  // 60 seconds
  enableParallelExecution: false
});

// Solution: Adjust retry settings
const orchestrator = new IntelligentAgentOrchestrator({
  maxRetries: 1,  // Reduce retries
  enableAutoRecovery: false  // Disable recovery
});