nupst/ts/cli/ups-handler.ts

import process from 'node:process';
import { execSync } from 'node:child_process';
import { Nupst } from '../nupst.ts';
import { logger, type ITableColumn } from '../logger.ts';
import { theme } from '../colors.ts';
import * as helpers from '../helpers/index.ts';
import type { TUpsModel } from '../snmp/types.ts';
import type { INupstConfig } from '../daemon.ts';

/**
 * Class for handling UPS-related CLI commands
 * Provides interface for managing UPS devices
 */
export class UpsHandler {
  private readonly nupst: Nupst;

  /**
   * Create a new UPS handler
   * @param nupst Reference to the main Nupst instance
   */
  constructor(nupst: Nupst) {
    this.nupst = nupst;
  }

  /**
   * Add a new UPS configuration
   */
  public async add(): Promise<void> {
    try {
      // Import readline module for user input
      const readline = await import('node:readline');

      const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
      });

      // Helper function to prompt for input
      const prompt = (question: string): Promise<string> => {
        return new Promise((resolve) => {
          rl.question(question, (answer: string) => {
            resolve(answer);
          });
        });
      };

      try {
        await this.runAddProcess(prompt);
      } finally {
        rl.close();
        process.stdin.destroy();
      }
    } catch (error) {
      logger.error(`Add UPS error: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * Run the interactive process to add a new UPS
   * @param prompt Function to prompt for user input
   */
  public async runAddProcess(prompt: (question: string) => Promise<string>): Promise<void> {
    logger.log('\nNUPST Add UPS');
    logger.log('=============\n');
    logger.log('This will guide you through configuring a new UPS.\n');

    // Try to load existing config if available
    let config;
    try {
      await this.nupst.getDaemon().loadConfig();
      config = this.nupst.getDaemon().getConfig();

      // Convert old format to new format if needed
      if (!config.upsDevices) {
        // Initialize with the current config as the first UPS
        config = {
          checkInterval: config.checkInterval,
          upsDevices: [{
            id: 'default',
        name: 'Default UPS',
        snmp: config.snmp,
        groups: [],
        actions: [],
          }],
          groups: [],
        };
        logger.log('Converting existing configuration to multi-UPS format.');
      }
    } catch (error) {
      // If config doesn't exist, initialize with empty config
      config = {
        checkInterval: 30000, // Default check interval
        upsDevices: [],
        groups: [],
      };
      logger.log('No existing configuration found. Creating a new configuration.');
    }

    // Get UPS ID and name
    const upsId = helpers.shortId();
    const name = await prompt('UPS Name: ');

    // Create a new UPS configuration object with defaults
    const newUps = {
      id: upsId,
      name: name || `UPS-${upsId}`,
      snmp: {
        host: '127.0.0.1',
        port: 161,
        community: 'public',
        version: 1,
        timeout: 5000,
        upsModel: 'cyberpower' as TUpsModel,
      },
      thresholds: {
        battery: 60,
        runtime: 20,
      },
      groups: [],
      actions: [],
    };

    // Gather SNMP settings
    await this.gatherSnmpSettings(newUps.snmp, prompt);

    // Gather threshold settings
    await this.gatherThresholdSettings(newUps.thresholds, prompt);

    // Gather UPS model settings
    await this.gatherUpsModelSettings(newUps.snmp, prompt);

    // Get access to GroupHandler for group assignments
    const groupHandler = this.nupst.getGroupHandler();

    // Assign to groups if any exist
    if (config.groups && config.groups.length > 0) {
      await groupHandler.assignUpsToGroups(newUps, config.groups, prompt);
    }

// Gather action settings
    await this.gatherActionSettings(newUps.actions, prompt);

    // Add the new UPS to the config
    config.upsDevices.push(newUps);

    // Save the configuration
    await this.nupst.getDaemon().saveConfig(config as INupstConfig);

    this.displayUpsConfigSummary(newUps);

    // Test the connection if requested
    await this.optionallyTestConnection(newUps.snmp, prompt);

    // Check if service is running and restart it if needed
    await this.restartServiceIfRunning();

    logger.log('\nSetup complete!');
  }

  /**
   * Edit an existing UPS configuration
   * @param upsId ID of the UPS to edit (undefined for default UPS)
   */
  public async edit(upsId?: string): Promise<void> {
    try {
      // Import readline module for user input
      const readline = await import('node:readline');

      const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
      });

      // Helper function to prompt for input
      const prompt = (question: string): Promise<string> => {
        return new Promise((resolve) => {
          rl.question(question, (answer: string) => {
            resolve(answer);
          });
        });
      };

      try {
        await this.runEditProcess(upsId, prompt);
      } finally {
        rl.close();
        process.stdin.destroy();
      }
    } catch (error) {
      logger.error(`Edit UPS error: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * Run the interactive process to edit a UPS
   * @param upsId ID of the UPS to edit (undefined for default UPS)
   * @param prompt Function to prompt for user input
   */
  public async runEditProcess(
    upsId: string | undefined,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    logger.log('\nNUPST Edit UPS');
    logger.log('=============\n');

    // Try to load existing config
    try {
      await this.nupst.getDaemon().loadConfig();
    } catch (error) {
      if (!upsId) {
        // For default UPS (no ID specified), run setup if no config exists
        logger.log('No existing configuration found. Running setup for new UPS.');
        await this.runAddProcess(prompt);
        return;
      } else {
        // For specific UPS ID, error if config doesn't exist
        logger.error('No configuration found. Please run "nupst setup" first.');
        return;
      }
    }

    // Get the config
    const config = this.nupst.getDaemon().getConfig();

    // Convert old format to new format if needed
    if (!config.upsDevices) {
      // Initialize with the current config as the first UPS
      if (!config.snmp) {
        logger.error('Legacy configuration is missing required SNMP settings');
        return;
      }
      config.upsDevices = [{
        id: 'default',
        name: 'Default UPS',
        snmp: config.snmp,
        groups: [],
        actions: [],
      }];
      config.groups = [];
      logger.log('Converting existing configuration to multi-UPS format.');
    }

    // Find the UPS to edit
    let upsToEdit;
    if (upsId) {
      // Find specific UPS by ID
      upsToEdit = config.upsDevices.find((ups) => ups.id === upsId);
      if (!upsToEdit) {
        logger.error(`UPS with ID "${upsId}" not found.`);
        return;
      }
      logger.log(`Editing UPS: ${upsToEdit.name} (${upsToEdit.id})\n`);
    } else {
      // For backward compatibility, edit the first UPS if no ID specified
      if (config.upsDevices.length === 0) {
        logger.error('No UPS devices configured. Please run "nupst add" to add a UPS.');
        return;
      }
      upsToEdit = config.upsDevices[0];
      logger.log(`Editing default UPS: ${upsToEdit.name} (${upsToEdit.id})\n`);
    }

    // Allow editing UPS name
    const newName = await prompt(`UPS Name [${upsToEdit.name}]: `);
    if (newName.trim()) {
      upsToEdit.name = newName;
    }

    // Edit SNMP settings
    await this.gatherSnmpSettings(upsToEdit.snmp, prompt);

    // Edit UPS model settings
    await this.gatherUpsModelSettings(upsToEdit.snmp, prompt);

    // Get access to GroupHandler for group assignments
    const groupHandler = this.nupst.getGroupHandler();

    // Edit group assignments
    if (config.groups && config.groups.length > 0) {
      await groupHandler.assignUpsToGroups(upsToEdit, config.groups, prompt);
    }

    // Initialize actions array if not exists
    if (!upsToEdit.actions) {
      upsToEdit.actions = [];
    }

    // Edit action settings
    await this.gatherActionSettings(upsToEdit.actions, prompt);

    // Save the configuration
    await this.nupst.getDaemon().saveConfig(config);

    this.displayUpsConfigSummary(upsToEdit);

    // Test the connection if requested
    await this.optionallyTestConnection(upsToEdit.snmp, prompt);

    // Check if service is running and restart it if needed
    await this.restartServiceIfRunning();

    logger.log('\nEdit complete!');
  }

  /**
   * Delete a UPS by ID
   * @param upsId ID of the UPS to delete
   */
  public async remove(upsId: string): Promise<void> {
    try {
      // Try to load configuration
      try {
        await this.nupst.getDaemon().loadConfig();
      } catch (error) {
        const errorBoxWidth = 45;
        logger.logBoxTitle('Configuration Error', errorBoxWidth);
        logger.logBoxLine('No configuration found.');
        logger.logBoxLine("Please run 'nupst setup' first to create a configuration.");
        logger.logBoxEnd();
        return;
      }

      // Get current configuration
      const config = this.nupst.getDaemon().getConfig();

      // Check if multi-UPS config
      if (!config.upsDevices || !Array.isArray(config.upsDevices)) {
        logger.error('Legacy single-UPS configuration detected. Cannot delete UPS.');
        logger.log('Use "nupst add" to migrate to multi-UPS configuration format first.');
        return;
      }

      // Find the UPS to delete
      const upsIndex = config.upsDevices.findIndex((ups) => ups.id === upsId);
      if (upsIndex === -1) {
        logger.error(`UPS with ID "${upsId}" not found.`);
        return;
      }

      const upsToDelete = config.upsDevices[upsIndex];

      // Get confirmation before deleting
      const readline = await import('node:readline');
      const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
      });

      const confirm = await new Promise<string>((resolve) => {
        rl.question(
          `Are you sure you want to delete UPS "${upsToDelete.name}" (${upsId})? [y/N]: `,
          (answer) => {
            resolve(answer.toLowerCase());
          },
        );
      });

      rl.close();
      process.stdin.destroy();

      if (confirm !== 'y' && confirm !== 'yes') {
        logger.log('Deletion cancelled.');
        return;
      }

      // Remove the UPS from the array
      config.upsDevices.splice(upsIndex, 1);

      // Save the configuration
      await this.nupst.getDaemon().saveConfig(config);

      logger.log(`UPS "${upsToDelete.name}" (${upsId}) has been deleted.`);

      // Check if service is running and restart it if needed
      await this.restartServiceIfRunning();
    } catch (error) {
      logger.error(
        `Failed to delete UPS: ${error instanceof Error ? error.message : String(error)}`,
      );
    }
  }

  /**
   * List all configured UPS devices
   */
  public async list(): Promise<void> {
    try {
      // Try to load configuration
      try {
        await this.nupst.getDaemon().loadConfig();
      } catch (error) {
        logger.logBox('Configuration Error', [
          'No configuration found.',
          "Please run 'nupst ups add' first to create a configuration.",
        ], 50, 'error');
        return;
      }

      // Get current configuration
      const config = this.nupst.getDaemon().getConfig();

      // Check if multi-UPS config
      if (!config.upsDevices || !Array.isArray(config.upsDevices)) {
        // Legacy single UPS configuration
        logger.logBox('UPS Devices', [
          'Legacy single-UPS configuration detected.',
          '',
          ...(!config.snmp 
            ? ['Error: Configuration missing SNMP settings']
            : [
                'Default UPS:',
                `  Host: ${config.snmp.host}:${config.snmp.port}`,
                `  Model: ${config.snmp.upsModel || 'cyberpower'}`,
                '',
                'Use "nupst ups add" to add more UPS devices and migrate',
                'to the multi-UPS configuration format.',
              ]
          ),
        ], 60, 'warning');
        return;
      }

      // Display UPS list with modern table
      if (config.upsDevices.length === 0) {
        logger.logBox('UPS Devices', [
          'No UPS devices configured.',
          '',
          `${theme.dim('Run')} ${theme.command('nupst ups add')} ${theme.dim('to add a device')}`,
        ], 60, 'info');
        return;
      }

      // Prepare table data
      const rows = config.upsDevices.map((ups) => ({
        id: ups.id,
        name: ups.name || '',
        host: `${ups.snmp.host}:${ups.snmp.port}`,
        model: ups.snmp.upsModel || 'cyberpower',
        groups: ups.groups.length > 0 ? ups.groups.join(', ') : theme.dim('None'),
      }));

      const columns: ITableColumn[] = [
        { header: 'ID', key: 'id', align: 'left', color: theme.highlight },
        { header: 'Name', key: 'name', align: 'left' },
        { header: 'Host:Port', key: 'host', align: 'left', color: theme.info },
        { header: 'Model', key: 'model', align: 'left' },
        { header: 'Groups', key: 'groups', align: 'left' },
      ];

      logger.log('');
      logger.info(`UPS Devices (${config.upsDevices.length}):`);
      logger.log('');
      logger.logTable(columns, rows);
      logger.log('');
    } catch (error) {
      logger.error(
        `Failed to list UPS devices: ${error instanceof Error ? error.message : String(error)}`,
      );
    }
  }

  /**
   * Test the current configuration by connecting to the UPS
   * @param debugMode Whether to enable debug mode
   */
  public async test(debugMode: boolean = false): Promise<void> {
    try {
      // Debug mode is now handled in parseAndExecute
      if (debugMode) {
        const boxWidth = 45;
        logger.logBoxTitle('Debug Mode', boxWidth);
        logger.logBoxLine('SNMP debugging enabled - detailed logs will be shown');
        logger.logBoxEnd();
      }

      // Try to load the configuration
      try {
        await this.nupst.getDaemon().loadConfig();
      } catch (error) {
        const errorBoxWidth = 45;
        logger.logBoxTitle('Configuration Error', errorBoxWidth);
        logger.logBoxLine('No configuration found.');
        logger.logBoxLine("Please run 'nupst setup' first to create a configuration.");
        logger.logBoxEnd();
        return;
      }

      // Get current configuration
      const config = this.nupst.getDaemon().getConfig();

      // Handle new multi-UPS configuration format
      if (config.upsDevices && config.upsDevices.length > 0) {
        logger.log(`Found ${config.upsDevices.length} UPS devices in configuration.`);

        for (let i = 0; i < config.upsDevices.length; i++) {
          const ups = config.upsDevices[i];
          logger.log(`\nTesting UPS: ${ups.name} (${ups.id})`);
          this.displayTestConfig(ups);
          await this.testConnection(ups);
        }
      } else {
        // Legacy configuration format
        this.displayTestConfig(config);
        await this.testConnection(config);
      }
    } catch (error) {
      logger.error(`Test failed: ${error instanceof Error ? error.message : String(error)}`);
    }
  }

  /**
   * Display the configuration for testing
   * @param config Current configuration or individual UPS configuration
   */
  private displayTestConfig(config: any): void {
    // Check if this is a UPS device or full configuration
    const isUpsConfig = config.snmp;
    const snmpConfig = isUpsConfig ? config.snmp : config.snmp || {};
    const checkInterval = config.checkInterval || 30000;

    // Get UPS name and ID if available
    const upsName = config.name ? config.name : 'Default UPS';
    const upsId = config.id ? config.id : 'default';

    const boxWidth = 45;
    logger.logBoxTitle(`Testing Configuration: ${upsName}`, boxWidth);
    logger.logBoxLine(`UPS ID: ${upsId}`);
    logger.logBoxLine('SNMP Settings:');
    logger.logBoxLine(`  Host: ${snmpConfig.host}`);
    logger.logBoxLine(`  Port: ${snmpConfig.port}`);
    logger.logBoxLine(`  Version: ${snmpConfig.version}`);
    logger.logBoxLine(`  UPS Model: ${snmpConfig.upsModel || 'cyberpower'}`);

    if (snmpConfig.version === 1 || snmpConfig.version === 2) {
      logger.logBoxLine(`  Community: ${snmpConfig.community}`);
    } else if (snmpConfig.version === 3) {
      logger.logBoxLine(`  Security Level: ${snmpConfig.securityLevel}`);
      logger.logBoxLine(`  Username: ${snmpConfig.username}`);

      // Show auth and privacy details based on security level
      if (snmpConfig.securityLevel === 'authNoPriv' || snmpConfig.securityLevel === 'authPriv') {
        logger.logBoxLine(`  Auth Protocol: ${snmpConfig.authProtocol || 'None'}`);
      }

      if (snmpConfig.securityLevel === 'authPriv') {
        logger.logBoxLine(`  Privacy Protocol: ${snmpConfig.privProtocol || 'None'}`);
      }

      // Show timeout value
      logger.logBoxLine(`  Timeout: ${snmpConfig.timeout / 1000} seconds`);
    }

    // Show OIDs if custom model is selected
    if (snmpConfig.upsModel === 'custom' && snmpConfig.customOIDs) {
      logger.logBoxLine('Custom OIDs:');
      logger.logBoxLine(`  Power Status: ${snmpConfig.customOIDs.POWER_STATUS || 'Not set'}`);
      logger.logBoxLine(
        `  Battery Capacity: ${snmpConfig.customOIDs.BATTERY_CAPACITY || 'Not set'}`,
      );
      logger.logBoxLine(`  Battery Runtime: ${snmpConfig.customOIDs.BATTERY_RUNTIME || 'Not set'}`);
    }
    logger.logBoxLine('Thresholds:');
    logger.logBoxLine(`  Battery: ${thresholds.battery}%`);
    logger.logBoxLine(`  Runtime: ${thresholds.runtime} minutes`);

    // Show group assignments if this is a UPS config
    if (config.groups && Array.isArray(config.groups)) {
      logger.logBoxLine(
        `Group Assignments: ${config.groups.length === 0 ? 'None' : config.groups.join(', ')}`,
      );
    }

    logger.logBoxLine(`Check Interval: ${checkInterval / 1000} seconds`);
    logger.logBoxEnd();
  }

  /**
   * Test connection to the UPS
   * @param config Current UPS configuration or legacy config
   */
  private async testConnection(config: any): Promise<void> {
    const upsId = config.id || 'default';
    const upsName = config.name || 'Default UPS';
    logger.log(`\nTesting connection to UPS: ${upsName} (${upsId})...`);

    try {
      // Create a test config with a short timeout
      const snmpConfig = config.snmp ? config.snmp : config.snmp;
      const thresholds = config.thresholds ? config.thresholds : config.thresholds;

      const testConfig = {
        ...snmpConfig,
        timeout: Math.min(snmpConfig.timeout, 10000), // Use at most 10 seconds for testing
      };

      const status = await this.nupst.getSnmp().getUpsStatus(testConfig);

      const boxWidth = 45;
      logger.logBoxTitle(`Connection Successful: ${upsName}`, boxWidth);
      logger.logBoxLine('UPS Status:');
      logger.logBoxLine(`  Power Status: ${status.powerStatus}`);
      logger.logBoxLine(`  Battery Capacity: ${status.batteryCapacity}%`);
      logger.logBoxLine(`  Runtime Remaining: ${status.batteryRuntime} minutes`);
      logger.logBoxEnd();

      // Check status against thresholds if on battery
      if (status.powerStatus === 'onBattery') {
        this.analyzeThresholds(status, thresholds);
      }
    } catch (error) {
      const errorBoxWidth = 45;
      logger.logBoxTitle(`Connection Failed: ${upsName}`, errorBoxWidth);
      logger.logBoxLine(`Error: ${error instanceof Error ? error.message : String(error)}`);
      logger.logBoxEnd();
      logger.log("\nPlease check your settings and run 'nupst edit' to reconfigure this UPS.");
    }
  }

  /**
   * Analyze UPS status against thresholds
   * @param status UPS status
   * @param thresholds Threshold configuration
   */
  private analyzeThresholds(status: any, thresholds: any): void {
    const boxWidth = 45;
    logger.logBoxTitle('Threshold Analysis', boxWidth);

    if (status.batteryCapacity < thresholds.battery) {
      logger.logBoxLine('⚠️ WARNING: Battery capacity below threshold');
      logger.logBoxLine(
        `  Current: ${status.batteryCapacity}% | Threshold: ${thresholds.battery}%`,
      );
      logger.logBoxLine('  System would initiate shutdown');
    } else {
      logger.logBoxLine('✓ Battery capacity above threshold');
      logger.logBoxLine(
        `  Current: ${status.batteryCapacity}% | Threshold: ${thresholds.battery}%`,
      );
    }

    if (status.batteryRuntime < thresholds.runtime) {
      logger.logBoxLine('⚠️ WARNING: Runtime below threshold');
      logger.logBoxLine(
        `  Current: ${status.batteryRuntime} min | Threshold: ${thresholds.runtime} min`,
      );
      logger.logBoxLine('  System would initiate shutdown');
    } else {
      logger.logBoxLine('✓ Runtime above threshold');
      logger.logBoxLine(
        `  Current: ${status.batteryRuntime} min | Threshold: ${thresholds.runtime} min`,
      );
    }

    logger.logBoxEnd();
  }

  /**
   * Gather SNMP settings
   * @param snmpConfig SNMP configuration object to update
   * @param prompt Function to prompt for user input
   */
  private async gatherSnmpSettings(
    snmpConfig: any,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    // SNMP IP Address
    const defaultHost = snmpConfig.host || '127.0.0.1';
    const host = await prompt(`UPS IP Address [${defaultHost}]: `);
    snmpConfig.host = host.trim() || defaultHost;

    // SNMP Port
    const defaultPort = snmpConfig.port || 161;
    const portInput = await prompt(`SNMP Port [${defaultPort}]: `);
    const port = parseInt(portInput, 10);
    snmpConfig.port = portInput.trim() && !isNaN(port) ? port : defaultPort;

    // SNMP Version
    const defaultVersion = snmpConfig.version || 1;
    logger.log('');
    logger.info('SNMP Version:');
    logger.dim('  1) SNMPv1');
    logger.dim('  2) SNMPv2c');
    logger.dim('  3) SNMPv3 (with security features)');
    const versionInput = await prompt(`Select SNMP version [${defaultVersion}]: `);
    const version = parseInt(versionInput, 10);
    snmpConfig.version = versionInput.trim() && (version === 1 || version === 2 || version === 3)
      ? version
      : defaultVersion;

    if (snmpConfig.version === 1 || snmpConfig.version === 2) {
      // SNMP Community String (for v1/v2c)
      const defaultCommunity = snmpConfig.community || 'public';
      const community = await prompt(`SNMP Community String [${defaultCommunity}]: `);
      snmpConfig.community = community.trim() || defaultCommunity;
    } else if (snmpConfig.version === 3) {
      // SNMP v3 settings
      await this.gatherSnmpV3Settings(snmpConfig, prompt);
    }
  }

  /**
   * Gather SNMPv3 specific settings
   * @param snmpConfig SNMP configuration object to update
   * @param prompt Function to prompt for user input
   */
  private async gatherSnmpV3Settings(
    snmpConfig: any,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    logger.log('');
    logger.info('SNMPv3 Security Settings:');

    // Security Level
    logger.log('');
    logger.info('Security Level:');
    logger.dim('  1) noAuthNoPriv (No Authentication, No Privacy)');
    logger.dim('  2) authNoPriv (Authentication, No Privacy)');
    logger.dim('  3) authPriv (Authentication and Privacy)');
    const defaultSecLevel = snmpConfig.securityLevel
      ? snmpConfig.securityLevel === 'noAuthNoPriv'
        ? 1
        : snmpConfig.securityLevel === 'authNoPriv'
        ? 2
        : 3
      : 3;
    const secLevelInput = await prompt(`Select Security Level [${defaultSecLevel}]: `);
    const secLevel = parseInt(secLevelInput, 10) || defaultSecLevel;

    if (secLevel === 1) {
      snmpConfig.securityLevel = 'noAuthNoPriv';
      // No auth, no priv - clear out authentication and privacy settings
      snmpConfig.authProtocol = '';
      snmpConfig.authKey = '';
      snmpConfig.privProtocol = '';
      snmpConfig.privKey = '';
      // Set appropriate timeout for security level
      snmpConfig.timeout = 5000; // 5 seconds for basic security
    } else if (secLevel === 2) {
      snmpConfig.securityLevel = 'authNoPriv';
      // Auth, no priv - clear out privacy settings
      snmpConfig.privProtocol = '';
      snmpConfig.privKey = '';
      // Set appropriate timeout for security level
      snmpConfig.timeout = 10000; // 10 seconds for authentication
    } else {
      snmpConfig.securityLevel = 'authPriv';
      // Set appropriate timeout for security level
      snmpConfig.timeout = 15000; // 15 seconds for full encryption
    }

    // Username
    const defaultUsername = snmpConfig.username || '';
    const username = await prompt(`SNMPv3 Username [${defaultUsername}]: `);
    snmpConfig.username = username.trim() || defaultUsername;

    if (secLevel >= 2) {
      // Authentication settings
      await this.gatherAuthenticationSettings(snmpConfig, prompt);

      if (secLevel === 3) {
        // Privacy settings
        await this.gatherPrivacySettings(snmpConfig, prompt);
      }

      // Allow customizing the timeout value
      const defaultTimeout = snmpConfig.timeout / 1000; // Convert from ms to seconds for display
      logger.log('');
      logger.info(
        'SNMPv3 operations with authentication and privacy may require longer timeouts.',
      );
      const timeoutInput = await prompt(`SNMP Timeout in seconds [${defaultTimeout}]: `);
      const timeout = parseInt(timeoutInput, 10);
      if (timeoutInput.trim() && !isNaN(timeout)) {
        snmpConfig.timeout = timeout * 1000; // Convert to ms
      }
    }
  }

  /**
   * Gather authentication settings for SNMPv3
   * @param snmpConfig SNMP configuration object to update
   * @param prompt Function to prompt for user input
   */
  private async gatherAuthenticationSettings(
    snmpConfig: any,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    // Authentication protocol
    logger.log('');
    logger.info('Authentication Protocol:');
    logger.dim('  1) MD5');
    logger.dim('  2) SHA');
    const defaultAuthProtocol = snmpConfig.authProtocol === 'SHA' ? 2 : 1;
    const authProtocolInput = await prompt(
      `Select Authentication Protocol [${defaultAuthProtocol}]: `,
    );
    const authProtocol = parseInt(authProtocolInput, 10) || defaultAuthProtocol;
    snmpConfig.authProtocol = authProtocol === 2 ? 'SHA' : 'MD5';

    // Authentication Key/Password
    const defaultAuthKey = snmpConfig.authKey || '';
    const authKey = await prompt(`Authentication Password ${defaultAuthKey ? '[*****]' : ''}: `);
    snmpConfig.authKey = authKey.trim() || defaultAuthKey;
  }

  /**
   * Gather privacy settings for SNMPv3
   * @param snmpConfig SNMP configuration object to update
   * @param prompt Function to prompt for user input
   */
  private async gatherPrivacySettings(
    snmpConfig: any,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    // Privacy protocol
    logger.log('');
    logger.info('Privacy Protocol:');
    logger.dim('  1) DES');
    logger.dim('  2) AES');
    const defaultPrivProtocol = snmpConfig.privProtocol === 'AES' ? 2 : 1;
    const privProtocolInput = await prompt(`Select Privacy Protocol [${defaultPrivProtocol}]: `);
    const privProtocol = parseInt(privProtocolInput, 10) || defaultPrivProtocol;
    snmpConfig.privProtocol = privProtocol === 2 ? 'AES' : 'DES';

    // Privacy Key/Password
    const defaultPrivKey = snmpConfig.privKey || '';
    const privKey = await prompt(`Privacy Password ${defaultPrivKey ? '[*****]' : ''}: `);
    snmpConfig.privKey = privKey.trim() || defaultPrivKey;
  }

  /**
   * Gather threshold settings
   * @param thresholds Thresholds configuration object to update
   * @param prompt Function to prompt for user input
   */
  private async gatherThresholdSettings(
    thresholds: any,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    logger.log('');
    logger.info('Shutdown Thresholds:');

    // Battery threshold
    const defaultBatteryThreshold = thresholds.battery || 60;
    const batteryThresholdInput = await prompt(
      `Battery percentage threshold [${defaultBatteryThreshold}%]: `,
    );
    const batteryThreshold = parseInt(batteryThresholdInput, 10);
    thresholds.battery = batteryThresholdInput.trim() && !isNaN(batteryThreshold)
      ? batteryThreshold
      : defaultBatteryThreshold;

    // Runtime threshold
    const defaultRuntimeThreshold = thresholds.runtime || 20;
    const runtimeThresholdInput = await prompt(
      `Runtime minutes threshold [${defaultRuntimeThreshold} minutes]: `,
    );
    const runtimeThreshold = parseInt(runtimeThresholdInput, 10);
    thresholds.runtime = runtimeThresholdInput.trim() && !isNaN(runtimeThreshold)
      ? runtimeThreshold
      : defaultRuntimeThreshold;
  }

  /**
   * Gather UPS model settings
   * @param snmpConfig SNMP configuration object to update
   * @param prompt Function to prompt for user input
   */
  private async gatherUpsModelSettings(
    snmpConfig: any,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    logger.log('');
    logger.info('UPS Model Selection:');
    logger.dim('  1) CyberPower');
    logger.dim('  2) APC');
    logger.dim('  3) Eaton');
    logger.dim('  4) TrippLite');
    logger.dim('  5) Liebert/Vertiv');
    logger.dim('  6) Custom (Advanced)');

    const defaultModelValue = snmpConfig.upsModel === 'cyberpower'
      ? 1
      : snmpConfig.upsModel === 'apc'
      ? 2
      : snmpConfig.upsModel === 'eaton'
      ? 3
      : snmpConfig.upsModel === 'tripplite'
      ? 4
      : snmpConfig.upsModel === 'liebert'
      ? 5
      : snmpConfig.upsModel === 'custom'
      ? 6
      : 1;

    const modelInput = await prompt(`Select UPS model [${defaultModelValue}]: `);
    const modelValue = parseInt(modelInput, 10) || defaultModelValue;

    if (modelValue === 1) {
      snmpConfig.upsModel = 'cyberpower';
    } else if (modelValue === 2) {
      snmpConfig.upsModel = 'apc';
    } else if (modelValue === 3) {
      snmpConfig.upsModel = 'eaton';
    } else if (modelValue === 4) {
      snmpConfig.upsModel = 'tripplite';
    } else if (modelValue === 5) {
      snmpConfig.upsModel = 'liebert';
    } else if (modelValue === 6) {
      snmpConfig.upsModel = 'custom';
      logger.log('');
      logger.info('Enter custom OIDs for your UPS:');
      logger.dim('(Leave blank to use standard RFC 1628 OIDs as fallback)');

      // Custom OIDs
      const powerStatusOID = await prompt('Power Status OID: ');
      const batteryCapacityOID = await prompt('Battery Capacity OID: ');
      const batteryRuntimeOID = await prompt('Battery Runtime OID: ');

      // Create custom OIDs object
      snmpConfig.customOIDs = {
        POWER_STATUS: powerStatusOID.trim(),
        BATTERY_CAPACITY: batteryCapacityOID.trim(),
        BATTERY_RUNTIME: batteryRuntimeOID.trim(),
      };
    }
  }

  /**
   * Gather action configuration settings
   * @param actions Actions array to configure
   * @param prompt Function to prompt for user input
   */
  private async gatherActionSettings(
    actions: any[],
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    logger.log('');
    logger.info('Action Configuration (Optional):');
    logger.dim('Actions are triggered on power status changes and threshold violations.');
    logger.dim('Leave empty to use default shutdown behavior on threshold violations.');

    const configureActions = await prompt('Configure custom actions? (y/N): ');
    if (configureActions.toLowerCase() !== 'y') {
      return; // Keep existing actions or use default
    }

    // Clear existing actions
    actions.length = 0;

    let addMore = true;
    while (addMore) {
      logger.log('');
      logger.info('Action Type:');
      logger.dim('  1) Shutdown (system shutdown)');
      logger.dim('  2) Webhook (HTTP notification)');
      logger.dim('  3) Custom Script (run .sh file from /etc/nupst)');

      const typeInput = await prompt('Select action type [1]: ');
      const typeValue = parseInt(typeInput, 10) || 1;

      const action: any = {};

      if (typeValue === 1) {
        // Shutdown action
        action.type = 'shutdown';

        const delayInput = await prompt('Shutdown delay in minutes [5]: ');
        const delay = parseInt(delayInput, 10);
        if (delayInput.trim() && !isNaN(delay)) {
          action.shutdownDelay = delay;
        }
      } else if (typeValue === 2) {
        // Webhook action
        action.type = 'webhook';

        const url = await prompt('Webhook URL: ');
        if (!url.trim()) {
          logger.warn('Webhook URL required, skipping action');
          continue;
        }
        action.webhookUrl = url.trim();

        logger.log('');
        logger.info('HTTP Method:');
        logger.dim('  1) POST (JSON body)');
        logger.dim('  2) GET (query parameters)');
        const methodInput = await prompt('Select method [1]: ');
        action.webhookMethod = methodInput === '2' ? 'GET' : 'POST';

        const timeoutInput = await prompt('Timeout in seconds [10]: ');
        const timeout = parseInt(timeoutInput, 10);
        if (timeoutInput.trim() && !isNaN(timeout)) {
          action.webhookTimeout = timeout * 1000; // Convert to ms
        }
      } else if (typeValue === 3) {
        // Script action
        action.type = 'script';

        const scriptPath = await prompt('Script filename (in /etc/nupst/, must end with .sh): ');
        if (!scriptPath.trim() || !scriptPath.trim().endsWith('.sh')) {
          logger.warn('Script path must end with .sh, skipping action');
          continue;
        }
        action.scriptPath = scriptPath.trim();

        const timeoutInput = await prompt('Script timeout in seconds [60]: ');
        const timeout = parseInt(timeoutInput, 10);
        if (timeoutInput.trim() && !isNaN(timeout)) {
          action.scriptTimeout = timeout * 1000; // Convert to ms
        }
      } else {
        logger.warn('Invalid action type, skipping');
        continue;
      }

      // Configure trigger mode (applies to all action types)
      logger.log('');
      logger.info('Trigger Mode:');
      logger.dim('  1) Power changes + thresholds (default)');
      logger.dim('  2) Only power status changes');
      logger.dim('  3) Only threshold violations');
      logger.dim('  4) Any change (every ~30s check)');
      const triggerInput = await prompt('Select trigger mode [1]: ');
      const triggerValue = parseInt(triggerInput, 10) || 1;
      
      switch (triggerValue) {
        case 2:
          action.triggerMode = 'onlyPowerChanges';
          break;
        case 3:
          action.triggerMode = 'onlyThresholds';
          break;
        case 4:
          action.triggerMode = 'anyChange';
          break;
        default:
          action.triggerMode = 'powerChangesAndThresholds';
      }

      // Configure thresholds if needed for onlyThresholds or powerChangesAndThresholds modes
      if (action.triggerMode === 'onlyThresholds' || action.triggerMode === 'powerChangesAndThresholds') {
        logger.log('');
        logger.info('Action Thresholds:');
        logger.dim('Action will trigger when battery or runtime falls below these values (while on battery)');
        
        const batteryInput = await prompt('Battery threshold percentage [60]: ');
        const battery = parseInt(batteryInput, 10);
        const batteryThreshold = (batteryInput.trim() && !isNaN(battery)) ? battery : 60;

        const runtimeInput = await prompt('Runtime threshold in minutes [20]: ');
        const runtime = parseInt(runtimeInput, 10);
        const runtimeThreshold = (runtimeInput.trim() && !isNaN(runtime)) ? runtime : 20;

        action.thresholds = {
          battery: batteryThreshold,
          runtime: runtimeThreshold,
        };
      }

      actions.push(action);
      logger.success(`${action.type.charAt(0).toUpperCase() + action.type.slice(1)} action added (mode: ${action.triggerMode || 'powerChangesAndThresholds'})`);

      const more = await prompt('Add another action? (y/N): ');
      addMore = more.toLowerCase() === 'y';
    }

    if (actions.length > 0) {
      logger.log('');
      logger.success(`${actions.length} action(s) configured`);
    }
  }

  /**
   * Display UPS configuration summary
   * @param ups UPS configuration
   */
  private displayUpsConfigSummary(ups: any): void {
    const boxWidth = 45;
    logger.log('');
    logger.logBoxTitle(`UPS Configuration: ${ups.name}`, boxWidth);
    logger.logBoxLine(`UPS ID: ${ups.id}`);
    logger.logBoxLine(`SNMP Host: ${ups.snmp.host}:${ups.snmp.port}`);
    logger.logBoxLine(`SNMP Version: ${ups.snmp.version}`);
    logger.logBoxLine(`UPS Model: ${ups.snmp.upsModel}`);
    logger.logBoxLine(
      `Thresholds: ${ups.thresholds.battery}% battery, ${ups.thresholds.runtime} min runtime`,
    );
    if (ups.groups && ups.groups.length > 0) {
      logger.logBoxLine(`Groups: ${ups.groups.join(', ')}`);
    } else {
      logger.logBoxLine('Groups: None');
    }
    logger.logBoxEnd();
    logger.log('');
  }

  /**
   * Optionally test connection to UPS
   * @param snmpConfig SNMP configuration to test
   * @param prompt Function to prompt for user input
   */
  private async optionallyTestConnection(
    snmpConfig: any,
    prompt: (question: string) => Promise<string>,
  ): Promise<void> {
    const testConnection = await prompt(
      'Would you like to test the connection to your UPS? (y/N): ',
    );
    if (testConnection.toLowerCase() === 'y') {
      logger.log('\nTesting connection to UPS...');
      try {
        // Create a test config with a short timeout
        const testConfig = {
          ...snmpConfig,
          timeout: Math.min(snmpConfig.timeout, 10000), // Use at most 10 seconds for testing
        };

        const status = await this.nupst.getSnmp().getUpsStatus(testConfig);
        const boxWidth = 45;
        logger.log('');
        logger.logBoxTitle('Connection Successful!', boxWidth);
        logger.logBoxLine('UPS Status:');
        logger.logBoxLine(`✓ Power Status: ${status.powerStatus}`);
        logger.logBoxLine(`✓ Battery Capacity: ${status.batteryCapacity}%`);
        logger.logBoxLine(`✓ Runtime Remaining: ${status.batteryRuntime} minutes`);
        logger.logBoxEnd();
      } catch (error) {
        const errorBoxWidth = 45;
        logger.log('');
        logger.logBoxTitle('Connection Failed!', errorBoxWidth);
        logger.logBoxLine(`Error: ${error instanceof Error ? error.message : String(error)}`);
        logger.logBoxEnd();
        logger.log('\nPlease check your settings and try again.');
      }
    }
  }

  /**
   * Check if the systemd service is running and restart it if it is
   * This is useful after configuration changes
   */
  public restartServiceIfRunning(): void {
    try {
      // Check if the service is active
      const isActive =
        execSync('systemctl is-active nupst.service || true').toString().trim() === 'active';

      if (isActive) {
        // Service is running, restart it
        const boxWidth = 45;
        logger.logBoxTitle('Service Update', boxWidth);
        logger.logBoxLine('Configuration has changed.');
        logger.logBoxLine('Restarting NUPST service to apply changes...');

        try {
          if (process.getuid && process.getuid() === 0) {
            // We have root access, restart directly
            execSync('systemctl restart nupst.service');
            logger.logBoxLine('Service restarted successfully.');
          } else {
            // No root access, show instructions
            logger.logBoxLine('Please restart the service with:');
            logger.logBoxLine('  sudo systemctl restart nupst.service');
          }
        } catch (error) {
          logger.logBoxLine(
            `Error restarting service: ${error instanceof Error ? error.message : String(error)}`,
          );
          logger.logBoxLine('You may need to restart the service manually:');
          logger.logBoxLine('  sudo systemctl restart nupst.service');
        }

        logger.logBoxEnd();
      }
    } catch (error) {
      // Ignore errors checking service status
    }
  }
}