gsender

import { EventEmitter } from 'events';
import SerialConnection from './SerialConnection';
import {
    GRBLHAL,
    GRBLHAL_REALTIME_COMMANDS,
} from '../controllers/Grblhal/constants';
import { GRBL, GRBL_REALTIME_COMMANDS } from '../controllers/Grbl/constants';
import logger from './logger';
import { noop, includes } from 'lodash';
import { WRITE_SOURCE_CLIENT } from '../controllers/constants';

const log = logger('connection');

// Firmware identification: $I is sent repeatedly until the reply identifies the
// board as grbl or grblHAL. MAX_ATTEMPTS is the total number of $I sends,
// including the immediate first one - so detection gets roughly
// ATTEMPTS * INTERVAL ms before we fall back to the configured default.
const FIRMWARE_DETECT_INTERVAL = 800;
const FIRMWARE_DETECT_MAX_ATTEMPTS = 7;

class Connection extends EventEmitter {
    sockets = {};

    controller = null;

    controllerType = null;

    options = {};

    connection = null;

    engine = null;

    timeout = null;

    count = 0;

    connectionEventListener = {
        data: (data) => {
            this.emit('data', data);
            log.silly(`< ${data}`);
            if (this.controllerType === null) {
                data = ('' + data).replace(/\s+$/, '');
                if (!data) {
                    log.warn(
                        'Empty result parsed from Connection Class Parser',
                    );
                    return;
                }

                // Note - Do we need two grblHAL clauses if we're using i insensitive flag? - ie grblHAL|GrblHAL
                // https://regex101.com/r/oPVkkF/1
                const grblR = data.match(/.*(grbl|fluidnc).*/i);
                const grblHalR = data.match(/.*(grblhal).*/i);

                if (grblHalR) {
                    this.controllerType = GRBLHAL;
                    this.stopFirmwareDetection();
                    this.emit(
                        'firmwareFound',
                        GRBLHAL,
                        this.options,
                        this.callback,
                    );
                } else if (grblR) {
                    this.controllerType = GRBL;
                    this.stopFirmwareDetection();
                    this.emit(
                        'firmwareFound',
                        GRBL,
                        this.options,
                        this.callback,
                    );
                }
            } // we dont handle the runner
        },
        close: (err) => {
            this.emit('close', err);

            if (err) {
                log.warn(
                    `Disconnected from serial port "${this.options.port}":`,
                    err,
                );
            }

            this.close(err);
        },
        error: (err) => {
            log.error(`Connection error: ${err}`);
            this.emit('error', err);
            if (this.controllerType === null) {
                if (err) {
                    log.error(
                        `Unexpected error while reading/writing serial port "${this.options.port}":`,
                        err,
                    );
                }
            }
        },
    };

    constructor(engine, port, options, callback) {
        super();
        const { baudrate, rtscts, network, defaultFirmware, ethernetPort } = { ...options };
        this.options = {
            ...this.options,
            port: port,
            baudrate: baudrate,
            rtscts: !!rtscts,
            defaultFirmware,
            ethernetPort,
            network,
        };
        this.callback = callback;
        this.engine = engine;

        this.connection = new SerialConnection({
            path: port,
            baudRate: baudrate,
            rtscts: !!rtscts,
            ethernetPort,
            network,
            writeFilter: (data) => {
                const line = data.trim();

                if (!line) {
                    return data;
                }
                return data;
            },
        });
    }

    isOpen = () => {
        return this.connection && this.connection.isOpen;
    };

    isClose() {
        return !this.isOpen();
    }

    addConnection = (socket) => {
        if (!socket) {
            log.error('The socket parameter is not specified');
            return;
        }

        log.debug(`Add socket connection: id=${socket.id}`);
        this.sockets[socket.id] = socket;
    };

    removeConnection(socket) {
        if (!socket) {
            log.error('The socket parameter is not specified');
            return;
        }

        log.debug(`Remove socket connection: id=${socket.id}`);
        this.sockets[socket.id] = undefined;
        delete this.sockets[socket.id];
    }

    open = (callback = noop) => {
        const { port, network = false } = this.options;

        // Assertion check
        if (this.isOpen()) {
            log.error(`Cannot open serial port "${port}"`);
            return;
        }

        this.connection.on('data', this.connectionEventListener.data);
        this.connection.on('close', this.connectionEventListener.close);
        this.connection.on('error', this.connectionEventListener.error);

        this.connection.open((err) => {
            if (err) {
                // Remove listeners so the async 'close' from port.destroy()
                // doesn't re-enter Connection.close() and double-fire the callback
                /*this.connection.removeListener('data', this.connectionEventListener.data);
                this.connection.removeListener('close', this.connectionEventListener.close);
                this.connection.removeListener('error', this.connectionEventListener.error);*/
                log.error(`Error opening serial port "${port}":`, err);
                this.emit('serialport:error', { err: err, port: port });
                this.emit('serialport:close', {}, 1);
                callback(err); // notify error
                return;
            }

            // Emit a change event to all connected sockets
            if (this.engine.io) {
                this.engine.io.emit('serialport:change', {
                    port: port,
                    inuse: true,
                });
            }

            log.debug(`Connected to serial port "${port}"`);
            if (!this.controllerType) {
                this.startFirmwareDetection();
            }
        });
    };

    // Poll $I until the reply identifies the firmware (see the data listener),
    // then fall back to the user's configured default.
    startFirmwareDetection() {
        this.stopFirmwareDetection();
        this.count = 0;

        this.sendFirmwareQuery();

        this.timeout = setInterval(() => {
            // The port can disappear mid-detection - unplugged, or an 'error'
            // with no matching 'close'. SerialConnection.writeImmediate has no
            // port guard of its own, so check here rather than letting it throw
            // from inside the timer.
            if (this.isClose()) {
                log.warn(
                    `Port "${this.options.port}" closed during firmware detection`,
                );
                this.stopFirmwareDetection();
                return;
            }

            if (this.count >= FIRMWARE_DETECT_MAX_ATTEMPTS) {
                this.useDefaultFirmware();
                return;
            }

            this.sendFirmwareQuery();
        }, FIRMWARE_DETECT_INTERVAL);
    }

    sendFirmwareQuery() {
        this.count++;
        this.connection.writeImmediate('$I\n');
    }

    stopFirmwareDetection() {
        clearInterval(this.timeout);
        this.timeout = null;
    }

    useDefaultFirmware() {
        // Stop before emitting: firmwareFound synchronously builds a controller
        // which sends its own $I, and we do not want to race it.
        this.stopFirmwareDetection();

        // The app always supplies one, but never emit an undefined type.
        const firmware = this.options.defaultFirmware || GRBL;
        log.warn(
            `No firmware identified after ${this.count} $I attempts; assuming ${firmware}`,
        );
        this.controllerType = firmware;
        this.emit('firmwareFound', firmware, this.options, this.callback);
    }

    close(err) {
        const { port } = this.options;

        // Assertion check
        if (!this.connection) {
            const err = `Serial port "${port}" is not available`;
            log.error(err);
            this.callback(err);
            return;
        }

        this.emit('serialport:close', {
            port: port,
            inuse: false,
        });

        // Emit a change event to all connected sockets
        if (this.engine.io) {
            this.engine.io.emit('serialport:change', {
                port: port,
                inuse: false,
            });
        }

        if (this.isClose()) {
            this.destroy();
            this.callback(err);
            return;
        }

        this.connection.close();
        this.destroy();
        this.callback(err);
    }

    addController = (controller) => {
        this.controller = controller;

        this.emit('serialport:open', {
            port: this.options.port,
            baudrate: this.options.baudrate,
            controllerType: this.controllerType,
            inuse: true,
        });
    };

    write(data, context = { source: WRITE_SOURCE_CLIENT }) {
        // Assertion check
        if (this.isClose()) {
            log.error(`Serial port "${this.options.port}" is not accessible`);
            return;
        }
        if (!context) {
            context = { source: WRITE_SOURCE_CLIENT };
        }
        this.connection.write(data, context);
        log.silly(`> ${data}`);
    }

    writeln(data, context = {}) {
        if (
            includes(GRBLHAL_REALTIME_COMMANDS, data) ||
            includes(GRBL_REALTIME_COMMANDS, data)
        ) {
            this.write(data, context);
        } else {
            this.write(data + '\n', context);
        }
    }

    writeImmediate(data) {
        this.connection.writeImmediate(data);
    }

    getSockets() {
        return this.sockets;
    }

    restoreListeners() {
        this.connection.addPortListeners();
    }

    setWriteFilter(writeFilter) {
        this.connection.setWriteFilter(writeFilter);
    }

    getConnectionObject() {
        return this.connection.port;
    }

    emitToSockets(eventName, ...args) {
        Object.keys(this.sockets).forEach((id) => {
            const socket = this.sockets[id];
            socket.emit(eventName, ...args);
        });
    }

    updateOptions(options) {
        this.options = {
            ...this.options,
            options
        };
    }

    refresh() {
        log.debug('connection refresh');
        this.emit('firmwareFound',
            this.controllerType,
            this.options,
            this.callback,
            true);
    }

    destroy() {
        this.stopFirmwareDetection();
        // Reset the attempt budget with the rest of the detection state, so a
        // reused Connection instance would start detection from scratch.
        this.count = 0;

        if (this.controller) {
            this.controller = null;
        }

        this.sockets = {};

        if (this.connection) {
            this.connection = null;
        }

        if (this.controllerType) {
            this.controllerType = null;
        }
    }

    isNetwork() {
        return this.options.network;
    }

    getFTPInfo() {
        return [this.options.port, this.options.ethernetPort];
    }
}

export default Connection;