09-cli-tool.ts

#!/usr/bin/env node
/**
 * 🖥️ CLI Tool Example
 *
 * This example demonstrates building a command-line interface for azubiheft-api:
 * - Interactive CLI with commands and subcommands
 * - Configuration management
 * - Progress indicators and user feedback
 * - Input validation and error handling
 * - Batch operations and automation
 * - Help system and documentation
 */

import {
  Session,
  Entry,
  EntryType,
  TimeHelper,
  isAuthError,
  isNotLoggedInError
} from '../src/index.js';

interface CLIConfig {
  username?: string;
  password?: string;
  baseUrl?: string;
  defaultDuration?: string;
  autoLogin?: boolean;
}

interface Command {
  name: string;
  description: string;
  usage: string;
  handler: (args: string[], config: CLIConfig) => Promise<void>;
  examples?: string[];
}

class AzubiheftCLI {
  private session: Session;
  private config: CLIConfig = {};
  private commands: Map<string, Command> = new Map();

  constructor() {
    this.session = new Session();
    this.setupCommands();
    this.loadConfig();
  }

  private setupCommands(): void {
    const commands: Command[] = [
      {
        name: 'login',
        description: 'Login to azubiheft.de',
        usage: 'login [username] [password]',
        handler: this.handleLogin.bind(this),
        examples: [
          'login myuser mypass',
          'login  # Interactive prompt'
        ]
      },
      {
        name: 'logout',
        description: 'Logout from azubiheft.de',
        usage: 'logout',
        handler: this.handleLogout.bind(this)
      },
      {
        name: 'status',
        description: 'Show login status and account info',
        usage: 'status',
        handler: this.handleStatus.bind(this)
      },
      {
        name: 'add',
        description: 'Add a new report entry',
        usage: 'add <message> [duration] [type]',
        handler: this.handleAdd.bind(this),
        examples: [
          'add "Worked on API development" 04:00 work',
          'add "Attended programming class" 03:30 school',
          'add "Code review session"  # Uses default duration'
        ]
      },
      {
        name: 'list',
        description: 'List reports for a date',
        usage: 'list [date]',
        handler: this.handleList.bind(this),
        examples: [
          'list',
          'list 2024-01-15',
          'list today',
          'list yesterday'
        ]
      },
      {
        name: 'delete',
        description: 'Delete reports for a date',
        usage: 'delete [date] [entry_number]',
        handler: this.handleDelete.bind(this),
        examples: [
          'delete  # Delete all entries for today',
          'delete 2024-01-15  # Delete all entries for specific date',
          'delete today 1  # Delete first entry for today'
        ]
      },
      {
        name: 'subjects',
        description: 'Manage subjects',
        usage: 'subjects [list|add|delete] [name|id]',
        handler: this.handleSubjects.bind(this),
        examples: [
          'subjects list',
          'subjects add "Web Development"',
          'subjects delete 123'
        ]
      },
      {
        name: 'week',
        description: 'Show weekly summary',
        usage: 'week [date]',
        handler: this.handleWeek.bind(this),
        examples: [
          'week',
          'week 2024-01-15'
        ]
      },
      {
        name: 'export',
        description: 'Export data to file',
        usage: 'export <format> [filename] [date_range]',
        handler: this.handleExport.bind(this),
        examples: [
          'export json reports.json',
          'export csv data.csv last-week',
          'export html report.html 2024-01-01:2024-01-31'
        ]
      },
      {
        name: 'config',
        description: 'Manage CLI configuration',
        usage: 'config [get|set|list] [key] [value]',
        handler: this.handleConfig.bind(this),
        examples: [
          'config list',
          'config set defaultDuration 08:00',
          'config get username'
        ]
      },
      {
        name: 'help',
        description: 'Show help information',
        usage: 'help [command]',
        handler: this.handleHelp.bind(this)
      }
    ];

    commands.forEach(cmd => this.commands.set(cmd.name, cmd));
  }

  async run(args: string[]): Promise<void> {
    if (args.length === 0) {
      this.showWelcome();
      return;
    }

    const [commandName, ...commandArgs] = args;
    const command = this.commands.get(commandName);

    if (!command) {
      console.error(`❌ Unknown command: ${commandName}`);
      console.log('💡 Use "help" to see available commands');
      process.exit(1);
    }

    try {
      await command.handler(commandArgs, this.config);
    } catch (error) {
      console.error(`❌ Command failed: ${error.message}`);

      if (isAuthError(error)) {
        console.log('💡 Try logging in first with: login');
      } else if (isNotLoggedInError(error)) {
        console.log('💡 You need to login first: login');
      }

      process.exit(1);
    }
  }

  private showWelcome(): void {
    console.log(`
🚀 Azubiheft CLI Tool

Usage: azubiheft-cli <command> [options]

Quick Start:
  azubiheft-cli login                    # Login to your account
  azubiheft-cli add "Daily work" 08:00   # Add a report entry
  azubiheft-cli list                     # Show today's entries
  azubiheft-cli help                     # Show all commands

💡 Use "azubiheft-cli help <command>" for detailed help on any command.
`);
  }

  private async handleLogin(args: string[], config: CLIConfig): Promise<void> {
    let username = args[0] || config.username;
    let password = args[1] || config.password;

    if (!username) {
      username = await this.promptInput('Username: ');
    }

    if (!password) {
      password = await this.promptInput('Password: ', true);
    }

    console.log('🔐 Logging in...');

    try {
      await this.session.login({ username, password });
      console.log('✅ Login successful!');

      // Save credentials if not provided via config
      if (!config.username) {
        this.config.username = username;
        this.saveConfig();
      }
    } catch (error) {
      if (isAuthError(error)) {
        console.error('❌ Login failed: Invalid credentials');
      } else {
        throw error;
      }
    }
  }

  private async handleLogout(): Promise<void> {
    await this.session.logout();
    console.log('👋 Logged out successfully');
  }

  private async handleStatus(): Promise<void> {
    const isLoggedIn = await this.session.isLoggedIn();

    if (isLoggedIn) {
      console.log('✅ Status: Logged in');

      try {
        const subjects = await this.session.getSubjects();
        console.log(`📚 Available subjects: ${subjects.length}`);

        const today = new Date();
        const reports = await this.session.getReport(today);
        console.log(`📋 Today's entries: ${reports.length}`);
      } catch (error) {
        console.log('⚠️ Could not fetch account details');
      }
    } else {
      console.log('❌ Status: Not logged in');
      console.log('💡 Use "login" command to authenticate');
    }
  }

  private async handleAdd(args: string[], config: CLIConfig): Promise<void> {
    if (args.length === 0) {
      console.error('❌ Message is required');
      console.log('Usage: add <message> [duration] [type]');
      return;
    }

    const message = args[0];
    const duration = args[1] || config.defaultDuration || '08:00';
    const typeArg = args[2] || 'work';

    // Parse entry type
    const entryType = this.parseEntryType(typeArg);

    console.log(`📝 Adding entry: "${message}" (${duration})`);

    const entry = new Entry(new Date(), message, duration, entryType);

    try {
      entry.validate();
      await this.session.writeReports([entry]);
      console.log('✅ Entry added successfully!');
    } catch (error) {
      console.error(`❌ Failed to add entry: ${error.message}`);
    }
  }

  private async handleList(args: string[]): Promise<void> {
    const dateArg = args[0] || 'today';
    const date = this.parseDate(dateArg);

    console.log(`📋 Reports for ${date.toDateString()}:`);

    try {
      const reports = await this.session.getReport(date);

      if (reports.length === 0) {
        console.log('📭 No entries found');
        return;
      }

      reports.forEach((report, index) => {
        console.log(`  ${index + 1}. [${report.type}] ${report.duration} - ${report.text.substring(0, 60)}${report.text.length > 60 ? '...' : ''}`);
      });

      // Calculate total time
      const totalMinutes = reports.reduce((sum, report) => {
        return sum + TimeHelper.timeStringToMinutes(report.duration);
      }, 0);

      console.log(`\n⏱️ Total time: ${TimeHelper.minutesToTimeString(totalMinutes)}`);
    } catch (error) {
      console.log('📭 No entries found for this date');
    }
  }

  private async handleDelete(args: string[]): Promise<void> {
    const dateArg = args[0] || 'today';
    const entryNumber = args[1] ? parseInt(args[1]) : undefined;
    const date = this.parseDate(dateArg);

    if (entryNumber) {
      console.log(`🗑️ Deleting entry #${entryNumber} for ${date.toDateString()}...`);
    } else {
      console.log(`🗑️ Deleting all entries for ${date.toDateString()}...`);
    }

    // Confirm deletion
    const confirmed = await this.promptConfirm('Are you sure? (y/N): ');
    if (!confirmed) {
      console.log('❌ Deletion cancelled');
      return;
    }

    try {
      await this.session.deleteReport(date, entryNumber);
      console.log('✅ Entries deleted successfully!');
    } catch (error) {
      console.error(`❌ Failed to delete: ${error.message}`);
    }
  }

  private async handleSubjects(args: string[]): Promise<void> {
    const action = args[0] || 'list';

    switch (action) {
      case 'list':
        await this.listSubjects();
        break;
      case 'add':
        if (!args[1]) {
          console.error('❌ Subject name is required');
          return;
        }
        await this.addSubject(args[1]);
        break;
      case 'delete':
        if (!args[1]) {
          console.error('❌ Subject ID is required');
          return;
        }
        await this.deleteSubject(args[1]);
        break;
      default:
        console.error(`❌ Unknown subjects action: ${action}`);
        console.log('Available actions: list, add, delete');
    }
  }

  private async listSubjects(): Promise<void> {
    console.log('📚 Available subjects:');

    try {
      const subjects = await this.session.getSubjects();
      subjects.forEach(subject => {
        const isBuiltIn = parseInt(subject.id) <= 7;
        console.log(`  ${isBuiltIn ? '🔧' : '⭐'} ${subject.name} (ID: ${subject.id})`);
      });
    } catch (error) {
      console.error(`❌ Failed to fetch subjects: ${error.message}`);
    }
  }

  private async addSubject(name: string): Promise<void> {
    console.log(`➕ Adding subject: "${name}"`);

    try {
      await this.session.addSubject(name);
      console.log('✅ Subject added successfully!');
    } catch (error) {
      console.error(`❌ Failed to add subject: ${error.message}`);
    }
  }

  private async deleteSubject(id: string): Promise<void> {
    console.log(`🗑️ Deleting subject ID: ${id}`);

    const confirmed = await this.promptConfirm('Are you sure? (y/N): ');
    if (!confirmed) {
      console.log('❌ Deletion cancelled');
      return;
    }

    try {
      await this.session.deleteSubject(id);
      console.log('✅ Subject deleted successfully!');
    } catch (error) {
      console.error(`❌ Failed to delete subject: ${error.message}`);
    }
  }

  private async handleWeek(args: string[]): Promise<void> {
    const dateArg = args[0] || 'today';
    const date = this.parseDate(dateArg);
    const weekInfo = TimeHelper.getISOWeek(date);

    console.log(`📅 Weekly summary for Week ${weekInfo.week}/${weekInfo.year}:`);

    // This is a simplified implementation
    // In a full CLI, you'd implement proper weekly aggregation
    console.log('⚠️ Full weekly summary feature not implemented in this example');
    console.log('💡 This would show aggregated data for the entire week');
  }

  private async handleExport(args: string[]): Promise<void> {
    if (args.length === 0) {
      console.error('❌ Export format is required');
      console.log('Available formats: json, csv, html, markdown');
      return;
    }

    const format = args[0];
    const filename = args[1] || `azubiheft-export.${format}`;

    console.log(`📤 Exporting data in ${format.toUpperCase()} format...`);
    console.log('⚠️ Export feature not fully implemented in this example');
    console.log(`💡 Would export to: ${filename}`);
  }

  private async handleConfig(args: string[]): Promise<void> {
    const action = args[0] || 'list';

    switch (action) {
      case 'list':
        console.log('⚙️ Current configuration:');
        Object.entries(this.config).forEach(([key, value]) => {
          const displayValue = key === 'password' ? '*'.repeat(8) : value;
          console.log(`  ${key}: ${displayValue}`);
        });
        break;
      case 'get':
        if (!args[1]) {
          console.error('❌ Config key is required');
          return;
        }
        const value = this.config[args[1] as keyof CLIConfig];
        console.log(`${args[1]}: ${value || 'not set'}`);
        break;
      case 'set':
        if (!args[1] || !args[2]) {
          console.error('❌ Config key and value are required');
          return;
        }
        (this.config as any)[args[1]] = args[2];
        this.saveConfig();
        console.log(`✅ Set ${args[1]} = ${args[2]}`);
        break;
      default:
        console.error(`❌ Unknown config action: ${action}`);
    }
  }

  private async handleHelp(args: string[]): Promise<void> {
    if (args.length === 0) {
      this.showAllCommands();
    } else {
      this.showCommandHelp(args[0]);
    }
  }

  private showAllCommands(): void {
    console.log('🚀 Azubiheft CLI Commands:\n');

    this.commands.forEach(command => {
      console.log(`📋 ${command.name.padEnd(12)} ${command.description}`);
      console.log(`   Usage: azubiheft-cli ${command.usage}\n`);
    });

    console.log('💡 Use "help <command>" for detailed information about a specific command.');
  }

  private showCommandHelp(commandName: string): void {
    const command = this.commands.get(commandName);

    if (!command) {
      console.error(`❌ Unknown command: ${commandName}`);
      return;
    }

    console.log(`📋 Command: ${command.name}`);
    console.log(`📄 Description: ${command.description}`);
    console.log(`💻 Usage: azubiheft-cli ${command.usage}`);

    if (command.examples && command.examples.length > 0) {
      console.log('\n💡 Examples:');
      command.examples.forEach(example => {
        console.log(`   azubiheft-cli ${example}`);
      });
    }
  }

  private parseEntryType(typeArg: string): EntryType {
    const typeMap: Record<string, EntryType> = {
      'work': EntryType.BETRIEB,
      'company': EntryType.BETRIEB,
      'betrieb': EntryType.BETRIEB,
      'school': EntryType.SCHULE,
      'schule': EntryType.SCHULE,
      'uba': EntryType.UBA,
      'vacation': EntryType.URLAUB,
      'urlaub': EntryType.URLAUB,
      'holiday': EntryType.FEIERTAG,
      'feiertag': EntryType.FEIERTAG,
      'sick': EntryType.ARBEITSUNFAHIG,
      'krank': EntryType.ARBEITSUNFAHIG,
      'free': EntryType.FREI,
      'frei': EntryType.FREI
    };

    return typeMap[typeArg.toLowerCase()] || EntryType.BETRIEB;
  }

  private parseDate(dateArg: string): Date {
    const today = new Date();

    switch (dateArg.toLowerCase()) {
      case 'today':
        return today;
      case 'yesterday':
        const yesterday = new Date(today);
        yesterday.setDate(today.getDate() - 1);
        return yesterday;
      case 'tomorrow':
        const tomorrow = new Date(today);
        tomorrow.setDate(today.getDate() + 1);
        return tomorrow;
      default:
        // Try to parse as ISO date
        const parsed = new Date(dateArg);
        if (isNaN(parsed.getTime())) {
          throw new Error(`Invalid date format: ${dateArg}`);
        }
        return parsed;
    }
  }

  private async promptInput(prompt: string, isPassword = false): Promise<string> {
    // In a real CLI, you'd use a proper input library like 'inquirer' or 'prompts'
    // This is a simplified version for the example
    process.stdout.write(prompt);

    return new Promise((resolve) => {
      const stdin = process.stdin;
      stdin.setRawMode(true);
      stdin.resume();
      stdin.setEncoding('utf8');

      let input = '';

      const onData = (char: string) => {
        if (char === '\r' || char === '\n') {
          stdin.setRawMode(false);
          stdin.pause();
          stdin.removeListener('data', onData);
          console.log();
          resolve(input);
        } else if (char === '\u0003') { // Ctrl+C
          process.exit();
        } else if (char === '\u007f') { // Backspace
          if (input.length > 0) {
            input = input.slice(0, -1);
            process.stdout.write('\b \b');
          }
        } else {
          input += char;
          process.stdout.write(isPassword ? '*' : char);
        }
      };

      stdin.on('data', onData);
    });
  }

  private async promptConfirm(prompt: string): Promise<boolean> {
    const response = await this.promptInput(prompt);
    return response.toLowerCase() === 'y' || response.toLowerCase() === 'yes';
  }

  private loadConfig(): void {
    // In a real CLI, you'd load from ~/.azubiheft-cli or similar
    this.config = {
      defaultDuration: '08:00',
      autoLogin: false
    };
  }

  private saveConfig(): void {
    // In a real CLI, you'd save to ~/.azubiheft-cli or similar
    console.log('💾 Configuration saved');
  }
}

// Example CLI runner
async function cliToolExample() {
  console.log('🖥️ Azubiheft CLI Tool Example\n');

  console.log('This example demonstrates how to build a CLI tool for azubiheft-api.');
  console.log('In a real implementation, you would:');
  console.log('');
  console.log('1. Install CLI dependencies:');
  console.log('   npm install commander inquirer chalk ora');
  console.log('');
  console.log('2. Add CLI binary to package.json:');
  console.log('   "bin": { "azubiheft-cli": "./dist/cli.js" }');
  console.log('');
  console.log('3. Build and link for local testing:');
  console.log('   npm run build && npm link');
  console.log('');
  console.log('4. Use the CLI globally:');
  console.log('   azubiheft-cli login');
  console.log('   azubiheft-cli add "Daily work" 08:00');
  console.log('   azubiheft-cli list');
  console.log('');

  // Simulate CLI usage
  const cli = new AzubiheftCLI();

  console.log('🎭 Simulating CLI commands:\n');

  console.log('$ azubiheft-cli help');
  await cli.run(['help']);

  console.log('\n$ azubiheft-cli help add');
  await cli.run(['help', 'add']);

  console.log('\n💡 To test with real credentials, modify the example or run:');
  console.log('   node examples/09-cli-tool.js login status');
}

// Export for use in other examples
export { AzubiheftCLI, CLIConfig };

// Run as CLI if called directly
if (import.meta.url === `file://${process.argv[1]}`) {
  const args = process.argv.slice(2);

  if (args.length > 0 && args[0] !== 'example') {
    // Run as actual CLI
    const cli = new AzubiheftCLI();
    cli.run(args).catch(error => {
      console.error('CLI error:', error);
      process.exit(1);
    });
  } else {
    // Run the example
    cliToolExample().catch(error => {
      console.error('💥 CLI tool example failed:', error);
      process.exit(1);
    });
  }
}