Time4Midi/preload.js

const { contextBridge, ipcRenderer } = require("electron");
const crypto = require("node:crypto");
const dgram = require("node:dgram");
const fs = require("node:fs/promises");
const os = require("node:os");
const path = require("node:path");
const { pathToFileURL } = require("node:url");
const mqtt = require("mqtt");
const ModbusRTU = require("modbus-serial");
const knx = require("knx");

const ARTNET_PORT = 6454;
const SACN_PORT = 5568;
const KNX_PORT = 3671;
const ARTNET_HEADER = Buffer.from("Art-Net\0", "ascii");
const ARTNET_OPCODE_DMX = 0x5000;
const ARTNET_OPCODE_TIMECODE = 0x9700;
const MAPPING_LIBRARY_STORE_FILE = "mapping-libraries.json";

function loadOptionalDependency(packageName) {
  try {
    return {
      module: require(packageName),
      error: null
    };
  } catch (error) {
    console.error(`[time4midi] Optional dependency "${packageName}" failed to load:`, error);
    return {
      module: null,
      error
    };
  }
}

function dependencyError(label, dependency) {
  const detail = dependency.error?.message || "Modul nicht verfuegbar";
  return new Error(`${label} Modul nicht verfuegbar: ${detail}`);
}

const serialportDependency = loadOptionalDependency("serialport");
const SerialPort = serialportDependency.module?.SerialPort || null;

function createStatusEmitter() {
  return {
    statusListeners: new Set(),
    lastError: ""
  };
}

function emitStatus(target, message) {
  target.lastError = message || "";
  const payload = {
    ok: !target.lastError,
    error: target.lastError
  };
  for (const listener of target.statusListeners) {
    listener(payload);
  }
}

function addStatusApi(target, handler) {
  target.statusListeners.add(handler);
  handler({
    ok: !target.lastError,
    error: target.lastError
  });
  return () => {
    target.statusListeners.delete(handler);
  };
}

function normalizeDiagnosticsChannelValues(values) {
  if (!Array.isArray(values)) {
    return [];
  }

  return values.slice(0, 512).map((value) => {
    const safeValue = Math.round(Number(value) || 0);
    return Math.max(0, Math.min(255, safeValue));
  });
}

function recordDiagnostics(record) {
  try {
    ipcRenderer.send("diagnostics:record", {
      ...record,
      timestamp: Date.now()
    });
  } catch (_error) {
    // Ignore diagnostics forwarding issues to avoid blocking output.
  }
}

const artnet = {
  ...createStatusEmitter(),
  sendSocket: null,
  sendSocketSignature: "",
  listenSocket: null,
  listeners: new Set(),
  config: {
    enabled: true,
    localAddress: "",
    host: "255.255.255.255",
    port: ARTNET_PORT,
    broadcast: true,
    timecodeListenPort: ARTNET_PORT
  },
  sequence: 1
};

const sacn = {
  ...createStatusEmitter(),
  socket: null,
  socketSignature: "",
  config: {
    enabled: false,
    localAddress: "",
    host: "",
    port: SACN_PORT,
    multicast: true,
    sourceName: "Time4Midi"
  },
  sequence: 1,
  cid: crypto.randomBytes(16)
};

const osc = {
  ...createStatusEmitter(),
  socket: null,
  socketSignature: "",
  config: {
    enabled: false,
    localAddress: "",
    host: "127.0.0.1",
    port: 8000
  }
};

const mqttState = {
  ...createStatusEmitter(),
  client: null,
  connected: false,
  config: {
    enabled: false,
    localAddress: "",
    brokerUrl: "mqtt://127.0.0.1:1883",
    username: "",
    password: "",
    clientId: ""
  }
};

const serialState = {
  ...createStatusEmitter(),
  port: null,
  config: {
    enabled: false,
    path: "",
    baudRate: 9600,
    dataBits: 8,
    stopBits: 1,
    parity: "none",
    mode: "rs232"
  }
};

const modbusTcpState = {
  ...createStatusEmitter(),
  client: new ModbusRTU(),
  connected: false,
  signature: "",
  config: {
    enabled: false,
    localAddress: "",
    host: "127.0.0.1",
    port: 502,
    timeout: 1000
  }
};

const modbusRtuState = {
  ...createStatusEmitter(),
  client: new ModbusRTU(),
  connected: false,
  signature: "",
  config: {
    enabled: false,
    path: "",
    baudRate: 9600,
    dataBits: 8,
    stopBits: 1,
    parity: "none",
    timeout: 1000
  }
};

const knxState = {
  ...createStatusEmitter(),
  connection: null,
  connecting: null,
  connected: false,
  config: {
    enabled: false,
    interface: "",
    ipAddr: "224.0.23.12",
    ipPort: KNX_PORT,
    physAddr: "15.15.15",
    forceTunneling: false
  }
};

function normalizeArtNetConfig(nextConfig = {}) {
  return {
    enabled: nextConfig.enabled !== false,
    localAddress: String(nextConfig.localAddress || "").trim(),
    host: nextConfig.host || "255.255.255.255",
    port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : ARTNET_PORT,
    broadcast: Boolean(nextConfig.broadcast),
    timecodeListenPort: Number.isFinite(Number(nextConfig.timecodeListenPort))
      ? Number(nextConfig.timecodeListenPort)
      : ARTNET_PORT
  };
}

function normalizeSacnConfig(nextConfig = {}) {
  return {
    enabled: Boolean(nextConfig.enabled),
    localAddress: String(nextConfig.localAddress || "").trim(),
    host: String(nextConfig.host || ""),
    port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : SACN_PORT,
    multicast: nextConfig.multicast !== false,
    sourceName: String(nextConfig.sourceName || "Time4Midi").slice(0, 63)
  };
}

function normalizeOscConfig(nextConfig = {}) {
  return {
    enabled: Boolean(nextConfig.enabled),
    localAddress: String(nextConfig.localAddress || "").trim(),
    host: nextConfig.host || "127.0.0.1",
    port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : 8000
  };
}

function normalizeMqttConfig(nextConfig = {}) {
  return {
    enabled: Boolean(nextConfig.enabled),
    localAddress: String(nextConfig.localAddress || "").trim(),
    brokerUrl: String(nextConfig.brokerUrl || "").trim() || "mqtt://127.0.0.1:1883",
    username: String(nextConfig.username || ""),
    password: String(nextConfig.password || ""),
    clientId: String(nextConfig.clientId || "")
  };
}

function normalizeSerialConfig(nextConfig = {}) {
  return {
    enabled: Boolean(nextConfig.enabled),
    path: String(nextConfig.path || ""),
    baudRate: Number.isFinite(Number(nextConfig.baudRate)) ? Number(nextConfig.baudRate) : 9600,
    dataBits: [7, 8].includes(Number(nextConfig.dataBits)) ? Number(nextConfig.dataBits) : 8,
    stopBits: [1, 2].includes(Number(nextConfig.stopBits)) ? Number(nextConfig.stopBits) : 1,
    parity: ["none", "even", "odd"].includes(String(nextConfig.parity || "none")) ? String(nextConfig.parity || "none") : "none",
    mode: String(nextConfig.mode || "rs232")
  };
}

function normalizeModbusTcpConfig(nextConfig = {}) {
  return {
    enabled: Boolean(nextConfig.enabled),
    localAddress: String(nextConfig.localAddress || "").trim(),
    host: String(nextConfig.host || "127.0.0.1"),
    port: Number.isFinite(Number(nextConfig.port)) ? Number(nextConfig.port) : 502,
    timeout: Number.isFinite(Number(nextConfig.timeout)) ? Number(nextConfig.timeout) : 1000
  };
}

function normalizeModbusRtuConfig(nextConfig = {}) {
  return {
    enabled: Boolean(nextConfig.enabled),
    path: String(nextConfig.path || ""),
    baudRate: Number.isFinite(Number(nextConfig.baudRate)) ? Number(nextConfig.baudRate) : 9600,
    dataBits: [7, 8].includes(Number(nextConfig.dataBits)) ? Number(nextConfig.dataBits) : 8,
    stopBits: [1, 2].includes(Number(nextConfig.stopBits)) ? Number(nextConfig.stopBits) : 1,
    parity: ["none", "even", "odd"].includes(String(nextConfig.parity || "none")) ? String(nextConfig.parity || "none") : "none",
    timeout: Number.isFinite(Number(nextConfig.timeout)) ? Number(nextConfig.timeout) : 1000
  };
}

function normalizeKnxConfig(nextConfig = {}) {
  return {
    enabled: Boolean(nextConfig.enabled),
    interface: String(nextConfig.interface || "").trim(),
    ipAddr: String(nextConfig.ipAddr || "224.0.23.12"),
    ipPort: Number.isFinite(Number(nextConfig.ipPort)) ? Number(nextConfig.ipPort) : KNX_PORT,
    physAddr: String(nextConfig.physAddr || "15.15.15"),
    forceTunneling: Boolean(nextConfig.forceTunneling)
  };
}

function createUdpSocket(target, label) {
  const socket = dgram.createSocket("udp4");
  socket.on("error", (error) => {
    emitStatus(target, `${label} Socket Fehler: ${error.message}`);
  });
  return socket;
}

function closeUdpSocket(target, key, signatureKey) {
  if (target[key]) {
    try {
      target[key].close();
    } catch (_error) {
      // Ignore close races while reconfiguring sockets.
    }
  }
  target[key] = null;
  target[signatureKey] = "";
}

async function ensureUdpSocket(target, key, signatureKey, label, config, options = {}) {
  const signature = [
    config.localAddress || "",
    options.broadcast ? "1" : "0",
    options.multicast ? "1" : "0",
    options.multicastInterface || "",
    Number.isFinite(Number(options.multicastTtl)) ? String(Number(options.multicastTtl)) : ""
  ].join("|");
  if (target[key] && target[signatureKey] === signature) {
    return target[key];
  }

  closeUdpSocket(target, key, signatureKey);
  const socket = createUdpSocket(target, label);
  target[key] = socket;
  target[signatureKey] = signature;

  const bindAddress = config.localAddress || "0.0.0.0";
  const requiresBinding = Boolean(
    config.localAddress
    || options.broadcast
    || options.multicast
    || options.forceBind
  );
  if (!requiresBinding) {
    emitStatus(target, "");
    return socket;
  }

  await new Promise((resolve, reject) => {
    let settled = false;
    const handleError = (error) => {
      if (settled) {
        return;
      }
      settled = true;
      socket.off("listening", handleListening);
      reject(error);
    };
    const handleListening = () => {
      if (settled) {
        return;
      }
      settled = true;
      socket.off("error", handleError);
      resolve(true);
    };

    socket.once("error", handleError);
    socket.once("listening", handleListening);
    try {
      socket.bind(0, bindAddress);
    } catch (error) {
      socket.off("error", handleError);
      socket.off("listening", handleListening);
      reject(error);
    }
  });

  if (options.broadcast) {
    socket.setBroadcast(true);
  }
  if (options.multicast) {
    if (Number.isFinite(Number(options.multicastTtl))) {
      socket.setMulticastTTL(Number(options.multicastTtl));
    }
    if (options.multicastInterface) {
      socket.setMulticastInterface(options.multicastInterface);
    }
  }

  emitStatus(target, "");
  return socket;
}

function closeArtNetListener() {
  if (artnet.listenSocket) {
    try {
      artnet.listenSocket.close();
    } catch (_error) {
      // Ignore listener close races.
    }
    artnet.listenSocket = null;
  }
}

function parseArtNetTimecode(message) {
  if (message.length < 19) {
    return null;
  }
  if (!message.subarray(0, 8).equals(ARTNET_HEADER)) {
    return null;
  }
  const opcode = message.readUInt16LE(8);
  if (opcode !== ARTNET_OPCODE_TIMECODE) {
    return null;
  }

  const frames = message[14];
  const seconds = message[15];
  const minutes = message[16];
  const hours = message[17];
  const frameType = message[18] & 0x03;
  const fpsMap = [24, 25, 29.97, 30];
  const fps = fpsMap[frameType] || 30;
  const totalSeconds = (hours * 3600) + (minutes * 60) + seconds + (frames / fps);
  return { hours, minutes, seconds, frames, fps, totalSeconds };
}

function ensureArtNetListener() {
  if (!artnet.config.enabled || artnet.listenSocket) {
    return;
  }

  artnet.listenSocket = createUdpSocket(artnet, "Art-Net");
  artnet.listenSocket.on("listening", () => {
    emitStatus(artnet, "");
  });
  artnet.listenSocket.on("message", (message) => {
    const parsed = parseArtNetTimecode(message);
    if (!parsed) return;
    for (const listener of artnet.listeners) {
      listener(parsed);
    }
  });

  try {
    if (artnet.config.localAddress) {
      artnet.listenSocket.bind(artnet.config.timecodeListenPort, artnet.config.localAddress);
    } else {
      artnet.listenSocket.bind(artnet.config.timecodeListenPort);
    }
  } catch (error) {
    emitStatus(artnet, `Art-Net Listen Fehler: ${error.message}`);
  }
}

function configureArtNet(nextConfig) {
  const previousPort = artnet.config.timecodeListenPort;
  const previousLocalAddress = artnet.config.localAddress;
  artnet.config = normalizeArtNetConfig(nextConfig);

  if (!artnet.config.enabled) {
    closeArtNetListener();
    closeUdpSocket(artnet, "sendSocket", "sendSocketSignature");
    emitStatus(artnet, "");
    return artnet.config;
  }

  if (
    previousPort !== artnet.config.timecodeListenPort
    || previousLocalAddress !== artnet.config.localAddress
  ) {
    closeArtNetListener();
  }
  if (
    artnet.sendSocket
    && (
      previousLocalAddress !== artnet.config.localAddress
      || Boolean(artnet.config.broadcast) !== artnet.sendSocketSignature.endsWith("|1")
    )
  ) {
    closeUdpSocket(artnet, "sendSocket", "sendSocketSignature");
  }
  if (artnet.listeners.size > 0) {
    ensureArtNetListener();
  }
  return artnet.config;
}

async function sendArtNetDmx(payload) {
  if (!artnet.config.enabled) {
    return false;
  }

  const universe = Math.max(0, Math.min(32767, Number(payload.universe) || 0));
  const values = Array.isArray(payload.values) ? payload.values : [];
  const diagnosticsValues = normalizeDiagnosticsChannelValues(values);
  const length = Math.max(2, Math.min(512, values.length || 512));
  const evenLength = length % 2 === 0 ? length : length + 1;
  const packet = Buffer.alloc(18 + evenLength);

  ARTNET_HEADER.copy(packet, 0);
  packet.writeUInt16LE(ARTNET_OPCODE_DMX, 8);
  packet[10] = 0x00;
  packet[11] = 0x0e;
  packet[12] = artnet.sequence;
  packet[13] = 0x00;
  packet.writeUInt16LE(universe, 14);
  packet.writeUInt16BE(evenLength, 16);
  for (let index = 0; index < evenLength; index += 1) {
    packet[18 + index] = Math.max(0, Math.min(255, Math.round(values[index] || 0)));
  }
  artnet.sequence = artnet.sequence >= 255 ? 1 : artnet.sequence + 1;

  const socket = await ensureUdpSocket(
    artnet,
    "sendSocket",
    "sendSocketSignature",
    "Art-Net",
    artnet.config,
    { broadcast: artnet.config.broadcast }
  );

  return new Promise((resolve, reject) => {
    socket.send(packet, 0, packet.length, artnet.config.port, artnet.config.host, (error) => {
      if (error) {
        emitStatus(artnet, `Art-Net Send Fehler: ${error.message}`);
        reject(error);
        return;
      }
      emitStatus(artnet, "");
      recordDiagnostics({
        kind: "dmx-frame",
        transport: "artnet",
        universe,
        values: diagnosticsValues
      });
      resolve(true);
    });
  });
}

function configureOsc(nextConfig) {
  const previousLocalAddress = osc.config.localAddress;
  osc.config = normalizeOscConfig(nextConfig);
  if (previousLocalAddress !== osc.config.localAddress) {
    closeUdpSocket(osc, "socket", "socketSignature");
  }
  emitStatus(osc, "");
  return osc.config;
}

function encodeOscString(value) {
  const base = Buffer.from(`${value}\0`, "utf8");
  const padding = (4 - (base.length % 4)) % 4;
  return padding === 0 ? base : Buffer.concat([base, Buffer.alloc(padding)]);
}

function encodeOscArgument(value, argType) {
  if (argType === "string") {
    return { tag: "s", data: encodeOscString(String(value ?? "")) };
  }
  if (argType === "int") {
    const data = Buffer.alloc(4);
    data.writeInt32BE(Math.round(Number(value) || 0), 0);
    return { tag: "i", data };
  }
  const data = Buffer.alloc(4);
  data.writeFloatBE(Number(value) || 0, 0);
  return { tag: "f", data };
}

async function sendOsc(payload) {
  if (!osc.config.enabled) {
    return false;
  }
  const address = String(payload.address || "/time4midi");
  const normalizedAddress = address.startsWith("/") ? address : `/${address}`;
  const argument = encodeOscArgument(payload.value, payload.argType || "float");
  const packet = Buffer.concat([
    encodeOscString(normalizedAddress),
    encodeOscString(`,${argument.tag}`),
    argument.data
  ]);
  const socket = await ensureUdpSocket(osc, "socket", "socketSignature", "OSC", osc.config);
  return new Promise((resolve, reject) => {
    socket.send(packet, 0, packet.length, osc.config.port, osc.config.host, (error) => {
      if (error) {
        emitStatus(osc, `OSC Send Fehler: ${error.message}`);
        reject(error);
        return;
      }
      emitStatus(osc, "");
      resolve(true);
    });
  });
}

function configureSacn(nextConfig) {
  const previousLocalAddress = sacn.config.localAddress;
  const previousMulticast = sacn.config.multicast;
  sacn.config = normalizeSacnConfig(nextConfig);
  if (
    previousLocalAddress !== sacn.config.localAddress
    || previousMulticast !== sacn.config.multicast
  ) {
    closeUdpSocket(sacn, "socket", "socketSignature");
  }
  emitStatus(sacn, "");
  return sacn.config;
}

function clampSacnUniverse(universe) {
  return Math.max(1, Math.min(63999, Number(universe) || 1));
}

function sacnDestination(universe) {
  const safeUniverse = clampSacnUniverse(universe);
  if (!sacn.config.multicast) {
    return sacn.config.host || "127.0.0.1";
  }
  const high = (safeUniverse >> 8) & 0xff;
  const low = safeUniverse & 0xff;
  return `239.255.${high}.${low}`;
}

function encodeFlagsAndLength(length) {
  return 0x7000 | length;
}

function writeFixedString(buffer, offset, size, value) {
  buffer.fill(0, offset, offset + size);
  Buffer.from(String(value || ""), "utf8").copy(buffer, offset, 0, size);
}

async function sendSacnDmx(payload) {
  if (!sacn.config.enabled) {
    return false;
  }

  const universe = clampSacnUniverse(payload.universe);
  const values = Array.isArray(payload.values) ? payload.values : [];
  const diagnosticsValues = normalizeDiagnosticsChannelValues(values);
  const slotCount = Math.max(1, Math.min(512, values.length || 512));
  const packetLength = 126 + slotCount;
  const propertyValueCount = slotCount + 1;
  const packet = Buffer.alloc(packetLength);

  packet.writeUInt16BE(0x0010, 0);
  packet.writeUInt16BE(0x0000, 2);
  writeFixedString(packet, 4, 12, "ASC-E1.17");

  packet.writeUInt16BE(encodeFlagsAndLength(packetLength - 16), 16);
  packet.writeUInt32BE(0x00000004, 18);
  sacn.cid.copy(packet, 22);

  packet.writeUInt16BE(encodeFlagsAndLength(packetLength - 38), 38);
  packet.writeUInt32BE(0x00000002, 40);
  writeFixedString(packet, 44, 64, sacn.config.sourceName || "Time4Midi");
  packet[108] = 100;
  packet.writeUInt16BE(0x0000, 109);
  packet[111] = sacn.sequence;
  packet[112] = 0x00;
  packet.writeUInt16BE(universe, 113);

  packet.writeUInt16BE(encodeFlagsAndLength(packetLength - 115), 115);
  packet[117] = 0x02;
  packet[118] = 0xa1;
  packet.writeUInt16BE(0x0000, 119);
  packet.writeUInt16BE(0x0001, 121);
  packet.writeUInt16BE(propertyValueCount, 123);
  packet[125] = 0x00;

  for (let index = 0; index < slotCount; index += 1) {
    packet[126 + index] = Math.max(0, Math.min(255, Math.round(values[index] || 0)));
  }

  sacn.sequence = sacn.sequence >= 255 ? 1 : sacn.sequence + 1;
  const host = sacnDestination(universe);
  const socket = await ensureUdpSocket(
    sacn,
    "socket",
    "socketSignature",
    "sACN",
    sacn.config,
    {
      multicast: sacn.config.multicast,
      multicastInterface: sacn.config.localAddress || "",
      multicastTtl: 32,
      forceBind: sacn.config.multicast
    }
  );

  return new Promise((resolve, reject) => {
    socket.send(packet, 0, packet.length, sacn.config.port, host, (error) => {
      if (error) {
        emitStatus(sacn, `sACN Send Fehler: ${error.message}`);
        reject(error);
        return;
      }
      emitStatus(sacn, "");
      recordDiagnostics({
        kind: "dmx-frame",
        transport: "sacn",
        universe,
        values: diagnosticsValues
      });
      resolve(true);
    });
  });
}

function disconnectMqtt() {
  if (mqttState.client) {
    try {
      mqttState.client.removeAllListeners();
      mqttState.client.end(true);
    } catch (_error) {
      // Best effort disconnect.
    }
  }
  mqttState.client = null;
  mqttState.connected = false;
}

function configureMqtt(nextConfig) {
  mqttState.config = normalizeMqttConfig(nextConfig);
  disconnectMqtt();

  if (!mqttState.config.enabled) {
    emitStatus(mqttState, "");
    return mqttState.config;
  }

  const options = { reconnectPeriod: 1000 };
  if (mqttState.config.clientId) options.clientId = mqttState.config.clientId;
  if (mqttState.config.username) options.username = mqttState.config.username;
  if (mqttState.config.password) options.password = mqttState.config.password;
  if (mqttState.config.localAddress) options.localAddress = mqttState.config.localAddress;

  try {
    mqttState.client = mqtt.connect(mqttState.config.brokerUrl, options);
    mqttState.client.on("connect", () => {
      mqttState.connected = true;
      emitStatus(mqttState, "");
    });
    mqttState.client.on("reconnect", () => {
      mqttState.connected = false;
      emitStatus(mqttState, "MQTT verbindet neu...");
    });
    mqttState.client.on("close", () => {
      mqttState.connected = false;
    });
    mqttState.client.on("error", (error) => {
      mqttState.connected = false;
      emitStatus(mqttState, `MQTT Fehler: ${error.message}`);
    });
  } catch (error) {
    emitStatus(mqttState, `MQTT Fehler: ${error.message}`);
  }

  return mqttState.config;
}

function publishMqtt(payload) {
  if (!mqttState.config.enabled) {
    return Promise.resolve(false);
  }
  return new Promise((resolve, reject) => {
    if (!mqttState.client || !mqttState.connected) {
      reject(new Error("MQTT nicht verbunden"));
      return;
    }
    mqttState.client.publish(String(payload.topic || ""), String(payload.value ?? ""), {}, (error) => {
      if (error) {
        emitStatus(mqttState, `MQTT Send Fehler: ${error.message}`);
        reject(error);
        return;
      }
      emitStatus(mqttState, "");
      recordDiagnostics({
        kind: "mqtt-publish",
        topic: String(payload.topic || ""),
        value: String(payload.value ?? "")
      });
      resolve(true);
    });
  });
}

function closeSerialPort() {
  return new Promise((resolve) => {
    if (!serialState.port) {
      resolve();
      return;
    }
    const port = serialState.port;
    serialState.port = null;
    if (!port.isOpen) {
      resolve();
      return;
    }
    port.close(() => resolve());
  });
}

async function configureSerial(nextConfig) {
  serialState.config = normalizeSerialConfig(nextConfig);
  await closeSerialPort();
  emitStatus(serialState, "");
  return serialState.config;
}

async function ensureSerialPortOpen() {
  if (!SerialPort) {
    throw dependencyError("Serial", serialportDependency);
  }
  if (!serialState.config.enabled) {
    throw new Error("Serial deaktiviert");
  }
  if (!serialState.config.path) {
    throw new Error("Serial Port nicht gesetzt");
  }
  if (serialState.port && serialState.port.isOpen && serialState.port.path === serialState.config.path) {
    return serialState.port;
  }
  await closeSerialPort();

  serialState.port = new SerialPort({
    path: serialState.config.path,
    baudRate: serialState.config.baudRate,
    dataBits: serialState.config.dataBits,
    stopBits: serialState.config.stopBits,
    parity: serialState.config.parity,
    autoOpen: false
  });

  serialState.port.on("error", (error) => {
    emitStatus(serialState, `Serial Fehler: ${error.message}`);
  });

  await new Promise((resolve, reject) => {
    serialState.port.open((error) => {
      if (error) {
        reject(error);
        return;
      }
      resolve(true);
    });
  });

  emitStatus(serialState, "");
  return serialState.port;
}

async function sendSerial(payload) {
  if (!serialState.config.enabled) {
    return false;
  }
  const port = await ensureSerialPortOpen();
  const text = String(payload.text ?? "");
  return new Promise((resolve, reject) => {
    port.write(text, "utf8", (error) => {
      if (error) {
        emitStatus(serialState, `Serial Send Fehler: ${error.message}`);
        reject(error);
        return;
      }
      emitStatus(serialState, "");
      resolve(true);
    });
  });
}

async function listSerialPorts() {
  if (!SerialPort) {
    throw dependencyError("Serial", serialportDependency);
  }
  const ports = await SerialPort.list();
  return ports.map((port) => ({
    path: port.path,
    manufacturer: port.manufacturer || "",
    friendlyName: port.path
  }));
}

async function listNetworkInterfaces() {
  const interfaces = os.networkInterfaces();
  const items = [];

  Object.entries(interfaces).forEach(([name, entries]) => {
    (entries || []).forEach((entry) => {
      const family = typeof entry.family === "string" ? entry.family : String(entry.family);
      if (family !== "IPv4" || entry.internal || !entry.address) {
        return;
      }

      items.push({
        id: entry.address,
        name: `${name} - ${entry.address}`,
        interfaceName: name,
        address: entry.address
      });
    });
  });

  items.sort((left, right) => left.name.localeCompare(right.name));
  return items;
}

async function readJsonFileSafe(filePath, fallbackValue) {
  try {
    const raw = await fs.readFile(filePath, "utf8");
    return JSON.parse(raw);
  } catch (error) {
    if (error?.code === "ENOENT") {
      return fallbackValue;
    }
    throw error;
  }
}

async function writeJsonFile(filePath, data) {
  await fs.mkdir(path.dirname(filePath), { recursive: true });
  await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
}

async function getMappingLibraryStorePath() {
  const userDataPath = await ipcRenderer.invoke("app:getUserDataPath");
  return path.join(userDataPath, MAPPING_LIBRARY_STORE_FILE);
}

async function loadStoredMappingLibraries() {
  const filePath = await getMappingLibraryStorePath();
  const data = await readJsonFileSafe(filePath, null);
  return {
    filePath,
    data
  };
}

async function saveStoredMappingLibraries(data) {
  const filePath = await getMappingLibraryStorePath();
  await writeJsonFile(filePath, data);
  return { filePath };
}

async function importMappingLibrary(defaultPath) {
  const result = await ipcRenderer.invoke("mappingLibrary:pickLoadFile", { defaultPath });
  if (result?.canceled || !result?.filePath) {
    return { canceled: true };
  }

  const data = await readJsonFileSafe(result.filePath, null);
  return {
    canceled: false,
    filePath: result.filePath,
    data
  };
}

async function exportMappingLibrary(defaultPath, data) {
  const result = await ipcRenderer.invoke("mappingLibrary:pickSaveFile", { defaultPath });
  if (result?.canceled || !result?.filePath) {
    return { canceled: true };
  }

  await writeJsonFile(result.filePath, data);
  return {
    canceled: false,
    filePath: result.filePath
  };
}

async function disconnectModbusClient(state) {
  if (state.client?.isOpen) {
    try {
      await state.client.close();
    } catch (_error) {
      // Best effort close.
    }
  }
  state.connected = false;
  state.signature = "";
}

async function configureModbusTcp(nextConfig) {
  modbusTcpState.config = normalizeModbusTcpConfig(nextConfig);
  await disconnectModbusClient(modbusTcpState);
  emitStatus(modbusTcpState, "");
  return modbusTcpState.config;
}

async function configureModbusRtu(nextConfig) {
  modbusRtuState.config = normalizeModbusRtuConfig(nextConfig);
  await disconnectModbusClient(modbusRtuState);
  emitStatus(modbusRtuState, "");
  return modbusRtuState.config;
}

async function ensureModbusTcpConnected() {
  if (!modbusTcpState.config.enabled) {
    throw new Error("Modbus TCP deaktiviert");
  }
  const signature = `${modbusTcpState.config.host}:${modbusTcpState.config.port}:${modbusTcpState.config.timeout}`;
  if (modbusTcpState.connected && modbusTcpState.signature === signature && modbusTcpState.client.isOpen) {
    return modbusTcpState.client;
  }
  await disconnectModbusClient(modbusTcpState);
  await modbusTcpState.client.connectTCP(modbusTcpState.config.host, {
    port: modbusTcpState.config.port,
    timeout: modbusTcpState.config.timeout,
    localAddress: modbusTcpState.config.localAddress || undefined
  });
  modbusTcpState.client.setTimeout(modbusTcpState.config.timeout);
  modbusTcpState.connected = true;
  modbusTcpState.signature = signature;
  emitStatus(modbusTcpState, "");
  return modbusTcpState.client;
}

async function ensureModbusRtuConnected() {
  if (!modbusRtuState.config.enabled) {
    throw new Error("Modbus RTU deaktiviert");
  }
  if (!modbusRtuState.config.path) {
    throw new Error("Modbus RTU Port nicht gesetzt");
  }
  const signature = `${modbusRtuState.config.path}:${modbusRtuState.config.baudRate}:${modbusRtuState.config.parity}:${modbusRtuState.config.dataBits}:${modbusRtuState.config.stopBits}`;
  if (modbusRtuState.connected && modbusRtuState.signature === signature && modbusRtuState.client.isOpen) {
    return modbusRtuState.client;
  }
  await disconnectModbusClient(modbusRtuState);
  await modbusRtuState.client.connectRTUBuffered(modbusRtuState.config.path, {
    baudRate: modbusRtuState.config.baudRate,
    parity: modbusRtuState.config.parity,
    dataBits: modbusRtuState.config.dataBits,
    stopBits: modbusRtuState.config.stopBits
  });
  modbusRtuState.client.setTimeout(modbusRtuState.config.timeout);
  modbusRtuState.connected = true;
  modbusRtuState.signature = signature;
  emitStatus(modbusRtuState, "");
  return modbusRtuState.client;
}

async function writeModbus(client, payload) {
  client.setID(Number(payload.unitId) || 1);
  const address = Number(payload.address) || 0;
  const value = Number(payload.value) || 0;
  if (payload.registerType === "coil") {
    await client.writeCoil(address, value >= 1);
  } else {
    await client.writeRegister(address, Math.max(0, Math.min(32767, Math.round(value))));
  }
}

async function sendModbusTcp(payload) {
  const client = await ensureModbusTcpConnected();
  try {
    await writeModbus(client, payload);
    emitStatus(modbusTcpState, "");
    return true;
  } catch (error) {
    emitStatus(modbusTcpState, `Modbus TCP Fehler: ${error.message}`);
    throw error;
  }
}

async function sendModbusRtu(payload) {
  const client = await ensureModbusRtuConnected();
  try {
    await writeModbus(client, payload);
    emitStatus(modbusRtuState, "");
    return true;
  } catch (error) {
    emitStatus(modbusRtuState, `Modbus RTU Fehler: ${error.message}`);
    throw error;
  }
}

function disconnectKnx() {
  return new Promise((resolve) => {
    if (!knxState.connection) {
      knxState.connected = false;
      knxState.connecting = null;
      resolve();
      return;
    }

    const connection = knxState.connection;
    knxState.connection = null;
    knxState.connected = false;
    knxState.connecting = null;
    try {
      connection.Disconnect(() => resolve());
    } catch (_error) {
      resolve();
    }
  });
}

async function configureKnx(nextConfig) {
  knxState.config = normalizeKnxConfig(nextConfig);
  await disconnectKnx();
  emitStatus(knxState, "");
  return knxState.config;
}

async function ensureKnxConnection() {
  if (!knxState.config.enabled) {
    throw new Error("KNX deaktiviert");
  }
  if (knxState.connection && knxState.connected) {
    return knxState.connection;
  }
  if (knxState.connecting) {
    return knxState.connecting;
  }

  knxState.connecting = new Promise((resolve, reject) => {
    try {
      const connection = knx.Connection({
        ipAddr: knxState.config.ipAddr,
        ipPort: knxState.config.ipPort,
        interface: knxState.config.interface || undefined,
        physAddr: knxState.config.physAddr,
        forceTunneling: knxState.config.forceTunneling,
        handlers: {
          connected: function () {
            knxState.connection = connection;
            knxState.connected = true;
            knxState.connecting = null;
            emitStatus(knxState, "");
            resolve(connection);
          },
          disconnected: function () {
            knxState.connected = false;
            knxState.connection = null;
          },
          error: function (error) {
            knxState.connected = false;
            knxState.connection = null;
            knxState.connecting = null;
            const message = error?.message || String(error);
            emitStatus(knxState, `KNX Fehler: ${message}`);
            reject(error instanceof Error ? error : new Error(message));
          }
        }
      });
      knxState.connection = connection;
    } catch (error) {
      knxState.connecting = null;
      emitStatus(knxState, `KNX Fehler: ${error.message}`);
      reject(error);
    }
  });

  return knxState.connecting;
}

async function sendKnx(payload) {
  const connection = await ensureKnxConnection();
  const dpt = String(payload.dpt || "DPT5.001");
  let value = payload.value;
  if (dpt.startsWith("DPT1")) {
    value = Number(value) >= 1;
  } else if (dpt.startsWith("DPT16")) {
    value = String(value ?? "");
  } else {
    value = Number(value) || 0;
  }

  return new Promise((resolve, reject) => {
    try {
      connection.write(String(payload.groupAddress || "1/1/1"), value, dpt, (error) => {
        if (error) {
          emitStatus(knxState, `KNX Send Fehler: ${error.message}`);
          reject(error);
          return;
        }
        emitStatus(knxState, "");
        recordDiagnostics({
          kind: "knx-write",
          groupAddress: String(payload.groupAddress || "1/1/1"),
          dpt,
          value
        });
        resolve(true);
      });
    } catch (error) {
      emitStatus(knxState, `KNX Send Fehler: ${error.message}`);
      reject(error);
    }
  });
}

configureMqtt(mqttState.config);

contextBridge.exposeInMainWorld("time4midi", {
  project: {
    save: (payload) => ipcRenderer.invoke("project:save", payload),
    load: () => ipcRenderer.invoke("project:load")
  },
  audio: {
    pickFile: () => ipcRenderer.invoke("audio:pickFile"),
    readFile: async (filePath) => {
      const buffer = await fs.readFile(filePath);
      return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
    },
    fileUrl: (filePath) => pathToFileURL(filePath).href
  },
  mappingLibraries: {
    loadStore: () => loadStoredMappingLibraries(),
    saveStore: (data) => saveStoredMappingLibraries(data),
    importFile: (defaultPath) => importMappingLibrary(defaultPath),
    exportFile: (defaultPath, data) => exportMappingLibrary(defaultPath, data)
  },
  diagnostics: {
    openWindow: () => ipcRenderer.invoke("diagnostics:openWindow"),
    getSnapshot: () => ipcRenderer.invoke("diagnostics:getSnapshot"),
    subscribe: (handler) => {
      const listener = (_event, record) => {
        handler(record);
      };
      ipcRenderer.on("diagnostics:update", listener);
      return () => {
        ipcRenderer.removeListener("diagnostics:update", listener);
      };
    }
  },
  network: {
    listInterfaces: () => listNetworkInterfaces()
  },
  artnet: {
    configure: (config) => configureArtNet(config),
    sendDmx: (payload) => sendArtNetDmx(payload),
    onTimecode: (handler) => {
      artnet.listeners.add(handler);
      ensureArtNetListener();
      return () => {
        artnet.listeners.delete(handler);
      };
    },
    onStatus: (handler) => addStatusApi(artnet, handler)
  },
  sacn: {
    configure: (config) => configureSacn(config),
    sendDmx: (payload) => sendSacnDmx(payload),
    onStatus: (handler) => addStatusApi(sacn, handler)
  },
  osc: {
    configure: (config) => configureOsc(config),
    send: (payload) => sendOsc(payload),
    onStatus: (handler) => addStatusApi(osc, handler)
  },
  mqtt: {
    configure: (config) => configureMqtt(config),
    publish: (payload) => publishMqtt(payload),
    onStatus: (handler) => addStatusApi(mqttState, handler)
  },
  serial: {
    configure: (config) => configureSerial(config),
    send: (payload) => sendSerial(payload),
    listPorts: () => listSerialPorts(),
    onStatus: (handler) => addStatusApi(serialState, handler)
  },
  modbusTcp: {
    configure: (config) => configureModbusTcp(config),
    send: (payload) => sendModbusTcp(payload),
    onStatus: (handler) => addStatusApi(modbusTcpState, handler)
  },
  modbusRtu: {
    configure: (config) => configureModbusRtu(config),
    send: (payload) => sendModbusRtu(payload),
    onStatus: (handler) => addStatusApi(modbusRtuState, handler)
  },
  knx: {
    configure: (config) => configureKnx(config),
    send: (payload) => sendKnx(payload),
    onStatus: (handler) => addStatusApi(knxState, handler)
  }
});