client.js

const fs = require('fs');
const http = require('http');
const https = require('https');
const { EventEmitter } = require('events');
const express = require('express');
const bodyParser = require('body-parser');
const { createDecipher } = require('crypto');
require('dotenv').config();
const _ = require('lodash');
const logger = require('./logger');
const { hangupCall, bridgeCall, acceptCall } = require('./voiceapi');

const app = express();
const eventEmitter = new EventEmitter();

let server;
let webHookUrl;
let bridgeToNumber = process.env.BRIDGETO || '';
const sseMsg = [];
const servicePort = process.env.SERVICE_PORT || 3000;

function onError(error) {
  if (error.syscall !== 'listen') throw error;
  switch (error.code) {
    case 'EACCES':
      logger.error(`Port ${servicePort} requires elevated privileges`);
      process.exit(1);
      break;
    case 'EADDRINUSE':
      logger.error(`Port ${servicePort} is already in use`);
      process.exit(1);
      break;
    default:
      throw error;
  }
}

function shutdown() {
  server.close(() => {
    logger.error('Shutting down the server');
    process.exit(0);
  });
  setTimeout(() => { process.exit(1); }, 10000);
}

function createNgrokTunnel() {
  server = app.listen(servicePort, () => {
    logger.info(`Server running on port ${servicePort}`);
    (async () => {
      try {
        webHookUrl = process.env.PUBLIC_WEBHOOK_URL;
        logger.info(`Webhook URL: ${webHookUrl}`);
      } catch (error) {
        logger.error(`ngrok error: ${JSON.stringify(error)}`);
        shutdown();
        return;
      }
      webHookUrl += '/event';
      logger.info(`Update this URL in the EnableX portal for inbound calls: ${webHookUrl}`);
    })();
  });
}

function setWebHookEventUrl() {
  logger.info(`Listening on port ${servicePort}`);
  webHookUrl = `${process.env.PUBLIC_WEBHOOK_HOST}/event`;
  logger.info(`Update this URL in the EnableX portal for inbound calls: ${webHookUrl}`);
}

function createAppServer() {
  if (process.env.LISTEN_SSL) {
    const options = {
      key: fs.readFileSync(process.env.CERTIFICATE_SSL_KEY).toString(),
      cert: fs.readFileSync(process.env.CERTIFICATE_SSL_CERT).toString(),
    };
    if (process.env.CERTIFICATE_SSL_CACERTS) {
      options.ca = [fs.readFileSync(process.env.CERTIFICATE_SSL_CACERTS).toString()];
    }
    server = https.createServer(options, app);
  } else {
    server = http.createServer(app);
  }
  app.set('port', servicePort);
  server.listen(servicePort);
  server.on('error', onError);
  server.on('listening', setWebHookEventUrl);
}

if (process.env.ENABLEX_APP_ID && process.env.ENABLEX_APP_KEY) {
  if (process.env.USE_NGROK_TUNNEL === 'true' && process.env.USE_PUBLIC_WEBHOOK === 'false') {
    createNgrokTunnel();
  } else if (process.env.USE_PUBLIC_WEBHOOK === 'true' && process.env.USE_NGROK_TUNNEL === 'false') {
    createAppServer();
  } else {
    logger.error('Incorrect configuration: set exactly one of USE_NGROK_TUNNEL or USE_PUBLIC_WEBHOOK to true');
  }
} else {
  logger.error('Missing env variables: ENABLEX_APP_ID and ENABLEX_APP_KEY are required');
}

process.on('SIGINT', () => {
  logger.info('Caught interrupt signal');
  shutdown();
});

app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(express.static('client'));

// Returns the current bridge-to number
app.get('/bridge-number', (req, res) => {
  res.json({ bridgeToNumber });
});

// Updates the bridge-to number at runtime without restarting
app.post('/bridge-number', (req, res) => {
  const { number } = req.body;
  if (!number) return res.status(400).json({ error: 'number is required' });
  bridgeToNumber = number.trim();
  logger.info(`Bridge-to number updated: ${bridgeToNumber}`);
  res.json({ bridgeToNumber });
});

// Streams EnableX voice events to the browser via Server-Sent Events
app.get('/event-stream', (req, res) => {
  res.writeHead(200, {
    'Content-Type': 'text/event-stream',
    'Cache-Control': 'no-cache',
    Connection: 'keep-alive',
  });

  const id = (new Date()).toLocaleTimeString();
  const interval = setInterval(() => {
    if (!_.isEmpty(sseMsg[0])) {
      res.write(`id: ${id}\n`);
      res.write(`data: ${sseMsg.shift()}\n\n`);
    }
  }, 100);

  req.on('close', () => clearInterval(interval));
});

// Receives EnableX webhook events; supports optional payload encryption
app.post('/event', (req, res) => {
  let jsonObj;
  if (req.headers['x-algoritm'] !== undefined) {
    const key = createDecipher(req.headers['x-algoritm'], process.env.ENABLEX_APP_ID);
    let decryptedData = key.update(req.body.encrypted_data, req.headers['x-format'], req.headers['x-encoding']);
    decryptedData += key.final(req.headers['x-encoding']);
    jsonObj = JSON.parse(decryptedData);
  } else {
    jsonObj = req.body;
  }
  logger.info(`Webhook event: ${JSON.stringify(jsonObj)}`);
  res.status(200).send();
  sseMsg.push('__WEBHOOK__:' + JSON.stringify(jsonObj));
  eventEmitter.emit('voicestateevent', jsonObj);
});

function voiceEventHandler(voiceEvent) {
  const voice_id = voiceEvent.voice_id;

  if (voiceEvent.state !== undefined) {
    if (voiceEvent.state === 'incomingcall') {
      const msg = `[${voice_id}] Incoming call received`;
      logger.info(msg);
      sseMsg.push(msg);
      setTimeout(() => acceptCall(voice_id, () => {}), 1000);

    } else if (voiceEvent.state === 'connected') {
      const msg = `[${voice_id}] Call connected — bridging to ${bridgeToNumber}`;
      logger.info(msg);
      sseMsg.push(msg);
      setTimeout(() => bridgeCall(voice_id, process.env.FROM, bridgeToNumber, () => {}), 1000);

    } else if (voiceEvent.state === 'bridged') {
      const msg = `[${voice_id}] Call bridged successfully`;
      logger.info(msg);
      sseMsg.push(msg);

    } else if (voiceEvent.state === 'bridge_disconnected') {
      const msg = `[${voice_id}] Bridge disconnected`;
      logger.info(msg);
      sseMsg.push(msg);
      hangupCall(voice_id, () => {});

    } else if (voiceEvent.state === 'disconnected') {
      const msg = `[${voice_id}] Call disconnected`;
      logger.info(msg);
      sseMsg.push(msg);
    }
  }
}

eventEmitter.on('voicestateevent', voiceEventHandler);