'use strict';
  
  const INTERVAL_BEETWEN_SIGNAL_STRENGTH_MS = 60000;
  const DELIMITER_WAIT_FOR_OK = '
  OK\r
  ';

  const moment = require('moment');

  const SerialPort = require('serialport');
  const ParserReadline = require('@serialport/parser-readline');
  const ParserDelimiter = require('@serialport/parser-delimiter');
  
  const config = require('komodo-sdk/config');
  const logger = require('komodo-sdk/logger');

  const mutex = require('./mutex');

  const common = require('./common');

  const sms = require('./sms');

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

  const reportSender = require('./report-sender');

  const msisdn = require('./msisdn');

  const modemInfo = {

      manufacturer: null,
      model: null,

      imei: null,

      imsi: null,

      msisdn: null,

      cops: null,
      networkId: null,
      networkName: null,

      signalStrength: null,

      signalStrengthTs: null,
      signalStrengthTsReadable: null,

      config: config.modem,

  };

  const port = new SerialPort(config.modem.device, { baudRate: 115200 });
  
  const parserReadLine = new ParserReadline();
  const parserWaitForOK = new ParserDelimiter({ delimiter: DELIMITER_WAIT_FOR_OK });
  port.pipe(parserReadLine);
  
  function writeToPort(data) {
      return new Promise((resolve) => {
          port.write(data, (err, bytesWritten) => {
              if (err) logger.warn(`ERROR: ${err.toString()}`);
              logger.verbose(`* OUT: ${data}`);
              resolve(bytesWritten);
          });
      });
  }
  
  async function writeToPortAndWaitForOK(data) {

      await mutex.setLockWaitForOK();

      const result = await writeToPort(data);

      await mutex.setLockWaitForOK();
      mutex.releaseLockWaitForOK();

      return result;
  }
  
  async function readSMS(slot) {
      const parser = new ParserDelimiter({ delimiter: DELIMITER_WAIT_FOR_OK });
      parser.on('data', async (data) => {
          if (data) {

              reportSender.incomingSMS(sms.extract(data.toString().trim()));

          }

          mutex.releaseLockWaitForOK();

      });
  
      logger.info(`Reading SMS on slot ${slot}`);
      port.pipe(parser);
      await writeToPortAndWaitForOK(`AT+CMGR=${slot}\r`);
      port.unpipe(parser);
      logger.verbose(`Finished reading SMS on slot ${slot}`);
  
      logger.info(`Deleting message on slot ${slot}`);
      port.pipe(parserWaitForOK);
      await writeToPortAndWaitForOK(`AT+CMGD=${slot}\r`);
      port.unpipe(parserWaitForOK);
  
      logger.info('Message processing has completed');
  }
  
  function onIncomingSMS(data) {
      const value = common.extractValueFromReadLineData(data);
      if (!value) return;
  
      const chunks = value.split(',');
      if (!chunks && !chunks[1]) return;
  
      const slot = chunks[1];
  
      logger.info(`Incoming SMS on slot ${slot}`);
      readSMS(slot);
  }

  function onCOPS(data) {
      modemInfo.cops = common.extractValueFromReadLineData(data).trim();
      logger.info(`Connected Network: ${modemInfo.cops}`);
  
      if (!modemInfo.cops) return;
  
      [, , modemInfo.networkId] = modemInfo.cops.split(',');
  
      if (modemInfo.networkId) {
          modemInfo.networkName = dbCops[modemInfo.networkId];
      }
  }

  parserReadLine.on('data', (data) => {
      logger.verbose(`* IN: ${data}`);
      if (data) {
          if (data.indexOf('+CSQ: ') === 0) {

              const signalStrength = common.extractValueFromReadLineData(data).trim();
              if (signalStrength) {
                  modemInfo.signalStrength = signalStrength;
                  modemInfo.signalStrengthTs = new Date();
                  modemInfo.signalStrengthTsReadable = moment(modemInfo.signalStrengthTs).format('YYYY-MM-DD HH:mm:ss');
                  logger.info(`Signal strength: ${modemInfo.signalStrength}`);
              }

          } else if (data.indexOf('+CMTI: ') === 0) {
              onIncomingSMS(data);

          } else if (data.indexOf('+COPS: ') === 0) {
              onCOPS(data);

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

      mutex.releaseLockWaitForOK();

  });

  function simpleCommand(cmd, callback) {
      const parser = new ParserDelimiter({ delimiter: DELIMITER_WAIT_FOR_OK });
      parser.on('data', (data) => {
          port.unpipe(parser);
          mutex.releaseLockWaitForOK();
  
          if (data) {
              callback(null, data.toString().trim());
          }
      });
  
      port.pipe(parser);
      writeToPortAndWaitForOK(cmd);
  }

  function readManufacturer() {
      return new Promise((resolve) => {
          simpleCommand('AT+CGMI\r', (err, result) => {
              modemInfo.manufacturer = result;
              logger.info(`Manufacturer: ${result}`);
              resolve(result);
          });
      });
  }
  
  function readModel() {
      return new Promise((resolve) => {
          simpleCommand('AT+CGMM\r', (err, result) => {
              modemInfo.model = result;
              logger.info(`Model: ${result}`);
              resolve(result);
          });
      });
  }
  
  function readIMEI() {
      return new Promise((resolve) => {
          simpleCommand('AT+CGSN\r', (err, result) => {
              modemInfo.imei = result;
              logger.info(`IMEI: ${result}`);
              resolve(result);
          });
      });
  }
  
  function readIMSI() {
      return new Promise((resolve) => {
          simpleCommand('AT+CIMI\r', (err, result) => {
              modemInfo.imsi = result;
              logger.info(`IMSI: ${result}`);

  
              if (result) {
                  modemInfo.msisdn = msisdn[result];
                  if (modemInfo.msisdn) {
                      logger.info(`MSISDN: ${modemInfo.msisdn}`);
                  }
              }

              resolve(result);
          });
      });
  }

  
  async function querySignalStrength() {
      port.pipe(parserWaitForOK);
      await writeToPortAndWaitForOK('AT+CSQ\r');
      port.unpipe(parserWaitForOK);
  }
  
  async function registerSignalStrengthBackgroundQuery() {
      logger.info('Registering background signal strength query');
  
      setInterval(() => {
          querySignalStrength();
      }, INTERVAL_BEETWEN_SIGNAL_STRENGTH_MS);
  }
  
  async function sendSMS(destination, msg) {

      if (typeof destination !== 'string' || typeof msg !== 'string' || !destination.trim() || !msg.trim()) return;

      await mutex.setLockWaitForCommand();

      logger.info('Sending message', { destination, msg });
  
      const correctedDestination = `+${destination}`.replace(/^0/, '62').replace(/^\++/, '+');
  
      port.pipe(parserWaitForOK);
      await writeToPortAndWaitForOK('AT+CMGF=1\r');
      await writeToPortAndWaitForOK(`AT+CMGS="${correctedDestination}"
  ${msg}${Buffer.from([0x1A])}`);
      port.unpipe(parserWaitForOK);
  
      logger.info('Message has been sent');

      mutex.releaseLockWaitForCommand();

  }
  
  function init() {
      port.on('open', async () => {
          port.pipe(parserWaitForOK);
  
          logger.info('Modem opened');
          await writeToPortAndWaitForOK('AT\r');
  
          logger.info('Initializing modem to factory set');
          await writeToPortAndWaitForOK('AT&F\r');
  
          logger.info('Disabling echo');
          await writeToPortAndWaitForOK('ATE0\r');

          await writeToPortAndWaitForOK('AT+COPS?\r');

          logger.info('Querying signal strength');
          await writeToPortAndWaitForOK('AT+CSQ\r');

          await readManufacturer();
          await readModel();
          await readIMEI();

          await readIMSI();

          if (!config.disable_delete_inbox_on_startup) {
              logger.info('Deleting existing messages');
              await writeToPortAndWaitForOK('AT+CMGD=0,4\r');
          }

          port.unpipe(parserWaitForOK);
  
          registerSignalStrengthBackgroundQuery();
          logger.verbose('Init completed');
      });
  }
  
  init();

  exports.modemInfo = modemInfo;

  exports.sendSMS = sendSMS;