machineGroupControl/src/nodeClass.js

const { outputUtils, configManager } = require("generalFunctions");
const Specific = require("./specificClass");

class nodeClass {
  /**
   * Create a MeasurementNode.
   * @param {object} uiConfig - Node-RED node configuration.
   * @param {object} RED    - Node-RED runtime API.
   * @param {object} nodeInstance - The Node-RED node instance.
   * @param {string} nameOfNode - The name of the node, used for
   */
  constructor(uiConfig, RED, nodeInstance, nameOfNode) {
    // Preserve RED reference for HTTP endpoints if needed
    this.node = nodeInstance; // This is the Node-RED node instance, we can use this to send messages and update status
    this.RED = RED; // This is the Node-RED runtime API, we can use this to create endpoints if needed
    this.name = nameOfNode; // This is the name of the node, it should match the file name and the node type in Node-RED
    this.source = null; // Will hold the specific class instance

    // Load default & UI config
    this._loadConfig(uiConfig, this.node);

    // Instantiate core Measurement class
    this._setupSpecificClass();

    // Wire up event and lifecycle handlers
    this._bindEvents();
    this._registerChild();
    this._startTickLoop();
    this._attachInputHandler();
    this._attachCloseHandler();
  }

  /**
   * Load and merge default config with user-defined settings.
   * @param {object} uiConfig - Raw config from Node-RED UI.
   */
  _loadConfig(uiConfig, node) {
    const cfgMgr = new configManager();
    this.defaultConfig = cfgMgr.getConfig(this.name);

    // Merge UI config over defaults
    this.config = {
      general: {
        name: uiConfig.name,
        id: node.id, // node.id is for the child registration process
        unit: uiConfig.unit, // add converter options later to convert to default units (need like a model that defines this which units we are going to use and then conver to those standards)
        logging: {
          enabled: uiConfig.enableLog,
          logLevel: uiConfig.logLevel,
        },
      },
      functionality: {
        positionVsParent: uiConfig.positionVsParent || "atEquipment", // Default to 'atEquipment' if not set
      },
    };
    // Utility for formatting outputs
    this._output = new outputUtils();
  }

  _updateNodeStatus() {
    const mg = this.source;
    const mode = mg.mode;
    const scaling = mg.scaling;
    const totalFlow =
      Math.round(
        mg.measurements
          .type("flow")
          .variant("predicted")
          .position("downstream")
          .getCurrentValue() * 1
      ) / 1;
    const totalPower =
      Math.round(
        mg.measurements
          .type("power")
          .variant("predicted")
          .position("upstream")
          .getCurrentValue() * 1
      ) / 1;

    // Calculate total capacity based on available machines
    const availableMachines = Object.values(mg.machines).filter((machine) => {
      const state = machine.state.getCurrentState();
      const mode = machine.currentMode;
      return !(
        state === "off" ||
        state === "maintenance" ||
        mode === "maintenance"
      );
    });

    const totalCapacity = Math.round(mg.dynamicTotals.flow.max * 1) / 1;

    // Determine overall status based on available machines
    const status =
      availableMachines.length > 0
        ? `${availableMachines.length} machines`
        : "No machines";

    let scalingSymbol = "";
    switch (scaling.toLowerCase()) {
      case "absolute":
        scalingSymbol = "Ⓐ"; // Clear symbol for Absolute mode
        break;
      case "normalized":
        scalingSymbol = "Ⓝ"; // Clear symbol for Normalized mode
        break;
      default:
        scalingSymbol = mode;
        break;
    }

    // Generate status text in a single line
    const text = ` ${mode} | ${scalingSymbol}: 💨=${totalFlow}/${totalCapacity} | ⚡=${totalPower} | ${status}`;

    return {
      fill: availableMachines.length > 0 ? "green" : "red",
      shape: "dot",
      text,
    };
  }

  /**
   * Instantiate the core logic and store as source.
   */
  _setupSpecificClass() {
    this.source = new Specific(this.config);
    this.node.source = this.source; // Store the source in the node instance for easy access
  }

  /**
   * Bind events to Node-RED status updates. Using internal emitter. --> REMOVE LATER WE NEED ONLY COMPLETE CHILDS AND THEN CHECK FOR UPDATES
   */
  _bindEvents() {
    this.source.emitter.on("mAbs", (val) => {
      this.node.status({
        fill: "green",
        shape: "dot",
        text: `${val} ${this.config.general.unit}`,
      });
    });
  }

  /**
   * Register this node as a child upstream and downstream.
   * Delayed to avoid Node-RED startup race conditions.
   */
  _registerChild() {
    setTimeout(() => {
      this.node.send([
        null,
        null,
        {
          topic: "registerChild",
          payload: this.node.id,
          positionVsParent:
            this.config?.functionality?.positionVsParent || "atEquipment",
        },
      ]);
    }, 100);
  }

  /**
   * Start the periodic tick loop to drive the Measurement class.
   */
  _startTickLoop() {
    setTimeout(() => {
      this._tickInterval = setInterval(() => this._tick(), 1000);
       // Update node status on nodered screen every second ( this is not the best way to do this, but it works for now)
      this._statusInterval = setInterval(() => {
        const status = this._updateNodeStatus();
        this.node.status(status);
      }, 1000);
    }, 1000);
  }

  /**
   * Execute a single tick: update measurement, format and send outputs.
   */
  _tick() {
    const raw = this.source.getOutput();
    const processMsg = this._output.formatMsg(raw, this.config, "process");
    const influxMsg = this._output.formatMsg(raw, this.config, "influxdb");

    // Send only updated outputs on ports 0 & 1
    this.node.send([processMsg, influxMsg]);
  }

  /**
   * Attach the node's input handler, routing control messages to the class.
   */
  _attachInputHandler() {
    this.node.on(
      "input",
      (msg, send, done) =>
        async function () {
          switch (msg.topic) {
            case "registerChild":
              const childId = msg.payload;
              const childObj = RED.nodes.getNode(childId);
              mg.childRegistrationUtils.registerChild(
                childObj.source,
                msg.positionVsParent
              );
              break;

            case "setMode":
              const mode = msg.payload;
              const source = "parent";
              mg.setMode(source, mode);
              break;

            case "setScaling":
              const scaling = msg.payload;
              mg.setScaling(scaling);
              break;

            case "Qd":
              const Qd = parseFloat(msg.payload);
              const sourceQd = "parent";

              if (isNaN(Qd)) {
                return mg.logger.error(`Invalid demand value: ${Qd}`);
              }

              try {
                await mg.handleInput(sourceQd, Qd);
                msg.topic = mg.config.general.name;
                msg.payload = "done";
                send(msg);
              } catch (e) {
                console.log(e);
              }
              break;

            default:
              // Handle unknown topics if needed
              break;
          }
          done();
        }
    );
  }

  /**
   * Clean up timers and intervals when Node-RED stops the node.
   */
  _attachCloseHandler() {
    this.node.on("close", (done) => {
      clearInterval(this._tickInterval);
      done();
    });
  }
}

module.exports = nodeClass; // Export the class for Node-RED to use