VoiceMessageHandler.js

const axios = require('axios');
const FormData = require('form-data');
const fs = require('fs');
const NexaraTranscriptionAdapter = require('./adapters/NexaraTranscriptionAdapter');
const TestTranscriptionAdapter = require('./adapters/TestTranscriptionAdapter');

/**
 * Voice Message Handler - Extracted from StreamTelegramBot
 * Handles voice transcription and processing with Nexara API
 */
class VoiceMessageHandler {
  constructor(bot, nexaraApiKey, activityIndicator, mainBot, configFilePath = './configs/bot1.json') {
    this.bot = bot;
    this.nexaraApiKey = nexaraApiKey;
    this.activityIndicator = activityIndicator;
    this.mainBot = mainBot; // Reference to main bot for delegation
    this.configFilePath = configFilePath;
    this.pendingCommands = new Map(); // messageId -> { transcribedText, userId, chatId }
  }

  /**
   * Get transcription method from config
   */
  getTranscriptionMethod() {
    try {
      const config = JSON.parse(fs.readFileSync(this.configFilePath, 'utf8'));
      return config.voiceTranscriptionMethod || 'nexara';
    } catch (error) {
      console.warn('[VoiceHandler] Config read error, using default:', error.message);
      return 'nexara';
    }
  }

  /**
   * Set transcription method in config
   */
  setTranscriptionMethod(method) {
    try {
      const config = JSON.parse(fs.readFileSync(this.configFilePath, 'utf8'));
      config.voiceTranscriptionMethod = method;
      fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
      console.log(`[VoiceHandler] Transcription method set to: ${method}`);
    } catch (error) {
      throw new Error(`Failed to update config: ${error.message}`);
    }
  }

  /**
   * Get voice transcription instant setting from bot config
   */
  getVoiceTranscriptionInstant() {
    try {
      const config = JSON.parse(fs.readFileSync(this.configFilePath, 'utf8'));
      return config.voiceTranscriptionInstant || false;
    } catch (error) {
      console.warn('[VoiceHandler] Bot config read error, using default:', error.message);
      return false;
    }
  }

  /**
   * Set voice transcription instant setting in bot config
   */
  setVoiceTranscriptionInstant(enabled) {
    try {
      const config = JSON.parse(fs.readFileSync(this.configFilePath, 'utf8'));
      config.voiceTranscriptionInstant = enabled;
      fs.writeFileSync(this.configFilePath, JSON.stringify(config, null, 2));
      console.log(`[VoiceHandler] Voice transcription instant set to: ${enabled}`);
    } catch (error) {
      throw new Error(`Failed to update bot config: ${error.message}`);
    }
  }

  /**
   * Create transcription adapter based on config
   */
  createTranscriptionAdapter() {
    // Check if we're in test mode
    const isTestMode = !this.nexaraApiKey || process.env.NODE_ENV === 'test';
    
    if (isTestMode) {
      return new TestTranscriptionAdapter();
    }
    
    // Always use Nexara API for transcription
    return new NexaraTranscriptionAdapter(this.nexaraApiKey);
  }

  /**
   * Handle voice messages with adapter pattern
   */
  async handleVoiceMessage(msg) {
    const chatId = msg.chat.id;
    const userId = msg.from.id;
    
    // Start typing indicator for voice processing
    await this.activityIndicator.start(chatId);
    
    try {
      const adapter = this.createTranscriptionAdapter();
      let transcribedText;
      
      if (adapter.getName() === 'Test Mode') {
        transcribedText = await adapter.transcribe(msg.voice.file_id);
        console.log('[Voice] Test mode - using simulated transcription');
      } else {
        // Nexara API requires audio buffer
        const file = await this.bot.getFile(msg.voice.file_id);
        const audioBuffer = await this.downloadTelegramFile(file.file_path);
        transcribedText = await adapter.transcribe(audioBuffer);
        console.log(`[Voice] Using ${adapter.getName()} transcription`);
      }
      
      // Stop typing indicator
      await this.activityIndicator.stop(chatId);
      
      // Check if instant mode is enabled
      const isInstantMode = this.getVoiceTranscriptionInstant();
      
      if (isInstantMode) {
        // Instant mode: execute directly without confirmation
        await this.mainBot.safeSendMessage(chatId,
          '🎤 *Voice Message Processed*\n\n' +
          `📝 **Text:** "${transcribedText}"\n\n` +
          `🔧 **Method:** ${adapter.getName()}\n\n` +
          '⚡ **Instant Mode:** Sending to Claude...'
        );
        
        // Execute immediately
        await this.executeVoiceCommand(transcribedText, userId, chatId);
        
      } else {
        // Normal mode: show confirmation buttons
        const keyboard = {
          inline_keyboard: [
            [
              { text: '✅ OK', callback_data: `voice_confirm:${chatId}_${Date.now()}` },
              { text: '❌ Cancel', callback_data: `voice_cancel:${chatId}_${Date.now()}` }
            ]
          ]
        };
        
        const confirmMsg = await this.mainBot.safeSendMessage(chatId,
          '🎤 *Voice Message Received*\n\n' +
          `📝 **Text:** "${transcribedText}"\n\n` +
          `🔧 **Method:** ${adapter.getName()}\n\n` +
          '❓ Execute this command?',
          {
            reply_markup: keyboard
          }
        );
        
        // Store pending command with new message ID (with safety check)
        if (confirmMsg && confirmMsg.message_id) {
          this.pendingCommands.set(confirmMsg.message_id, {
            transcribedText,
            userId,
            chatId
          });
        } else {
          console.error('[Voice] Warning: confirmMsg or message_id is undefined, cannot store pending command');
        }
      }
      
    } catch (error) {
      console.error('[Voice] Processing error:', error);
      
      // Stop typing indicator on error
      await this.activityIndicator.stop(chatId);
      
      // Send error message to user
      try {
        await this.mainBot.safeSendMessage(chatId,
          '❌ *Voice Message Error*\n\n' +
          'Sorry, I couldn\'t process your voice message.\n\n' +
          `Error: ${error.message}`
        );
      } catch (sendError) {
        console.error('[Voice] Failed to send error message:', sendError);
      }
    }
  }

  /**
   * Execute voice command - common logic for both instant and confirmed modes
   */
  async executeVoiceCommand(transcribedText, userId, chatId, processUserMessageCallback = null, messageId = null) {
    try {
      // Check if concat mode is enabled
      if (this.mainBot.getConcatModeStatus(userId)) {
        const bufferSize = await this.mainBot.addToMessageBuffer(userId, {
          type: 'voice',
          content: transcribedText,
          imagePath: null
        });
        
        // For instant mode, we don't have messageId to edit, so send a new message
        if (processUserMessageCallback) {
          await this.mainBot.safeEditMessage(chatId, messageId, 
            `📝 **Voice Added to Buffer**\n\n🎤 Transcription: "${transcribedText}"\n\nBuffer: ${bufferSize} message${bufferSize > 1 ? 's' : ''}`
          );
        } else {
          await this.mainBot.safeSendMessage(chatId, 
            `📝 **Voice Added to Buffer**\n\n🎤 Transcription: "${transcribedText}"\n\nBuffer: ${bufferSize} message${bufferSize > 1 ? 's' : ''}`
          );
        }
      } else {
        // Normal processing - add voice transcription prefix like in CONCAT mode
        const prefixedMessage = `Voice Message Transcribe: ${transcribedText}`;
        
        // For instant mode, we need to find the processUserMessageCallback
        if (!processUserMessageCallback && this.mainBot.processUserMessage) {
          await this.mainBot.processUserMessage(prefixedMessage, userId, chatId);
        } else if (processUserMessageCallback) {
          await processUserMessageCallback(prefixedMessage, userId, chatId);
        } else {
          console.error('[Voice] No way to process user message found');
        }
      }
    } catch (error) {
      console.error('[Voice] Error executing voice command:', error);
      
      // Send error message
      try {
        await this.mainBot.safeSendMessage(chatId,
          '❌ *Voice Command Error*\n\n' +
          `Failed to execute command: ${error.message}`
        );
      } catch (sendError) {
        console.error('[Voice] Failed to send execution error message:', sendError);
      }
    }
  }

  /**
   * Handle voice command callbacks
   */
  async handleVoiceCallback(data, chatId, messageId, userId, processUserMessageCallback) {
    const pendingCommand = this.pendingCommands.get(messageId);
    
    if (!pendingCommand) {
      try {
        await this.mainBot.safeEditMessage(chatId, messageId, 
          '❌ *Voice command expired*\n\nPlease send a new voice message.'
        );
      } catch {
        // Silently handle edit errors for expired commands
      }
      return;
    }
    
    const { transcribedText } = pendingCommand;
    
    try {
      if (data.startsWith('voice_confirm:')) {
        // Execute the command
        await this.mainBot.safeEditMessage(chatId, messageId,
          '✅ *Executing voice command*\n\n' +
          `📝 Command: "${transcribedText}"\n\n` +
          '⏳ Sending to Claude...'
        );
        
        // Remove from pending
        this.pendingCommands.delete(messageId);
        
        // Execute the voice command
        await this.executeVoiceCommand(transcribedText, userId, chatId, processUserMessageCallback, messageId);
        
      } else if (data.startsWith('voice_cancel:')) {
        await this.mainBot.safeEditMessage(chatId, messageId,
          '❌ *Voice command cancelled*'
        );
        
        this.pendingCommands.delete(messageId);
      }
    } catch {
      // Silently handle edit errors for callback operations
    }
  }

  /**
   * Download Telegram file with retry logic for SSL errors
   */
  async downloadTelegramFile(filePath) {
    const MAX_RETRIES = 5;
    const BASE_DELAY = 1000; // 1 second
    
    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
      try {
        const botToken = this.bot.token;
        const url = `https://api.telegram.org/file/bot${botToken}/${filePath}`;
        
        const response = await axios.get(url, {
          responseType: 'arraybuffer',
          timeout: 30000
        });
        
        return Buffer.from(response.data);
      } catch (error) {
        const isSSLError = error.message.includes('SSL routines') || 
                          error.message.includes('packet length too long') ||
                          error.message.includes('tls_get_more_records') ||
                          error.code === 'ECONNRESET' ||
                          error.code === 'ETIMEDOUT';
        
        if (isSSLError && attempt < MAX_RETRIES) {
          const delay = BASE_DELAY * Math.pow(2, attempt - 1); // Exponential backoff
          console.log(`[VoiceHandler] SSL connection error on attempt ${attempt}/${MAX_RETRIES}, retrying in ${delay}ms...`);
          console.log(`[VoiceHandler] Error details: ${error.message}`);
          
          await new Promise(resolve => setTimeout(resolve, delay));
          continue;
        }
        
        // If it's not an SSL error or we've exhausted retries, throw the error
        throw new Error(`Failed to download file after ${attempt} attempts: ${error.message}`);
      }
    }
  }

  /**
   * Transcribe audio with Nexara API
   */
  async transcribeWithNexara(audioBuffer) {
    if (!this.nexaraApiKey) {
      throw new Error('Nexara API key not configured. Voice messages unavailable.');
    }
    
    try {
      console.log('[Nexara] Transcribing audio...');
      
      // Create FormData with the audio file
      const formData = new FormData();
      
      // Add the audio file as a buffer with proper filename and content type
      formData.append('file', audioBuffer, {
        filename: 'audio.ogg',
        contentType: 'audio/ogg'
      });
      
      // Add other required fields
      formData.append('model', 'whisper-1');
      
      const response = await axios.post('https://api.nexara.ru/api/v1/audio/transcriptions', formData, {
        headers: {
          'Authorization': `Bearer ${this.nexaraApiKey}`,
          ...formData.getHeaders()
        },
        timeout: 30000
      });
      
      if (response.data && response.data.text) {
        console.log(`[Nexara] Transcribed: "${response.data.text}"`);
        return response.data.text;
      } else {
        throw new Error('Empty response from Nexara API');
      }
      
    } catch (error) {
      if (error.response) {
        throw new Error(`Nexara API error: ${error.response.status} - ${error.response.data?.message || 'Unknown error'}`);
      } else if (error.request) {
        throw new Error('No response from Nexara API. Check internet connection.');
      } else {
        throw new Error(`Request error: ${error.message}`);
      }
    }
  }

  /**
   * Cleanup pending commands
   */
  cleanup() {
    this.pendingCommands.clear();
  }

  /**
   * Get stats for debugging
   */
  getStats() {
    return {
      pendingVoiceCommands: this.pendingCommands.size
    };
  }
}

module.exports = VoiceMessageHandler;