/**
 * Basic SkillKit Usage Examples
 * Demonstrates core functionality
 */

import {
  initializeConfig,
  getConfig,
  SkillRunner,
  executeSkill,
  ModelProvider,
} from '../src/index.js';

/**
 * Example 1: Initialize configuration
 */
async function example1_InitializeConfig() {
  console.log('=== Example 1: Initialize Configuration ===\n');

  // Initialize with custom config directory
  const config = initializeConfig('/home/user/.skillkit');

  // Set API keys
  config.setApiKey(ModelProvider.ANTHROPIC, 'sk-ant-...');
  config.setApiKey(ModelProvider.OPENAI, 'sk-proj-...');

  // Set default provider
  config.setDefaultProvider(ModelProvider.ANTHROPIC);

  // Configure model
  config.setModel(ModelProvider.ANTHROPIC, 'claude-3-5-sonnet-20241022');
  config.setMaxTokens(4096);

  // Save configuration
  config.save();

  console.log('Configuration saved to:', config.getConfigPath());
  console.log('Default provider:', config.getDefaultProvider());
  console.log('Default model:', config.getModel(ModelProvider.ANTHROPIC));
}

/**
 * Example 2: Execute a simple skill
 */
async function example2_SimpleExecution() {
  console.log('\n=== Example 2: Simple Skill Execution ===\n');

  // Get global config
  const config = getConfig();
  config.setApiKey(ModelProvider.ANTHROPIC, process.env.ANTHROPIC_API_KEY!);
  config.setDefaultProvider(ModelProvider.ANTHROPIC);

  const result = await executeSkill(
    '/path/to/skill.md', // Could be file path or registry ID
    {
      topic: 'machine learning',
      language: 'spanish',
    },
    {
      streaming: false,
      timeout: 30000,
      maxTokens: 2048,
    }
  );

  if (result.success) {
    console.log('Execution successful!');
    console.log('Output:', result.outputs);
    console.log('Duration:', result.duration, 'ms');
    console.log('Tokens used:', result.usage?.totalTokens);
  } else {
    console.error('Execution failed:', result.error);
  }
}

/**
 * Example 3: Using SkillRunner for advanced control
 */
async function example3_SkillRunnerAdvanced() {
  console.log('\n=== Example 3: Advanced SkillRunner Usage ===\n');

  const runner = new SkillRunner({
    verbose: true,
    skipSecurityScans: false,
  });

  // Listen to execution events
  runner.on('execution:start', (data) => {
    console.log(`Started executing: ${data.skillName}`);
  });

  runner.on('execution:complete', (data) => {
    console.log(`Completed executing: ${data.skillName}`);
  });

  runner.on('execution:error', (data) => {
    console.error(`Error in ${data.executionId}:`, data.error);
  });

  // Execute with custom options
  const result = await runner.executeSkill(
    'search-master-5x', // From ClawHub registry
    {
      query: 'latest TypeScript frameworks 2026',
      maxResults: 5,
    },
    {
      provider: ModelProvider.OPENAI,
      model: 'gpt-4-turbo',
      streaming: true,
      onChunk: (chunk) => {
        if (chunk.type === 'content') {
          console.log('Streaming:', chunk.content);
        }
      },
    }
  );

  console.log('\nFinal result:', result.outputs);
}

/**
 * Example 4: Batch execution
 */
async function example4_BatchExecution() {
  console.log('\n=== Example 4: Batch Skill Execution ===\n');

  const runner = new SkillRunner();

  const batchResult = await runner.executeBatch({
    skillPath: 'summarizer',
    inputs: [
      { text: 'Long article 1...', language: 'en' },
      { text: 'Long article 2...', language: 'en' },
      { text: 'Long article 3...', language: 'en' },
    ],
    options: {
      provider: ModelProvider.ANTHROPIC,
      timeout: 30000,
    },
    continueOnError: true,
  });

  console.log(`Batch completed: ${batchResult.succeeded}/${batchResult.total} succeeded`);
  console.log('Total duration:', batchResult.duration, 'ms');

  for (const result of batchResult.results) {
    if ('success' in result && result.success) {
      console.log('Success:', result.outputs);
    } else if ('error' in result) {
      console.error('Failed:', result.error);
    }
  }
}

/**
 * Example 5: Configuration management
 */
async function example5_ConfigManagement() {
  console.log('\n=== Example 5: Configuration Management ===\n');

  const config = getConfig();

  // Get current config
  const fullConfig = config.getConfig();
  console.log('Current language:', config.getLanguage());
  console.log('Timeout:', config.getTimeout(), 'ms');
  console.log('Security level:', config.getSecurityLevel());

  // Update settings
  config.setLanguage('es');
  config.setTimeout(45000);
  config.setSecurityLevel('strict');

  // Custom settings
  config.setCustom('myOrganization', 'ACME Corp');
  config.setCustom('customApiEndpoint', 'https://api.acme.com');

  console.log('\nUpdated settings:');
  console.log('Language:', config.getLanguage());
  console.log('Organization:', config.getCustom('myOrganization'));

  // Validate API keys
  const validation = config.validateApiKeys([
    ModelProvider.ANTHROPIC,
    ModelProvider.OPENAI,
  ]);

  console.log('API keys valid:', validation.valid);
  if (!validation.valid) {
    console.log('Missing keys:', validation.missing);
  }

  config.save();
}

/**
 * Example 6: Multiple providers
 */
async function example6_MultipleProviders() {
  console.log('\n=== Example 6: Multi-Provider Execution ===\n');

  const runner = new SkillRunner();
  const skillPath = 'content-writer';
  const input = { topic: 'AI trends', wordCount: 500 };

  const providers = [
    ModelProvider.ANTHROPIC,
    ModelProvider.OPENAI,
    ModelProvider.GOOGLE,
  ];

  const results = await Promise.all(
    providers.map((provider) =>
      runner.executeSkill(skillPath, input, { provider })
    )
  );

  for (let i = 0; i < results.length; i++) {
    const result = results[i];
    console.log(
      `${providers[i]} result:`,
      result.success ? 'Success' : 'Failed'
    );
    console.log('  Duration:', result.duration, 'ms');
    console.log('  Model:', result.modelUsed);
  }
}

/**
 * Example 7: Error handling
 */
async function example7_ErrorHandling() {
  console.log('\n=== Example 7: Error Handling ===\n');

  const runner = new SkillRunner();

  try {
    const result = await runner.executeSkill(
      'nonexistent-skill',
      { foo: 'bar' },
      { timeout: 5000 }
    );

    if (!result.success) {
      console.error('Execution failed:');
      console.error('  Status:', result.status);
      console.error('  Error:', result.error);
    }
  } catch (error) {
    console.error('Error during execution:', error);
  }
}

/**
 * Run all examples
 */
async function main() {
  try {
    // Uncomment examples to run
    // await example1_InitializeConfig();
    // await example2_SimpleExecution();
    // await example3_SkillRunnerAdvanced();
    // await example4_BatchExecution();
    // await example5_ConfigManagement();
    // await example6_MultipleProviders();
    // await example7_ErrorHandling();

    console.log('\nAll examples completed!');
  } catch (error) {
    console.error('Fatal error:', error);
    process.exit(1);
  }
}

main();