#!/usr/bin/env node
import { Command } from 'commander';
import chalk from 'chalk';
import { ProjectState } from '../core/project-state';
import { ResourceManager } from '../core/resource-manager';
import { PersonaManager } from '../core/persona-manager';
import { AuthManager } from '../core/auth-manager';
import { SupabaseCommands } from '../commands/supabase';
import { WorkflowCommands } from '../commands/workflow';

const program = new Command();

// Initialize core systems
const projectState = new ProjectState();
const resourceManager = new ResourceManager();
const personaManager = new PersonaManager(resourceManager);
const supabaseCommands = new SupabaseCommands();
const workflowCommands = new WorkflowCommands();

program
  .name('vcsys')
  .description(chalk.bold('🚀 The ultimate CLI for founders to build and deploy SaaS applications'))
  .version('1.0.0');

program
  .command('init <project-name>')
  .description('Initialize a new VC-SYS project')
  .option('-t, --template <template>', 'Project template to use', 'saas-starter')
  .action(async (projectName, options) => {
    console.log(chalk.blue('🚀 Initializing VC-SYS project:'), chalk.bold(projectName));
    
    try {
      await projectState.initialize(projectName, options.template);
      console.log(chalk.green('✅ Project initialized successfully!'));
      console.log(chalk.gray('Next steps:'));
      console.log(chalk.gray('  1. Run: vcsys mentor'));
      console.log(chalk.gray('  2. Start with idea validation: vcsys gauntlet'));
    } catch (error) {
      console.error(chalk.red('❌ Failed to initialize project:'), error);
      process.exit(1);
    }
  });

program
  .command('mentor')
  .description('Chat with The Mentor (Master Orchestrator)')
  .action(async () => {
    console.log(chalk.magenta('🎭 The Mentor: Welcome! I can help you navigate VC-SYS personas.'));
    
    try {
      const mentor = await personaManager.loadPersona('the-mentor');
      await mentor.interact();
    } catch (error) {
      console.error(chalk.red('❌ Failed to load The Mentor:'), error);
      console.log(chalk.yellow('💡 This will be implemented in Phase 1, Task 6.1.1'));
    }
  });

program
  .command('gauntlet')
  .description('Validate ideas with The Gauntlet')
  .argument('[idea]', 'The idea to validate')
  .action(async (idea) => {
    console.log(chalk.red('⚔️  The Gauntlet: Ready to challenge your assumptions!'));
    
    if (idea) {
      console.log(chalk.yellow('💡 Validating idea:'), idea);
    }
    
    try {
      const gauntlet = await personaManager.loadPersona('the-gauntlet');
      await gauntlet.interact();
    } catch (error) {
      console.error(chalk.red('❌ Failed to load The Gauntlet:'), error);
      console.log(chalk.yellow('💡 This will be implemented in Phase 1, Task 6.1.2'));
    }
  });

program
  .command('architect')
  .description('Create PRDs and technical architecture with The Architect')
  .action(async () => {
    console.log(chalk.blue('🏗️  The Architect: Ready to design your technical architecture!'));
    
    try {
      const architect = await personaManager.loadPersona('the-architect');
      await architect.interact();
    } catch (error) {
      console.error(chalk.red('❌ Failed to load The Architect:'), error);
      console.log(chalk.yellow('💡 Make sure you have completed idea validation first'));
    }
  });

program
  .command('database-wizard')
  .description('Draft database schemas and provision Supabase backends')
  .option('-r, --requirements <file>', 'Requirements file for schema generation')
  .action(async (options) => {
    console.log(chalk.blue('🧙 Database Wizard: Ready to architect your database!'));
    
    try {
      const wizard = await personaManager.loadPersona('database-wizard');
      await wizard.interact();
    } catch (error) {
      console.error(chalk.red('❌ Failed to load Database Wizard:'), error);
      console.log(chalk.yellow('💡 Make sure you have completed technical architecture first'));
    }
  });

program
  .command('status')
  .description('Show current project status')
  .action(async () => {
    try {
      const status = await projectState.getStatus();
      console.log(chalk.blue('📊 Project Status:'));
      console.log(status);
    } catch (error) {
      console.error(chalk.red('❌ No VC-SYS project found in current directory'));
      console.log(chalk.gray('💡 Run: vcsys init <project-name> to get started'));
    }
  });

program
  .command('validate-resources')
  .description('Validate CLI resources and dependencies')
  .action(async () => {
    console.log(chalk.blue('🔍 Validating VC-SYS resources...'));
    
    try {
      const validation = await resourceManager.validateResources();
      console.log(validation);
    } catch (error) {
      console.error(chalk.red('❌ Resource validation failed:'), error);
    }
  });

program
  .command('generate-document <template> [variables...]')
  .description('Generate a document from a template')
  .option('-o, --output <filename>', 'Output filename')
  .action(async (templateName, variableArgs, options) => {
    console.log(chalk.blue(`📄 Generating document from template: ${templateName}`));
    
    try {
      // Parse variables from command line args
      const variables: Record<string, any> = {};
      variableArgs.forEach((arg: string) => {
        const [key, value] = arg.split('=');
        if (key && value) {
          variables[key] = value;
        }
      });
      
      // Add default variables
      variables.current_date = new Date().toLocaleDateString();
      variables.project_name = variables.project_name || 'My Project';
      
      const document = await resourceManager.renderTemplate(templateName, variables);
      
      if (options.output) {
        const projectState = new ProjectState();
        const projectRoot = projectState.getProjectRoot();
        const filePath = await resourceManager.saveDocument(document, options.output, projectRoot);
        console.log(chalk.green(`✅ Document saved to: ${filePath}`));
      } else {
        console.log(chalk.blue('\n📄 Generated Document:'));
        console.log(chalk.gray('─'.repeat(50)));
        console.log(document);
        console.log(chalk.gray('─'.repeat(50)));
      }
    } catch (error) {
      console.error(chalk.red('❌ Failed to generate document:'), error);
    }
  });

// Register Supabase commands
supabaseCommands.registerCommands(program);

// Register Workflow commands
workflowCommands.registerCommands(program);

// Global error handler
program.exitOverride((err) => {
  if (err.code === 'commander.help') {
    process.exit(0);
  }
  console.error(chalk.red('❌ CLI Error:'), err.message);
  process.exit(1);
});

// Parse command line arguments
program.parse(process.argv);

// Show help if no command provided
if (!process.argv.slice(2).length) {
  program.outputHelp();
}