server.js

const express = require('express');
const net = require('net');
const { SerialPort } = require('serialport');
const WebSocket = require('ws');
const mavlink = require('mavlinkjs/mavlink_all_v2');

const HTTP_PORT = 3001;
const DEFAULT_TCP_HOST = '192.168.1.1';
//const DEFAULT_TCP_HOST = '127.0.0.1';
const DEFAULT_TCP_PORT = 8888;
const DEFAULT_UART_PORT = 'COM5';
const DEFAULT_UART_BAUD = 921600;
const RECONNECT_DELAY_MS = 100;
const HEARTBEAT_INTERVAL_MS = 1000; // send heartbeat every second
const MAVLINK_SYS_ID = 1;
const MAVLINK_COMP_ID = 249;

const app = express();
app.use((req, res, next) => {
  res.header('Access-Control-Allow-Origin', '*');
  res.header('Access-Control-Allow-Methods', 'GET,POST,OPTIONS');
  res.header('Access-Control-Allow-Headers', 'Content-Type');
  if (req.method === 'OPTIONS') {
    res.sendStatus(204);
    return;
  }
  next();
});
app.use(express.static('public'));
app.use(express.json());

const inputConfig = {
  mode: 'tcp',
  tcpHost: DEFAULT_TCP_HOST,
  tcpPort: DEFAULT_TCP_PORT,
  uartPort: DEFAULT_UART_PORT,
  uartBaud: DEFAULT_UART_BAUD,
};

const args = process.argv.slice(2);

if (args.length > 0) {
  const [host, port] = args[0].split(':');
  if (host) inputConfig.tcpHost = host;
  if (port) inputConfig.tcpPort = parseInt(port, 10);
}

function getPublicInputConfig() {
  return {
    mode: inputConfig.mode,
    tcpHost: inputConfig.tcpHost,
    tcpPort: inputConfig.tcpPort,
    uartPort: inputConfig.uartPort,
    uartBaud: inputConfig.uartBaud,
  };
}

async function listAvailableSerialPorts() {
  try {
    const ports = await SerialPort.list();
    return ports.map((port) => ({
      path: port.path,
      manufacturer: port.manufacturer || '',
      friendlyName: [port.path, port.friendlyName || port.manufacturer]
        .filter(Boolean)
        .join(' - '),
    }));
  } catch (err) {
    console.error('⚠️ Failed to enumerate serial ports:', err.message);
    return [];
  }
}

app.get('/api/input-config', (req, res) => {
  res.json({ config: getPublicInputConfig() });
});

app.get('/api/serial-ports', async (req, res) => {
  const ports = await listAvailableSerialPorts();
  res.json({ ports });
});

app.post('/api/input-config', (req, res) => {
  const body = req.body || {};
  const mode = String(body.mode || '').toLowerCase();

  if (mode !== 'tcp' && mode !== 'uart') {
    res.status(400).json({ error: 'mode must be either "tcp" or "uart"' });
    return;
  }

  const nextConfig = {
    mode,
    tcpHost: String(body.tcpHost || inputConfig.tcpHost || '').trim(),
    tcpPort: Number(body.tcpPort ?? inputConfig.tcpPort),
    uartPort: String(body.uartPort || inputConfig.uartPort || '').trim(),
    uartBaud: Number(body.uartBaud ?? inputConfig.uartBaud),
  };

  if (!nextConfig.tcpHost) {
    res.status(400).json({ error: 'tcpHost must not be empty' });
    return;
  }

  if (!Number.isInteger(nextConfig.tcpPort) || nextConfig.tcpPort <= 0 || nextConfig.tcpPort > 65535) {
    res.status(400).json({ error: 'tcpPort must be a valid TCP port' });
    return;
  }

  if (!nextConfig.uartPort) {
    res.status(400).json({ error: 'uartPort must not be empty' });
    return;
  }

  if (!Number.isInteger(nextConfig.uartBaud) || nextConfig.uartBaud <= 0) {
    res.status(400).json({ error: 'uartBaud must be a positive integer' });
    return;
  }

  inputConfig.mode = nextConfig.mode;
  inputConfig.tcpHost = nextConfig.tcpHost;
  inputConfig.tcpPort = nextConfig.tcpPort;
  inputConfig.uartPort = nextConfig.uartPort;
  inputConfig.uartBaud = nextConfig.uartBaud;

  console.log(`⚙️ Input config updated: ${JSON.stringify(getPublicInputConfig())}`);
  reconnectInput();

  res.json({ ok: true, config: getPublicInputConfig() });
});

const server = app.listen(HTTP_PORT, () => {
  console.log(`🌐 HTTP server running at http://localhost:${HTTP_PORT}`);
});

const wss = new WebSocket.Server({ server });

function broadcast(msg) {
  const json = JSON.stringify(msg);
  wss.clients.forEach(client => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(json);
    }
  });
}

// MAVLink parser
const mav = new mavlink.MAVLink20Processor(null, MAVLINK_SYS_ID, MAVLINK_COMP_ID);

let tcpClient;
let serialClient;
let reconnectTimer = null;
let heartbeatTimer = null;

function handleMavlinkData(data) {
  let messages;
  try {
    messages = mav.parseBuffer(data);
    for (const m of messages) {
      if (m.id > -1) {
        broadcast(m);
      }
    }
  } catch (err) {
    console.error('⚠️ MAVLink parse error:', err.message);
    console.log(data);
  }
}

function cleanupInput() {
  stopHeartbeat();

  if (tcpClient) {
    tcpClient.removeAllListeners();
    tcpClient.destroy();
    tcpClient = null;
  }

  if (serialClient) {
    serialClient.removeAllListeners();
    if (serialClient.isOpen) {
      serialClient.close(() => {});
    }
    serialClient = null;
  }
}

function reconnectInput() {
  if (reconnectTimer) {
    clearTimeout(reconnectTimer);
    reconnectTimer = null;
  }

  cleanupInput();
  connectInput();
}

function connectInput() {
  if (inputConfig.mode === 'uart') {
    connectUART();
    return;
  }
  connectTCP();
}

function connectTCP() {
  cleanupInput();

  tcpClient = new net.Socket();

  console.log(`🔌 Attempting TCP connection to MAVLink server at ${inputConfig.tcpHost}:${inputConfig.tcpPort}...`);
  tcpClient.connect(inputConfig.tcpPort, inputConfig.tcpHost);

  tcpClient.on('connect', () => {
    console.log(`✅ Connected to MAVLink TCP server at ${inputConfig.tcpHost}:${inputConfig.tcpPort} with SYS:COMP ${MAVLINK_SYS_ID}:${MAVLINK_COMP_ID}`);

    // Start sending heartbeat
    startHeartbeat();
  });

  tcpClient.on('data', (data) => {
    handleMavlinkData(data);
  });

  tcpClient.on('error', (err) => {
    console.error('❌ TCP connection error:', err.message);
  });

  tcpClient.on('close', () => {
    console.warn('🔌 TCP connection closed');
    stopHeartbeat();
    scheduleReconnect();
  });
}

function connectUART() {
  cleanupInput();

  if (!inputConfig.uartPort) {
    console.error('❌ UART connection error: no COM port configured');
    scheduleReconnect();
    return;
  }

  serialClient = new SerialPort({
    path: inputConfig.uartPort,
    baudRate: inputConfig.uartBaud,
    autoOpen: false,
  });

  console.log(`🔌 Attempting UART connection on ${inputConfig.uartPort} @ ${inputConfig.uartBaud} baud...`);

  serialClient.on('open', () => {
    console.log(`✅ Connected to MAVLink UART port ${inputConfig.uartPort} @ ${inputConfig.uartBaud} baud with SYS:COMP ${MAVLINK_SYS_ID}:${MAVLINK_COMP_ID}`);
    startHeartbeat();
  });

  serialClient.on('data', (data) => {
    handleMavlinkData(data);
  });

  serialClient.on('error', (err) => {
    console.error('❌ UART connection error:', err.message);
  });

  serialClient.on('close', () => {
    console.warn('🔌 UART connection closed');
    stopHeartbeat();
    scheduleReconnect();
  });

  serialClient.open((err) => {
    if (err) {
      console.error('❌ Failed to open UART port:', err.message);
      scheduleReconnect();
    }
  });
}

function scheduleReconnect() {
  if (reconnectTimer) return;
  console.log(`⏳ Reconnecting ${inputConfig.mode.toUpperCase()} input in ${RECONNECT_DELAY_MS / 1000} seconds...`);
  reconnectTimer = setTimeout(() => {
    reconnectTimer = null;
    connectInput();
  }, RECONNECT_DELAY_MS);
}

function writeToInput(buffer) {
  if (inputConfig.mode === 'uart') {
    if (!serialClient || !serialClient.isOpen) {
      throw new Error('UART is not connected');
    }
    serialClient.write(buffer);
    return;
  }

  if (!tcpClient || tcpClient.destroyed) {
    throw new Error('TCP socket is not connected');
  }
  tcpClient.write(buffer);
}

function startHeartbeat() {
  if (heartbeatTimer) return;

  heartbeatTimer = setInterval(() => {
    try {

      // type, autopilot, base_mode, custom_mode, system_status, mavlink_version
      const hb = new mavlink.mavlink20.messages.heartbeat(6, 8, 0,0,0,3);

      writeToInput(Buffer.from(hb.pack(mav)));
      // console.log("❤️ Sent heartbeat");
    } catch (err) {
      console.error("⚠️ Failed to send heartbeat:", err.message);
    }
  }, HEARTBEAT_INTERVAL_MS);
}

function stopHeartbeat() {
  if (heartbeatTimer) {
    clearInterval(heartbeatTimer);
    heartbeatTimer = null;
  }
}

connectInput();