import { Command } from 'commander';
import { ConfigLoader } from '../../config/ConfigLoader';
import { Configuration } from '../../config/Configuration';

export class ConfigCommand extends Command {
  constructor() {
    super('config');
    this.description('Manage AI Developer Assistant configuration');
    
    this.command('show')
         .description('Show current configuration')
         .option('--format <format>', 'Output format (json, yaml)', 'yaml')
         .action(async (options) => {
           try {
             const config = await ConfigLoader.loadConfiguration();
             const output = options.format === 'json' 
               ? JSON.stringify(config, null, 2)
               : require('yaml').stringify(config);
             console.log(output);
           } catch (error) {
             console.error(`Failed to show configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
             process.exit(1);
           }
         });

    this.command('validate')
         .description('Validate configuration file')
         .option('-c, --config <path>', 'Path to configuration file')
         .action(async (options) => {
           try {
             const config = await ConfigLoader.loadConfiguration(options.config);
             const validation = await ConfigLoader.validateConfiguration(config);
             
             if (validation.isValid) {
               console.log('✅ Configuration is valid');
             } else {
               console.log('❌ Configuration is invalid');
               console.log('Errors:');
               validation.errors.forEach(error => console.log(`  - ${error}`));
             }
             
             if (validation.warnings.length > 0) {
               console.log('Warnings:');
               validation.warnings.forEach(warning => console.log(`  - ${warning}`));
             }
           } catch (error) {
             console.error(`Failed to validate configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
             process.exit(1);
           }
         });

    this.command('init')
         .description('Initialize configuration file')
         .option('-c, --config <path>', 'Path to configuration file', './ai-dev.config.yaml')
         .option('--interactive', 'Interactive configuration setup')
         .action(async (options) => {
           try {
             if (options.interactive) {
               await this.interactiveConfigSetup(options.config);
             } else {
               const config = await ConfigLoader.loadConfiguration();
               await ConfigLoader.saveConfiguration(config, options.config);
               console.log(`Configuration saved to ${options.config}`);
             }
           } catch (error) {
             console.error(`Failed to initialize configuration: ${error instanceof Error ? error.message : 'Unknown error'}`);
             process.exit(1);
           }
         });
  }

  private async interactiveConfigSetup(configPath: string): Promise<void> {
    const inquirer = require('inquirer');
    
    const questions = [
      {
        type: 'list',
        name: 'llmProvider',
        message: 'Which LLM provider would you like to use?',
        choices: ['openai', 'ollama', 'gemini'],
        default: 'openai',
      },
      {
        type: 'input',
        name: 'openaiApiKey',
        message: 'Enter your OpenAI API key:',
        when: (answers: any) => answers.llmProvider === 'openai',
      },
      {
        type: 'input',
        name: 'ollamaBaseUrl',
        message: 'Enter Ollama base URL:',
        default: 'http://localhost:11434',
        when: (answers: any) => answers.llmProvider === 'ollama',
      },
      {
        type: 'input',
        name: 'geminiApiKey',
        message: 'Enter your Gemini API key:',
        when: (answers: any) => answers.llmProvider === 'gemini',
      },
      {
        type: 'input',
        name: 'geminiModel',
        message: 'Enter Gemini model:',
        default: 'gemini-2.0-flash',
        when: (answers: any) => answers.llmProvider === 'gemini',
      },
      {
        type: 'input',
        name: 'githubToken',
        message: 'Enter your GitHub token (optional):',
      },
      {
        type: 'list',
        name: 'outputFormat',
        message: 'Default output format:',
        choices: ['console', 'markdown', 'json', 'html'],
        default: 'console',
      },
      {
        type: 'confirm',
        name: 'enableSecurity',
        message: 'Enable security scanning?',
        default: true,
      },
      {
        type: 'confirm',
        name: 'enableTests',
        message: 'Enable test generation?',
        default: true,
      },
      {
        type: 'confirm',
        name: 'enableDocs',
        message: 'Enable documentation generation?',
        default: true,
      },
    ];

    const answers = await inquirer.prompt(questions);
    
    // Build configuration from answers
    const config: any = {
      llm: {
        provider: answers.llmProvider,
        model: answers.llmProvider === 'openai' ? 'gpt-4' : answers.llmProvider === 'gemini' ? 'gemini-2.0-flash' : 'llama2',
        temperature: 0.7,
        maxTokens: 2000,
        timeout: 30000,
      },
      openai: answers.llmProvider === 'openai' ? {
        apiKey: answers.openaiApiKey,
        baseUrl: 'https://api.openai.com/v1',
      } : undefined,
      ollama: answers.llmProvider === 'ollama' ? {
        enabled: true,
        baseUrl: answers.ollamaBaseUrl,
        model: 'llama2',
      } : undefined,
      gemini: answers.llmProvider === 'gemini' ? {
        apiKey: answers.geminiApiKey,
        model: answers.geminiModel || 'gemini-2.0-flash',
        temperature: 0.7,
        maxTokens: 2000,
      } : undefined,
      github: answers.githubToken ? {
        token: answers.githubToken,
        baseUrl: 'https://api.github.com',
        apiVersion: '2022-11-28',
      } : undefined,
      git: {
        repoPath: process.cwd(),
        defaultBranch: 'main',
        includeStaged: true,
        includeUnstaged: true,
      },
      output: {
        format: answers.outputFormat,
        colorize: true,
        verbose: false,
      },
      security: {
        enabled: answers.enableSecurity,
        severity: ['low', 'medium', 'high', 'critical'],
        categories: ['injection', 'authentication', 'authorization', 'cryptography', 'data_exposure', 'input_validation', 'dependency', 'configuration', 'logging', 'other'],
        includeDependencies: true,
      },
      test: {
        enabled: answers.enableTests,
        framework: 'jest',
        testType: 'unit',
        language: 'typescript',
        includeSetup: true,
        includeTeardown: true,
        coverageTarget: 80,
      },
      documentation: {
        enabled: answers.enableDocs,
        format: 'markdown',
        language: 'typescript',
        includeExamples: true,
        includeParameters: true,
        includeReturnTypes: true,
        includeSeeAlso: true,
        style: 'technical',
      },
      review: {
        enabled: true,
        severity: ['info', 'warning', 'error', 'suggestion'],
        categories: ['style', 'logic', 'security', 'performance', 'maintainability', 'documentation', 'testing', 'accessibility'],
        outputFormat: 'console',
        postToGitHub: false,
      },
      filePatterns: ['**/*.ts', '**/*.js', '**/*.tsx', '**/*.jsx', '**/*.py', '**/*.java', '**/*.cpp', '**/*.c', '**/*.cs', '**/*.php', '**/*.rb', '**/*.go', '**/*.rs'],
      excludePatterns: ['**/node_modules/**', '**/dist/**', '**/build/**', '**/.git/**', '**/coverage/**'],
      verbose: false,
      debug: false,
    };

    await ConfigLoader.saveConfiguration(config, configPath);
    console.log(`Configuration saved to ${configPath}`);
  }
}