import {
  SwEvent,
  TelnyxError,
  TELNYX_ERROR_CODES,
  isMediaRecoveryErrorEvent,
} from '@telnyx/webrtc';

interface ITelnyxStandardErrorEvent {
  error: ITelnyxError;     // structured error (TelnyxError instance)
  sessionId: string;       // SDK session identifier
  callId?: string;         // present when the error is tied to a call
  recoverable?: false;     // usually absent — see note below
}

interface ITelnyxMediaRecoveryErrorEvent {
  error: ITelnyxMediaError; // one of 42001 / 42002 / 42003
  sessionId: string;
  callId: string;
  recoverable: true;        // the only positive recovery signal
  retryDeadline: number;   // epoch ms after which the SDK stops waiting
  resume: () => void;       // retry media acquisition after permissions are fixed
  reject: () => void;       // abort recovery and let the call fail
}

import {
  SwEvent,
  TelnyxError,
  TELNYX_ERROR_CODES,
  isMediaRecoveryErrorEvent,
} from '@telnyx/webrtc';

client.on(SwEvent.Error, (event) => {
  // 1. Media-permission recovery path (only when configured)
  if (isMediaRecoveryErrorEvent(event)) {
    openPermissionsDialog({
      deadline: event.retryDeadline,
      onRetry: () => event.resume(),
      onCancel: () => event.reject(),
    });
    return;
  }

  // 2. Guard against non-structured errors (legacy/edge paths)
  if (!(event.error instanceof TelnyxError)) {
    showErrorMessage('An unknown SDK error occurred.');
    return;
  }

  // 3. Branch on the numeric code — always compare against TELNYX_ERROR_CODES
  switch (event.error.code) {
    case TELNYX_ERROR_CODES.SESSION_NOT_REATTACHED:
      // Fatal: server lost the call after reconnect
      terminateCallUi(event.callId);
      showErrorMessage('The call could not be recovered. Please place the call again.');
      break;

    case TELNYX_ERROR_CODES.LOGIN_FAILED:
    case TELNYX_ERROR_CODES.INVALID_CREDENTIALS:
      // Fatal: re-authenticate without recreating the client
      refreshTokenAndLogin();
      break;

    case TELNYX_ERROR_CODES.RECONNECTION_EXHAUSTED:
      // Fatal: automatic reconnect gave up
      showReconnectButton();
      break;

    case TELNYX_ERROR_CODES.MEDIA_MICROPHONE_PERMISSION_DENIED:
    case TELNYX_ERROR_CODES.MEDIA_DEVICE_NOT_FOUND:
    case TELNYX_ERROR_CODES.MEDIA_GET_USER_MEDIA_FAILED:
      showMediaError(event.error.message);
      break;

    default:
      showErrorMessage(event.error.message);
  }
});

const client = new TelnyxRTC({
  login_token: jwt,
  mediaPermissionsRecovery: {
    enabled: true,
    timeout: 10000,
  },
});

client.on(SwEvent.Error, (event) => {
  if (isMediaRecoveryErrorEvent(event)) {
    // Show a dialog asking the user to grant microphone permission
    // event.retryDeadline is the timestamp by which they must act
    showPermissionDialog({
      onGrant: () => event.resume(),
      onDismiss: () => event.reject(),
    });
  }
});

import { SwEvent, TELNYX_WARNING_CODES } from '@telnyx/webrtc';

interface ITelnyxWarningEvent {
  warning: ITelnyxWarning; // structured warning (plain object, not an Error)
  sessionId: string;
  callId?: string;
}

// Added on recovery warnings:
//   reason?: string                                        // human-readable reason
//   source?: 'probe' | 'request' | 'peer_failure' | 'no_rtp' // SIGNALING_RECOVERY_REQUIRED only

import { SwEvent, TELNYX_WARNING_CODES } from '@telnyx/webrtc';

client.on(SwEvent.Warning, (event) => {
  const { warning, sessionId, callId, reason, source } = event;

  switch (warning.code) {
    case TELNYX_WARNING_CODES.TOKEN_EXPIRING_SOON:
      refreshToken();
      break;

    case TELNYX_WARNING_CODES.PEER_CONNECTION_FAILED:
      showWarningBanner('Call is reconnecting');
      break;

    case TELNYX_WARNING_CODES.SIGNALING_RECOVERY_REQUIRED:
      // source tells you what triggered recovery: 'probe' | 'request' | 'peer_failure' | 'no_rtp'
      showReconnectingBanner(`Signaling recovery (${source})`);
      break;

    case TELNYX_WARNING_CODES.MEDIA_RECOVERY_REQUIRED:
      showReconnectingBanner('Media reconnecting');
      break;

    case TELNYX_WARNING_CODES.MULTIPLE_ACTIVE_CALLS_DETECTED:
      logMultiCall(callId, sessionId);
      break;

    case TELNYX_WARNING_CODES.SHARED_REMOTE_ELEMENT_OVERWRITE:
      // A shared remoteElement was overwritten by a different stream
      console.warn('Shared remoteElement overwritten — assign a distinct element per call');
      break;

    case TELNYX_WARNING_CODES.RECONNECTION_FAILED_WITH_NO_AUTO_RECONNECT:
      showReconnectButton();
      break;

    default:
      console.warn(`[${warning.code}] ${warning.name}: ${warning.message}`);
  }
});

const placeCall = (destinationNumber) => {
  if (!client.connection.connected) {
    showErrorMessage('Still connecting to Telnyx. Please try again shortly.');
    return;
  }

  client.newCall({ destinationNumber });
};

// Before reconnecting
client.clearReconnectToken();

// Or configure the SDK to skip the last voice SDK ID on reconnect
const client = new TelnyxRTC({
  login_token: jwt,
  skipLastVoiceSdkId: true,
});

client.on(SwEvent.Error, (event) => {
  // event.error is a plain Error object — no structured code
  // event.type may include ERROR_TYPE.invalidCredentialsOptions
  // event.sessionId is available
  console.error('SDK error:', event.error?.message || event.error);
});

client.on(SwEvent.Notification, (notification) => {
  switch (notification.type) {
    case 'userMediaError':
      // notification.error — raw browser Error/DOMException
      // notification.errorName — error name string
      // notification.errorMessage — error message string
      // notification.call — the Call object (if available)
      // SDK automatically hangs up the call
      showPermissionPrompt(notification.errorMessage);
      break;

    case 'peerConnectionFailureError':
      // notification.error — raw error
      // Peer connection failed, but the call may be recovered by the server
      // via attach with 'recovering' state. Show degraded UI and wait.
      showReconnectingBanner();
      break;

    case 'signalingStateClosed':
      // Peer signaling state closed — peer is not recoverable
      // But the call may still recover through server attach
      // Only clean up after a final hangup/callUpdate confirms loss
      showReconnectingBanner();
      break;

    case 'callUpdate':
      // Normal call lifecycle
      handleCallUpdate(notification.call);
      break;
  }
});

import { SwEvent, ERROR_TYPE } from '@telnyx/webrtc';

client.on(SwEvent.Error, (event) => {
  if (event.type === ERROR_TYPE.invalidCredentialsOptions) {
    // Credentials were invalid before the request was sent
    showLoginError('Please check your credentials.');
    return;
  }

  // For LOGIN_FAILED or AUTHENTICATION_REQUIRED, re-login without recreating the instance:
  // await client.login({ creds: { login_token: newToken } });

  // Other errors — generic handling
  showErrorMessage(event.error?.message || 'An error occurred');
});