/* global axios */
import ApiClient from '../ApiClient';

class VoiceAPI extends ApiClient {
  constructor() {
    // Use 'voice' as the resource with accountScoped: true
    super('voice', { accountScoped: true });
    
    // Client-side Twilio device
    this.device = null;
    this.activeConnection = null;
    this.initialized = false;
  }

  // Initiate a call to a contact
  initiateCall(contactId) {
    if (!contactId) {
      throw new Error('Contact ID is required to initiate a call');
    }

    // Based on the route definition, the correct URL path is /api/v1/accounts/{accountId}/contacts/{contactId}/call
    // The endpoint is defined in the contacts namespace, not voice namespace
    return axios.post(`${this.baseUrl().replace('/voice', '')}/contacts/${contactId}/call`);
  }

  // End an active call
  endCall(callSid, conversationId) {
    if (!conversationId) {
      throw new Error('Conversation ID is required to end a call');
    }

    if (!callSid) {
      throw new Error('Call SID is required to end a call');
    }

    // Validate call SID format - Twilio call SID starts with 'CA' or 'TJ'
    if (!callSid.startsWith('CA') && !callSid.startsWith('TJ')) {
      throw new Error(
        'Invalid call SID format. Expected Twilio call SID starting with CA or TJ.'
      );
    }

    return axios.post(`${this.url}/end_call`, {
      call_sid: callSid,
      conversation_id: conversationId,
      id: conversationId,
    });
  }

  // Get call status
  getCallStatus(callSid) {
    if (!callSid) {
      throw new Error('Call SID is required to get call status');
    }

    return axios.get(`${this.url}/call_status`, {
      params: { call_sid: callSid },
    });
  }

  // Join an incoming call as an agent (join the conference)
  // This is used for the WebRTC client-side setup, not for phone calls anymore
  joinCall(params) {
    // Check if we have individual parameters or a params object
    const conversationId = params.conversation_id || params.conversationId;
    const callSid = params.call_sid || params.callSid;
    const accountId = params.account_id;

    if (!conversationId) {
      throw new Error('Conversation ID is required to join a call');
    }

    if (!callSid) {
      throw new Error('Call SID is required to join a call');
    }

    // Build request payload with proper naming convention
    const payload = {
      call_sid: callSid,
      conversation_id: conversationId,
    };

    // Add account_id if provided
    if (accountId) {
      payload.account_id = accountId;
    }

    console.log('Calling join_call API endpoint with payload:', payload);

    return axios.post(`${this.url}/join_call`, payload);
  }

  // Reject an incoming call as an agent (don't join the conference)
  rejectCall(callSid, conversationId) {
    if (!conversationId) {
      throw new Error('Conversation ID is required to reject a call');
    }

    if (!callSid) {
      throw new Error('Call SID is required to reject a call');
    }

    return axios.post(`${this.url}/reject_call`, {
      call_sid: callSid,
      conversation_id: conversationId,
    });
  }
  
  // Client SDK methods
  
  // Get a capability token for the Twilio Client
  getToken(inboxId) {
    console.log(`Requesting token for inbox ID: ${inboxId} at URL: ${this.url}/tokens`);
    
    // Log the base URL for debugging
    console.log(`Base URL: ${this.baseUrl()}`);
    
    // Check if inboxId is valid
    if (!inboxId) {
      console.error('No inbox ID provided for token request');
      return Promise.reject(new Error('Inbox ID is required'));
    }
    
    // Add more request details to help debugging
    return axios.post(`${this.url}/tokens`, { inbox_id: inboxId }, {
      headers: { 'Content-Type': 'application/json' },
    }).catch(error => {
      // Extract useful error details for debugging
      const errorInfo = {
        status: error.response?.status,
        statusText: error.response?.statusText,
        data: error.response?.data,
        url: `${this.url}/tokens`,
        inboxId,
      };
      
      console.error('Token request error details:', errorInfo);
      
      // Try to extract a more useful error message from the HTML response if it's a 500 error
      if (error.response?.status === 500 && typeof error.response.data === 'string') {
        // Look for specific error patterns in the HTML
        const htmlData = error.response.data;
        
        // Check for common Ruby/Rails error patterns
        const nameMatchResult = htmlData.match(/<h2>(.*?)<\/h2>/);
        const detailsMatchResult = htmlData.match(/<pre>([\s\S]*?)<\/pre>/);
        
        const errorName = nameMatchResult ? nameMatchResult[1] : null;
        const errorDetails = detailsMatchResult ? detailsMatchResult[1] : null;
        
        if (errorName || errorDetails) {
          const enhancedError = new Error(`Server error: ${errorName || 'Internal Server Error'}`);
          enhancedError.details = errorDetails;
          enhancedError.originalError = error;
          throw enhancedError;
        }
      }
      
      throw error;
    });
  }
  
  // Initialize the Twilio Device
  async initializeDevice(inboxId) {
    // If already initialized, return the existing device after checking its health
    if (this.initialized && this.device) {
      const deviceState = this.device.state;
      console.log('Device already initialized, current state:', deviceState);
      
      // If the device is in a bad state, destroy and reinitialize
      if (deviceState === 'error' || deviceState === 'unregistered') {
        console.log('Device is in a bad state, destroying and reinitializing...');
        try {
          this.device.destroy();
        } catch (e) {
          console.log('Error destroying device:', e);
        }
        this.device = null;
        this.initialized = false;
      } else {
        // Device is in a good state, return it
        return this.device;
      }
    }
    
    // Device needs to be initialized or reinitialized
    try {
      console.log(`Starting Twilio Device initialization for inbox: ${inboxId}`);
      
      // Import the Twilio Voice SDK
      let Device;
      try {
        // We know the package is installed via package.json
        const { Device: TwilioDevice } = await import('@twilio/voice-sdk');
        Device = TwilioDevice;
        console.log('✓ Twilio Voice SDK imported successfully');
      } catch (importError) {
        console.error('✗ Failed to import Twilio Voice SDK:', importError);
        throw new Error(`Failed to load Twilio Voice SDK: ${importError.message}`);
      }
      
      // Validate inbox ID
      if (!inboxId) {
        throw new Error('Inbox ID is required to initialize the Twilio Device');
      }
      
      // Step 1: Get a token from the server
      console.log(`Requesting Twilio token for inbox: ${inboxId}`);
      let response;
      try {
        response = await this.getToken(inboxId);
        console.log(`✓ Token response received with status: ${response.status}`);
      } catch (tokenError) {
        console.error('✗ Token request failed:', tokenError);
        
        // Enhanced error handling for token requests
        if (tokenError.details) {
          // If we already have extracted details from the error, include those
          console.error('Token error details:', tokenError.details);
          throw new Error(`Failed to get token: ${tokenError.message}`);
        }
        
        // Check for specific HTTP error status codes
        if (tokenError.response) {
          const status = tokenError.response.status;
          const data = tokenError.response.data;
          
          if (status === 401) {
            throw new Error('Authentication error: Please check your Twilio credentials');
          } else if (status === 403) {
            throw new Error('Permission denied: You don\'t have access to this inbox');
          } else if (status === 404) {
            throw new Error('Inbox not found or does not have voice capability');
          } else if (status === 500) {
            throw new Error('Server error: The server encountered an error processing your request. Check your Twilio configuration.');
          } else if (data && data.error) {
            throw new Error(`Server error: ${data.error}`);
          }
        }
        
        throw new Error(`Failed to get token: ${tokenError.message}`);
      }
      
      // Validate token response
      if (!response.data || !response.data.token) {
        console.error('✗ Invalid token response data:', response.data);
        
        // Check if we have an error message in the response
        if (response.data && response.data.error) {
          throw new Error(`Server did not return a valid token: ${response.data.error}`);
        } else {
          throw new Error('Server did not return a valid token');
        }
      }
      
      // Check for warnings about missing TwiML App SID
      if (response.data.warning) {
        console.warn('⚠️ Twilio Voice Warning:', response.data.warning);
        
        if (!response.data.has_twiml_app) {
          console.error(
            '🚨 IMPORTANT: Missing TwiML App SID. Browser-based calling requires a ' +
            'TwiML App configured in Twilio Console. Set the Voice Request URL to: ' +
            response.data.twiml_endpoint
          );
        }
      }
      
      // Extract token data
      const { token, identity, voice_enabled, account_sid } = response.data;
      
      // Log diagnostic information
      console.log(`✓ Token data received for identity: ${identity}`);
      console.log(`✓ Voice enabled: ${voice_enabled}`);
      console.log(`✓ Twilio Account SID available: ${!!account_sid}`);
      
      // Log the TwiML endpoint that will be used
      if (response.data.twiml_endpoint) {
        console.log(`✓ TwiML endpoint: ${response.data.twiml_endpoint}`);
      } else {
        console.warn('⚠️ No TwiML endpoint found in token response');
      }
      
      // Check if voice is enabled
      if (!voice_enabled) {
        throw new Error('Voice is not enabled for this inbox. Check your Twilio configuration.');
      }
      
      // Store the TwiML endpoint URL for later use
      this.twimlEndpoint = response.data.twiml_endpoint;

      // Step 2: Create Twilio Device with better options
      const deviceOptions = {
        // Use absolute minimal options - less is more for audio compatibility
        allowIncomingWhileBusy: true, // Allow incoming calls while already on a call
        debug: true, // Enable debug logging
        warnings: true, // Show warnings in console
        disableAudioContextSounds: true, // Disable browser audio context for sounds
        // Add explicit edge parameter - this helps avoid connectivity issues
        edge: ['ashburn', 'sydney', 'roaming'],
        // Explicitly set codec preferences
        codecPreferences: ['opus', 'pcmu'],
        // Add the account ID to any calls made by this device
        appParams: {
          account_id: response.data.account_id,
        }
      };
      
      console.log('Creating Twilio Device with options:', deviceOptions);
      
      try {
        this.device = new Device(token, deviceOptions);
        console.log('✓ Twilio Device created successfully');
      } catch (deviceError) {
        console.error('✗ Failed to create Twilio Device:', deviceError);
        throw new Error(`Failed to create Twilio Device: ${deviceError.message}`);
      }
      
      // Step 3: Set up event listeners with enhanced error handling
      this._setupDeviceEventListeners(inboxId);
      
      // Step 4: Register the device with Twilio
      console.log('Registering Twilio Device...');
      try {
        await this.device.register();
        console.log('✓ Twilio Device registered successfully');
        this.initialized = true;
        return this.device;
      } catch (registerError) {
        console.error('✗ Failed to register Twilio Device:', registerError);
        
        // Handle specific registration errors
        if (registerError.message && registerError.message.includes('token')) {
          throw new Error('Invalid Twilio token. Check your account credentials.');
        } else if (registerError.message && registerError.message.includes('permission')) {
          throw new Error('Missing microphone permission. Please allow microphone access.');
        }
        
        throw new Error(`Failed to register device: ${registerError.message}`);
      }
    } catch (error) {
      // Clear device and initialized flag in case of error
      this.device = null;
      this.initialized = false;
      
      console.error('Failed to initialize Twilio Device:', error);
      
      // Create a detailed error with context for debugging
      const enhancedError = new Error(`Twilio Device initialization failed: ${error.message}`);
      enhancedError.originalError = error;
      enhancedError.inboxId = inboxId;
      enhancedError.timestamp = new Date().toISOString();
      enhancedError.browserInfo = {
        userAgent: navigator.userAgent,
        hasGetUserMedia: !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia),
      };
      
      // Add specific advice for known error cases
      if (error.message.includes('permission')) {
        enhancedError.advice = 'Please ensure your browser allows microphone access.';
      } else if (error.message.includes('token')) {
        enhancedError.advice = 'Check your Twilio credentials in the Voice channel settings.';
      } else if (error.message.includes('TwiML')) {
        enhancedError.advice = 'Set up a valid TwiML app in your Twilio console and configure it in the inbox settings.';
      } else if (error.message.includes('configuration')) {
        enhancedError.advice = 'Review your Voice inbox configuration to ensure all required fields are completed.';
      }
      
      throw enhancedError;
    }
  }
  
  // Helper method to set up device event listeners
  _setupDeviceEventListeners(inboxId) {
    if (!this.device) return;
    
    // Remove any existing listeners to prevent duplicates
    this.device.removeAllListeners();
    
    // Add standard event listeners
    this.device.on('registered', () => {
      console.log('✓ Twilio Device registered with Twilio servers');
    });
    
    this.device.on('unregistered', () => {
      console.log('⚠️ Twilio Device unregistered from Twilio servers');
    });
    
    this.device.on('tokenWillExpire', () => {
      console.log('⚠️ Twilio token is about to expire, refreshing...');
      this.getToken(inboxId)
        .then(newTokenResponse => {
          if (newTokenResponse.data && newTokenResponse.data.token) {
            console.log('✓ Successfully obtained new token');
            this.device.updateToken(newTokenResponse.data.token);
          } else {
            console.error('✗ Failed to get a valid token for renewal');
          }
        })
        .catch(tokenError => {
          console.error('✗ Error refreshing token:', tokenError);
        });
    });
    
    this.device.on('incoming', connection => {
      console.log('📞 Incoming call received via Twilio Device');
      this.activeConnection = connection;
      
      // Set up connection-specific events
      this._setupConnectionEventListeners(connection);
    });
    
    this.device.on('error', error => {
      // Enhanced error logging with full details
      const errorDetails = {
        code: error.code,
        message: error.message,
        description: error.description || 'No description',
        twilioErrorObject: error,
        connectionInfo: this.activeConnection ? {
          parameters: this.activeConnection.parameters,
          status: this.activeConnection.status && this.activeConnection.status(),
          direction: this.activeConnection.direction,
        } : 'No active connection',
        deviceState: this.device.state,
        browserInfo: {
          userAgent: navigator.userAgent,
          platform: navigator.platform
        },
        timestamp: new Date().toISOString()
      };
      
      console.error('❌ DETAILED Twilio Device Error:', errorDetails);
      
      // Provide helpful troubleshooting tips based on error code
      switch (error.code) {
        case 31000:
          console.error('⚠️ Error 31000: General Error. This could be an authentication, configuration, or network issue.');
          console.error('31000 Error Details:', {
            sdp: error.sdp || 'No SDP data',
            callState: error.call ? error.call.state : 'No call state',
            connectionState: error.connection ? error.connection.state : 'No connection state',
            peerConnectionState: error.peerConnection ? error.peerConnection.iceConnectionState : 'No ICE state',
            message: error.message,
            twilioError: error,
            info: error.info || 'No additional info',
            solution: 'Check Twilio account status, SDP negotiations, and network connectivity'
          });
          
          // Create a network diagnostic to check connectivity
          fetch('https://status.twilio.com/api/v2/status.json')
            .then(response => response.json())
            .then(data => {
              console.log('Twilio service status check:', data);
            })
            .catch(statusError => {
              console.error('Failed to check Twilio status:', statusError);
            });
          break;
        case 31002:
          console.error('⚠️ Error 31002: Permission Denied. Your browser microphone is blocked or unavailable.');
          break;
        case 31003:
          console.error('⚠️ Error 31003: TwiML App Error. Your TwiML application does not exist or is misconfigured.');
          break;
        case 31005:
          console.error('⚠️ Error 31005: Error sent from gateway in HANGUP. This usually means the TwiML endpoint is not reachable or returning invalid TwiML.');
          console.error('Additional details for 31005:', {
            activeConnection: this.activeConnection ? 'Yes' : 'No',
            deviceState: this.device ? this.device.state : 'No device',
            params: this.activeConnection ? this.activeConnection.parameters : 'No params',
            twimlEndpoint: this.activeConnection && this.activeConnection.parameters ? 
              this.activeConnection.parameters.To : 'Unknown endpoint',
            hangupReason: error.hangupReason || 'Unknown',  // Capture hangup reason
            message: error.message,
            description: error.description,
            customMessage: error.customMessage,
            originalError: error.originalError ? JSON.stringify(error.originalError) : 'None'
          });
          break;
        case 31008:
          console.error('⚠️ Error 31008: Connection Error. The call could not be established.');
          break;
        case 31204:
          console.error('⚠️ Error 31204: ICE Connection Failed. WebRTC connection failure, check firewall settings.');
          break;
        default:
          console.error(`⚠️ Unspecified error with code ${error.code}: ${error.message}`);
      }
    });
    
    this.device.on('connect', connection => {
      console.log('📞 Call connected');
      this.activeConnection = connection;
      this._setupConnectionEventListeners(connection);
    });
    
    this.device.on('disconnect', () => {
      console.log('📞 Call disconnected');
      this.activeConnection = null;
    });
  }
  
  // Set up event listeners for the active connection with enhanced audio diagnostic logging
  _setupConnectionEventListeners(connection) {
    if (!connection) return;
    
    // Add advanced audio debug data
    const getAudioDiagnostics = () => {
      const audioContext = window.AudioContext || window.webkitAudioContext;
      let audioInfo = { supported: !!audioContext };
      
      try {
        if (audioContext) {
          const context = new audioContext();
          audioInfo = {
            ...audioInfo,
            sampleRate: context.sampleRate,
            state: context.state,
            baseLatency: context.baseLatency,
            outputLatency: context.outputLatency,
            destination: {
              maxChannelCount: context.destination.maxChannelCount,
              numberOfInputs: context.destination.numberOfInputs,
              numberOfOutputs: context.destination.numberOfOutputs
            }
          };
          context.close();
        }
      } catch (e) {
        audioInfo.error = e.message;
      }
      
      // Check if microphone is accessible
      let microphoneInfo = { detected: false, active: false, tracks: [] };
      if (window.activeAudioStream) {
        const tracks = window.activeAudioStream.getAudioTracks();
        microphoneInfo = {
          detected: true,
          active: tracks.some(track => track.enabled && track.readyState === 'live'),
          tracks: tracks.map(track => ({
            id: track.id,
            label: track.label,
            enabled: track.enabled,
            muted: track.muted,
            readyState: track.readyState,
            constraints: track.getConstraints()
          }))
        };
      }
      
      return { 
        audioContext: audioInfo, 
        microphone: microphoneInfo,
        speakersMuted: typeof window.speechSynthesis !== 'undefined' ? 
          window.speechSynthesis.speaking === false : 'unknown'
      };
    };
    
    connection.on('error', error => {
      // Significantly enhanced connection error logging with audio diagnostics
      const diagnostics = getAudioDiagnostics();
      
      const connectionErrorDetails = {
        code: error.code,
        message: error.message,
        description: error.description || 'No description',
        twilioErrorObject: error,
        connectionInfo: {
          parameters: connection.parameters,
          status: connection.status && connection.status(),
          direction: connection.direction,
        },
        deviceState: this.device ? this.device.state : 'No device',
        timestamp: new Date().toISOString(),
        // Audio diagnostics for troubleshooting
        audioDiagnostics: diagnostics,
        // Browser media permissions
        mediaPermissions: {
          hasGetUserMedia: !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia),
          activeAudioStream: !!window.activeAudioStream,
          activeAudioTracks: window.activeAudioStream ? 
            window.activeAudioStream.getAudioTracks().length : 0
        }
      };
      
      console.error('❌ DETAILED Connection Error with Audio Diagnostics:', connectionErrorDetails);
    });
    
    connection.on('mute', isMuted => {
      console.log(`📞 Call ${isMuted ? 'muted' : 'unmuted'}`);
    });
    
    connection.on('accept', () => {
      // Enhanced logging for accept event with audio diagnostics
      const diagnostics = getAudioDiagnostics();
      
      console.log('📞 Call accepted with audio diagnostics:', {
        connectionParameters: connection.parameters,
        status: connection.status && connection.status(),
        audioDiagnostics: diagnostics,
        activeAudioStream: window.activeAudioStream ? {
          active: window.activeAudioStream.active,
          id: window.activeAudioStream.id,
          trackCount: window.activeAudioStream.getTracks().length
        } : 'No active stream'
      });
      
      // AUDIO HEALTH CHECK AFTER CONNECTION
      setTimeout(() => {
        console.log('🔊 AUDIO HEALTH CHECK:', {
          connectionActive: this.activeConnection === connection,
          connectionState: connection.status && connection.status(),
          audioTracks: window.activeAudioStream ? 
            window.activeAudioStream.getAudioTracks().map(track => ({
              label: track.label,
              enabled: track.enabled,
              readyState: track.readyState,
              muted: track.muted
            })) : 'No active stream',
          // Device state after 5 seconds
          deviceState: this.device ? this.device.state : 'No device'
        });
      }, 5000);
    });
    
    connection.on('disconnect', () => {
      console.log('📞 Call disconnected', {
        disconnectCause: connection.parameters ? connection.parameters.DisconnectCause : 'Unknown',
        finalStatus: connection.status && connection.status(),
        audioDiagnostics: getAudioDiagnostics()
      });
      this.activeConnection = null;
    });
    
    connection.on('reject', () => {
      console.log('📞 Call rejected', {
        rejectCause: connection.parameters ? connection.parameters.DisconnectCause : 'Unknown',
        audioDiagnostics: getAudioDiagnostics()
      });
      this.activeConnection = null;
    });
    
    // Additional event for warning messages
    connection.on('warning', warning => {
      console.warn('⚠️ Connection Warning:', warning);
    });
    
    // Listen for TwiML processing events
    connection.on('twiml-processing', twiml => {
      console.log('📄 Processing TwiML:', twiml);
    });
    
    // Enhanced audio events for debugging
    if (typeof connection.on === 'function') {
      try {
        // Check for volume events
        connection.on('volume', (inputVolume, outputVolume) => {
          // Log only significant volume changes to avoid console spam
          if (Math.abs(inputVolume) > 50 || Math.abs(outputVolume) > 50) {
            console.log(`🔊 Volume change - Input: ${inputVolume}, Output: ${outputVolume}`);
          }
        });
        
        // Check for media stream events if supported
        if (typeof connection.getRemoteStream === 'function') {
          const remoteStream = connection.getRemoteStream();
          if (remoteStream) {
            console.log('✅ Remote audio stream available:', {
              active: remoteStream.active,
              id: remoteStream.id,
              tracks: remoteStream.getTracks().map(t => ({
                kind: t.kind,
                enabled: t.enabled,
                readyState: t.readyState
              }))
            });
          } else {
            console.warn('⚠️ No remote audio stream available');
          }
        }
      } catch (e) {
        console.warn('Error setting up enhanced audio events:', e);
      }
    }
  }
  
  // Make a call using the Twilio Client
  makeClientCall(params) {
    if (!this.device || !this.initialized) {
      throw new Error('Twilio Device not initialized');
    }
    
    this.activeConnection = this.device.connect(params);
    return this.activeConnection;
  }
  
  // Join a conference call using the Twilio Client
  joinClientCall(conferenceParams) {
    if (!this.device || !this.initialized) {
      throw new Error('Twilio Device not initialized');
    }

    try {
      // IMPORTANT: Do NOT try to register if already registered
      // Only check state is ready
      if (this.device.state !== 'ready' && this.device.state !== 'registered') {
        // Don't try to register again if already registered
      }

      // This is CRITICAL for Twilio - params must be formatted exactly right
      // and passed directly in the format Twilio expects
      const params = {
        // REQUIRED: Twilio Voice JS SDK expects 'To' parameter to be a properly formatted string
        To: `${conferenceParams.To}`,

        // Additional params for our server
        account_id: conferenceParams.account_id,
        is_agent: 'true'
      };

      // Check To parameter exists - fail if missing
      if (!params.To) {
        throw new Error('Missing To parameter for conference');
      }

      // Make sure 'To' is explicitly a string
      const stringifiedTo = String(params.To);
      console.log('🎯 CRITICAL CONFERENCE CONNECTION: Connecting agent to conference with To=', stringifiedTo);

      // Follow Twilio documentation format - params should be nested under 'params' property
      console.log('🎯 TRYING CONNECTION: Using documented format with params property');

      // Just use the minimal required parameters
      const connection = this.device.connect({
        params: {
          To: stringifiedTo,  // Conference ID
          is_agent: 'true'    // Flag to indicate agent is joining
        }
      });

      console.log('🎯 CONFERENCE CONNECTION RESULT:', connection ? 'Success' : 'Failed');
      this.activeConnection = connection;

      if (connection && typeof connection.then === 'function') {
        // It's a Promise - newer Twilio SDK version
        connection.then(resolvedConnection => {
          this.activeConnection = resolvedConnection;
          try {
            if (typeof resolvedConnection.on === 'function') {
              resolvedConnection.on('accept', () => {
                // Connection accepted
              });
            }
          } catch (listenerError) {
            // Could not add listeners to Promise connection
          }
        }).catch(connError => {
          // WebRTC Promise connection error
        });
      } else {
        // It's a synchronous connection - older Twilio SDK
      }
      return connection;
    } catch (error) {
      // Error joining conference
    }
  }

  // Get the status of the device with additional diagnostic info
  getDeviceStatus() {
    if (!this.device) {
      return 'not_initialized';
    }
    
    const deviceState = this.device.state;
    
    // Append a recommended action based on the state
    switch (deviceState) {
      case 'registered':
        return 'ready';
      case 'unregistered':
        return 'disconnected';
      case 'destroyed':
        return 'terminated';
      case 'busy':
        return 'busy';
      case 'error':
        return 'error';
      default:
        return deviceState;
    }
  }
  
  // Get comprehensive diagnostic information about the device and connection
  getDiagnosticInfo() {
    const browserInfo = {
      userAgent: navigator.userAgent,
      platform: navigator.platform,
      vendor: navigator.vendor,
      hasMediaDevices: !!navigator.mediaDevices,
      hasGetUserMedia: !!(navigator.mediaDevices && navigator.mediaDevices.getUserMedia),
    };
    
    const deviceInfo = this.device ? {
      state: this.device.state,
      isInitialized: this.initialized,
      capabilities: this.device.capabilities || {},
      isBusy: this.device.isBusy || false,
      audio: {
        isAudioSelectionSupported: this.device.isAudioSelectionSupported || false
      }
    } : { state: 'not_initialized' };
    
    const connectionInfo = this.activeConnection ? {
      status: this.activeConnection.status(),
      isMuted: this.activeConnection.isMuted(),
      direction: this.activeConnection.direction,
      parameters: this.activeConnection.parameters,
    } : { status: 'no_connection' };
    
    return {
      timestamp: new Date().toISOString(),
      browser: browserInfo,
      device: deviceInfo,
      connection: connectionInfo
    };
  }
  
  // Get the status of the active connection
  getConnectionStatus() {
    if (!this.activeConnection) {
      return 'no_connection';
    }
    
    const status = this.activeConnection.status();
    
    // Translate connection statuses to more user-friendly terms
    switch (status) {
      case 'pending':
        return 'connecting';
      case 'open':
        return 'connected';
      case 'connecting':
        return 'connecting';
      case 'ringing':
        return 'ringing';
      case 'closed':
        return 'ended';
      default:
        return status;
    }
  }
}

export default new VoiceAPI();