const PARSER_READLINE_DELIMITER = '\r
  ';

  const PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = /
  (?:OK|ERROR)\r
  /;

  const moment = require('moment');

  const nodePdu = require('node-pdu');

  // const pdu = require('pdu');

  const ParserReadline = require('@serialport/parser-readline');

  const ParserRegex = require('@serialport/parser-regex');

  const logger = require('komodo-sdk/logger');

  const dbCops = require('./db-cops');

  const modemInfo = require('./modem-info');

  let port;
  
  exports.setPort = function setPort(val) {
      logger.info('SERIALPORT-PARSERS: setting port');
      port = val;
  };
  
  exports.getPort = function getPort() {
      return port;
  };

  let ussdCallback = null;
  function setUssdCallback(cb) {
      ussdCallback = cb;
  }
  exports.setUssdCallback = setUssdCallback;
  
  function isAlphaNumeric(str) {
      const len = str.length;
      // eslint-disable-next-line no-plusplus
      for (let i = 0; i < len; i++) {
          const code = str.charCodeAt(i);
          if (!(code > 47 && code < 58) // numeric (0-9)
              && !(code > 64 && code < 91) // upper alpha (A-Z)
              && !(code > 96 && code < 123)) { // lower alpha (a-z)
              return false;
          }
      }
      return true;
  }
  
  function parsePdu(_data) {
      const data = _data && _data.toString().trim().toUpperCase();

      if (!data) return null;

      if (!isAlphaNumeric(data)) return null;

  
      try {

          const result = nodePdu.parse(data);

          return result;
      } catch (e) {
          return null;
      }
  }

  function onCSQ(data) {
      const val = data.toString().trim().match(/\+CSQ:\s*(.*)/);

      if (!val || !val[1]) return null;

      const [, signalStrength] = val;

      logger.info('Signal quality extracted', { signalQuality: val[1] });

  
      modemInfo.signalStrength = signalStrength;
      modemInfo.signalStrengthTs = new Date();
      modemInfo.signalStrengthTsReadable = moment(modemInfo.signalStrengthTs).format('YYYY-MM-DD HH:mm:ss');
  
      return signalStrength;

  }

  function onPduDeliver(data, parsedData) {

      const from = parsedData.getAddress && parsedData.getAddress().getPhone
          ? parsedData.getAddress().getPhone() : null;
  
      const msg = parsedData.getData && parsedData.getData().getData
          ? parsedData.getData().getData() : null;

      const ts = new Date(parsedData.getScts().getIsoString());
  
      logger.verbose('PDU processed', { ts, from, msg });

      return { from, msg };
  }

  function onCOPS(data) {

      const val = data.toString().trim().match(/\+COPS:\s*(.*)/);
      if (!val || !val[1]) return null;
  
      const cops = val[1];

  
      if (!cops) return null;
      const [mode, format, networkId] = cops.split(',');
      const networkName = networkId ? dbCops[networkId] || networkId : null;

      logger.info('COPS extracted', {

          cops, mode, format, networkId, networkName,
      });

      modemInfo.cops = cops;

      modemInfo.networkId = networkId || null;
      modemInfo.networkName = networkName || null;

      return {
          cops, mode, format, networkId, networkName,
      };
  }

  function isResultCodeIs(data, resultCode) {
      if (!data) return false;
      const cleanedData = (data.toString() || '').trim();
      if (!cleanedData) return false;
  
      if (resultCode.indexOf('+') !== 0) {
          // eslint-disable-next-line no-param-reassign
          resultCode = `+${resultCode}`;
      }
  
      if (resultCode.search(/:$/) < 0) {
          // eslint-disable-next-line no-param-reassign
          resultCode += ':';
      }
  
      return cleanedData.indexOf(resultCode) === 0;
  }
  
  const parserReadline = new ParserReadline({ delimiter: PARSER_READLINE_DELIMITER });
  parserReadline.on('data', (data) => {

      modemInfo.lastReadTs = new Date();

      logger.verbose('INCOMING', { data: `${data.toString()}${PARSER_READLINE_DELIMITER}`, parser: 'parserReadLine' });

  
      if (!data) return;

  
      const pduParsed = parsePdu(data);

      if (pduParsed && pduParsed.constructor.name !== 'Deliver') {

          const pduType = pduParsed.getType();
          logger.warn('WARN-9DA32C41: Unknown PDU message type name. PLEASE REPORT IT TO DEVELOPER AT TEKTRANS', { typeName: pduParsed.constructor.name, pduType, data: data.toString().trim() });

      }

      if (pduParsed && pduParsed.constructor.name === 'Deliver' && pduParsed.getData().getSize()) {

          const pduType = pduParsed.getType();
          logger.verbose('Got a PDU SMS-DELIVER', { pduType });

          onPduDeliver(data, pduParsed);

      } else if (isResultCodeIs(data, 'CSQ')) {

          logger.verbose('Got a signal quality report', { data: data.toString() });

          onCSQ(data);

      } else if (isResultCodeIs(data, 'COPS:')) {
          logger.verbose('Got a COPS report', { data: data.toString() });

          onCOPS(data);

      } else if (isResultCodeIs(data, 'CMT')) {
          logger.verbose('Got a new message report', { data: data.toString() });
      } else if (isResultCodeIs(data, 'CMTI')) {
          logger.verbose('Got a new message notification report', { data: data.toString() });

      } else if (isResultCodeIs(data, 'CUSD')) {
          logger.verbose('Got a USSD command response', { data: data.toString() });
          if (ussdCallback && typeof ussdCallback === 'function') {
              logger.verbose('Calling USSD callback');
              ussdCallback(data.toString());
          } else {
              logger.verbose('Skip unwanted USSD response');
          }

      }
  });

  const parserWaitForOkOrError = new ParserRegex({ regex: PARSER_WAIT_FOR_OK_OR_ERROR_REGEX });
  parserWaitForOkOrError.on('data', (data) => {

      logger.verbose('INCOMING', { data: data.toString(), parser: 'parserWaitForOkOrError' });

  });

  exports.PARSER_READLINE_DELIMITER = PARSER_READLINE_DELIMITER;
  exports.PARSER_WAIT_FOR_OK_OR_ERROR_REGEX = PARSER_WAIT_FOR_OK_OR_ERROR_REGEX;

  exports.parserReadline = parserReadline;

  exports.parserWaitForOkOrError = parserWaitForOkOrError;