VFence: Keep Your Pets and Kids Within Virtual Fence

/* eslint-disable no-console */

//const pb = require('pretty-bytes');

const initialize = (tempBufferLength, logFunction) => {
    if (typeof tempBufferLength !== 'number' || Number.isNaN(tempBufferLength) === true) {
      throw Error('@initialize : expecting "tempBufferLength" to be a number.');
    }
    if (tempBufferLength < 1) {
      throw Error('@initialize : expecting "tempBufferLength" to be greater than zero.');
    }
    if (logFunction !== undefined) {
      if (typeof logFunction !== 'function') {
        throw Error('@initialize : expecting "logFunction" to be a function.');
      }
      logFunction(`@initialize : setting buffer limit to ${pb(tempBufferLength)}`);
    }
    const dictionary = {};
    let dictionaryEnabled = false;
    let dictionaryOffset = -33;
    /**
     * Why -33:
     * - This allows us to use the negative (-32 to -1) and positive fixint range (0 to 127)
     * - So instead of encoding the whole key string, we only encode a single byte
     * - That's (32 + 128) = 160 of your first entries being encoded in a single damn byte
     */
    const register = (...args) => {
      if (dictionaryEnabled === false) dictionaryEnabled = true;
      for (let i = 0, l = args.length; i < l; i += 1) {
        dictionaryOffset += 1;
        dictionary[dictionaryOffset] = args[i];
        dictionary[args[i]] = dictionaryOffset;
      }
    };
    const tempEncodeBuffer = Buffer.allocUnsafe(tempBufferLength).fill(0);
    let tempEncodeBufferOffset = -1;
    const internalEncode = (value) => {
      let length = 0;
      switch (typeof value) {
        case 'string':
          length = Buffer.byteLength(value);
          if (length < 32) { // < 32, fixstr
            length = 0;
            for (let i = 0, c = 0, l = value.length; i < l; i += 1) {
              c = value.charCodeAt(i);
              if (c < 128) {
                length += 1;
              } else if (c < 1280) {
                length += 2;
              } else if (c < 55296 || c >= 57344) {
                length += 3;
              } else {
                i += 1;
                length += 4;
              }
            }
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length | 160;
            for (let i = 0, c = 0, l = value.length; i < l; i += 1) {
              c = value.charCodeAt(i);
              if (c < 128) {
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = c;
              } else if (c < 1280) {
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 192 | (c >> 6);
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 128 | (c & 63);
              } else if (c < 55296 || c >= 57344) {
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 224 | (c >> 12);
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 128 | (c >> 6) & 63;
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 128 | (c & 63);
              } else {
                i += 1;
                c = 65536 + (((c & 1023) << 10) | (value.charCodeAt(i) & 1023));
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 240 | (c >> 18);
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 128 | (c >> 12) & 63;
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 128 | (c >> 6) & 63;
                tempEncodeBuffer[tempEncodeBufferOffset += 1] = 128 | (c & 63);
              }
            }
          } else if (length < 256) { // str8
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = 217;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
            tempEncodeBuffer.write(value, tempEncodeBufferOffset += 1, length, 'utf8');
            tempEncodeBufferOffset += length - 1;
          } else if (length < 65536) { // str16
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = 218;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
            tempEncodeBuffer.write(value, tempEncodeBufferOffset += 1, length, 'utf8');
            tempEncodeBufferOffset += length - 1;
          } else if (length < 4294967296) { // str32
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = 219;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 24;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 16;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
            tempEncodeBuffer.write(value, tempEncodeBufferOffset += 1, length, 'utf8');
            tempEncodeBufferOffset += length - 1;
          } else {
            throw Error('@internalEncode : Max supported string length (4294967296) exceeded, encoding failure.');
          }
          break;
        case 'number':
          if (Number.isFinite(value) === false) {
            if (Number.isNaN(value) === true) { // NaN, fixext 1, type = 0, data = 1
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 212;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 0;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 1;
              break;
            }
            if (value === Infinity) { // +Infinity, fixext 1, type = 0, data = 2
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 212;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 0;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 2;
              break;
            }
            if (value === -Infinity) { // -Infinity, fixext 1, type = 0, data = 3
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 212;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 0;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 3;
              break;
            }
          }
          if (Math.floor(value) !== value) {
            if (Math.fround(value) === value) {
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 202;
              tempEncodeBuffer.writeFloatBE(value, tempEncodeBufferOffset += 1);
              tempEncodeBufferOffset += 3;
              break;
            } else {
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 203;
              tempEncodeBuffer.writeDoubleBE(value, tempEncodeBufferOffset += 1);
              tempEncodeBufferOffset += 7;
              break;
            }
          }
          if (value >= 0) {
            if (value < 128) { // positive fixint
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            if (value < 256) { // uint 8
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 204;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            if (value < 65536) {  // uint 16
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 205;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            if (value < 4294967296) { // uint 32
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 206;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 24;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 16;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            // uint 64
            let hi = (value / Math.pow(2, 32)) >> 0, lo = value >>> 0;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = 207;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi >> 24;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi >> 16;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi >> 8;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo >> 24;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo >> 16;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo >> 8;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo;
          } else {
            if (value >= -32) { // negative fixint
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            if (value >= -128) { // int 8
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 208;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            if (value >= -12800) { // int 16
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 209;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            if (value >= -128000000) { // int 32
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 210;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 24;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 16;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = value;
              break;
            }
            // int 64
            let hi = Math.floor(value / Math.pow(2, 32)), lo = value >>> 0;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = 211;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi >> 24;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi >> 16;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi >> 8;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = hi;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo >> 24;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo >> 16;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo >> 8;
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = lo;
          }
          break;
        case 'object':
          if (value === null) { // null
            tempEncodeBuffer[tempEncodeBufferOffset += 1] = 192;
            break;
          }
          if (Array.isArray(value) === true) {
            length = value.length;
            if (length < 16) { // fixarray
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length | 144;
            } else if (length < 65536) { // array 16
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 220;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
            } else if (length < 4294967296) { // array 32
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 221;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 24;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 16;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
            } else {
              throw new Error('@internalEncode : Array too large');
            }
            for (let i = 0; i < length; i += 1) {
              internalEncode(value[i]);
            }
            break;
          }
          if (value instanceof ArrayBuffer) { // arraybuffer to buffer
            value = Buffer.from(value);
          }
          if (
            value instanceof Buffer === false &&
            (
              value instanceof Int8Array
              || value instanceof Int16Array
              || value instanceof Int32Array
              || value instanceof Uint8Array
              || value instanceof Uint8ClampedArray
              || value instanceof Uint16Array
              || value instanceof Uint32Array
              || value instanceof Float32Array
              || value instanceof Float64Array
            )
          ) {
            let temp = Buffer.from(value.buffer);
            if (value.byteLength !== value.buffer.byteLength) {
              temp = temp.slice(value.byteOffset, value.byteOffset + value.byteLength)
            }
            value = temp;
          }
          if (value instanceof Buffer) { // typedarrays and buffer
            length = value.length;
            if (length < 256) { // bin8
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 196;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
              if (length > 32) {
                value.copy(tempEncodeBuffer, tempEncodeBufferOffset += 1, 0, length);
                tempEncodeBufferOffset += length - 1;
              } else {
                for (let i = 0; i < length; i++) {
                  tempEncodeBuffer[tempEncodeBufferOffset += 1] = value[i];
                }
              }
            } else if (length < 65536) { // bin16
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 197;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
              value.copy(tempEncodeBuffer, tempEncodeBufferOffset += 1, 0, length);
              tempEncodeBufferOffset += length - 1;
            } else if (length < 4294967296) { // bin32
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 198;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 24;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 16;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
              value.copy(tempEncodeBuffer, tempEncodeBufferOffset += 1, 0, length);
              tempEncodeBufferOffset += length - 1;
            } else {
              throw Error('@internalEncode : Max supported buffer length (4294967296) exceeded, encoding failure.');
            }
            break;
          } else { // plain javascript object
            let keys = Object.keys(value);
            length = keys.length;
            if (length < 16) { // fixmap
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length | 128;
            } else if (length < 65536) { // map16
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 222;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
            } else if (length < 4294967296) { // map32
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 223;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 24;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 16;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length >> 8;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = length;
            } else {
              throw new Error('@internalEncode : Object too large');
            }
            if (dictionaryEnabled === true) {
              for (let i = 0; i < length; i += 1) {
                internalEncode(dictionary[keys[i]] || keys[i]);
                internalEncode(value[keys[i]]);
              }
            } else {
              for (let i = 0; i < length; i += 1) {
                internalEncode(keys[i]);
                internalEncode(value[keys[i]]);
              }
            }
          }
          break;
        default:
          switch (value) {
            case true:  // true
              tempEncodeBuffer[tempEncodeBufferOffset += 1] =  195;
              break;
            case false: // false
              tempEncodeBuffer[tempEncodeBufferOffset += 1] =  194;
              break;
            case undefined: // undefined, fixext 1, type = 0, data = 0
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 212;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 0;
              tempEncodeBuffer[tempEncodeBufferOffset += 1] = 0;
              break;
            default:
              throw Error('@internalEncode : Error encoding value.');
          }
      }
    };
    const encode = (value) => {
      tempEncodeBufferOffset = -1;
      internalEncode(value);
      const encoded = Buffer.allocUnsafe(tempEncodeBufferOffset + 1).fill(0);
      tempEncodeBuffer.copy(encoded, 0, 0, tempEncodeBufferOffset + 1);
      return encoded;
    };
    let tempDecodeBuffer = undefined;
    let tempDecodeBufferOffset = 0;
    const internalDecode = () => {
      let value, length;
      if (tempDecodeBuffer[tempDecodeBufferOffset] < 192) {
        if (tempDecodeBuffer[tempDecodeBufferOffset] < 128) { // positive fixint
          value = tempDecodeBuffer[tempDecodeBufferOffset];
          tempDecodeBufferOffset += 1;
          return value;
        } else if (tempDecodeBuffer[tempDecodeBufferOffset] < 144) { // fixmap
          length = tempDecodeBuffer[tempDecodeBufferOffset] & 31;
          value = {};
          tempDecodeBufferOffset += 1;
          if (dictionaryEnabled === true) {
            for (let i = 0, key; i < length; i++) {
              key = internalDecode();
              value[dictionary[key] || key] = internalDecode();
            }
          } else {
            for (let i = 0; i < length; i++) {
              value[internalDecode()] = internalDecode();
            }
          }
          return value;
        } else if (tempDecodeBuffer[tempDecodeBufferOffset] < 160) { // fixarray
          length = tempDecodeBuffer[tempDecodeBufferOffset] & 15;
          tempDecodeBufferOffset += 1;
          value = new Array(length);
          for (let i = 0; i < length; i += 1) {
            value[i] = internalDecode();
          }
          return value;
        } else { // fixstr
          length = tempDecodeBuffer[tempDecodeBufferOffset] & 31;
          tempDecodeBufferOffset += 1;
          value = tempDecodeBuffer.toString('utf8', tempDecodeBufferOffset, tempDecodeBufferOffset + length);
          tempDecodeBufferOffset += length;
          return value;
        }
      } else if (tempDecodeBuffer[tempDecodeBufferOffset] > 223) { // negative fixint
        value = (255 - tempDecodeBuffer[tempDecodeBufferOffset] + 1) * -1;
        tempDecodeBufferOffset += 1;
        return value;
      } else {
        switch (tempDecodeBuffer[tempDecodeBufferOffset]) {
          case 202: // float 32
            value = tempDecodeBuffer.readFloatBE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 4;
            return value;
          case 203: // float 64
            value = tempDecodeBuffer.readDoubleBE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 8;
            return value;
          case 204: // uint 8
            value = tempDecodeBuffer.readUInt8(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 1;
            return value;
          case 205: // uint 16
            value = tempDecodeBuffer.readUInt16BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 2;
            return value;
          case 206: // uint 32
            value = tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 4;
            return value;
          case 207: // uint 64
            value = ( tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 1) * Math.pow(2, 32) ) + tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 4);
            tempDecodeBufferOffset += 4;
            return value;
          case 208: // int 8
            value = tempDecodeBuffer.readInt8(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 1;
            return value;
          case 209: // int 16
            value = tempDecodeBuffer.readInt16BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 2;
            return value;
          case 210: // int 32
            value = tempDecodeBuffer.readInt32BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 4;
            return value;
          case 211: // int 64
            value = ( tempDecodeBuffer.readInt32BE(tempDecodeBufferOffset += 1) * Math.pow(2, 32) ) + tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 4);
            tempDecodeBufferOffset += 4;
            return value;
  
          case 217: // str 8
            length = tempDecodeBuffer.readUInt8(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 1;
            value = tempDecodeBuffer.toString('utf8', tempDecodeBufferOffset, tempDecodeBufferOffset + length);
            tempDecodeBufferOffset += length;
            return value;
          case 218: // str 16
            length = tempDecodeBuffer.readUInt16BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 2;
            value = tempDecodeBuffer.toString('utf8', tempDecodeBufferOffset, tempDecodeBufferOffset + length);
            tempDecodeBufferOffset += length;
            return value;
          case 219: // str 32
            length = tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 4;
            value = tempDecodeBuffer.toString('utf8', tempDecodeBufferOffset, tempDecodeBufferOffset + length);
            tempDecodeBufferOffset += length;
            return value;
  
          case 212: // fixext 1
            switch ( tempDecodeBuffer.readInt8(tempDecodeBufferOffset += 1) ) { // fixext 1, type = ?
              case 0:
                switch ( tempDecodeBuffer.readInt8(tempDecodeBufferOffset += 1) ) { // fixext 1, type = 0, data = ?
                  case 0: // undefined, fixext 1, type = 0, data = 0
                    value = undefined;
                    tempDecodeBufferOffset += 1;
                    return value;
                  case 1: // NaN, fixext 1, type = 0, data = 1
                    value = NaN;
                    tempDecodeBufferOffset += 1;
                    return value;
                  case 2: // +Infinity, fixext 1, type = 0, data = 2
                    value = Infinity;
                    tempDecodeBufferOffset += 1;
                    return value;
                  case 3: // -Infinity, fixext 1, type = 0, data = 3
                    value = -Infinity;
                    tempDecodeBufferOffset += 1;
                    return value;
                }
              break;
            }
            break;
          case 192: // nil
            value = null;
            tempDecodeBufferOffset += 1;
            return value;
          case 194: // false
            value = false;
            tempDecodeBufferOffset += 1;
            return value;
          case 195: // true
            value = true;
            tempDecodeBufferOffset += 1;
            return value;
          case 220: // array16
            length = tempDecodeBuffer.readUInt16BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 2;
            value = new Array(length);
            for (let i = 0; i < length; i += 1) {
              value[i] = internalDecode();
            }
            return value;
          case 221: // array32
            length = tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 4;
            value = new Array(length);
            for (let i = 0; i < length; i += 1) {
              value[i] = internalDecode();
            }
            return value;
          case 222: // map16
            length = tempDecodeBuffer.readUInt16BE(tempDecodeBufferOffset += 1);
            value = {};
            tempDecodeBufferOffset += 2;
            if (dictionaryEnabled === true) {
              for (let i = 0, key; i < length; i++) {
                key = internalDecode();
                value[dictionary[key] || key] = internalDecode();
              }
            } else {
              for (let i = 0; i < length; i++) {
                value[internalDecode()] = internalDecode();
              }
            }
            return value;
          case 223: // map32
            length = tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 1);
            value = {};
            tempDecodeBufferOffset += 4;
            if (dictionaryEnabled === true) {
              for (let i = 0, key; i < length; i++) {
                key = internalDecode();
                value[dictionary[key] || key] = internalDecode();
              }
            } else {
              for (let i = 0; i < length; i++) {
                value[internalDecode()] = internalDecode();
              }
            }
            return value;
          case 196: // bin8
            length = tempDecodeBuffer.readUInt8(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 1;
            value = tempDecodeBuffer.slice(tempDecodeBufferOffset, tempDecodeBufferOffset + length);
            tempDecodeBufferOffset += length;
            return value;
          case 197: // bin16
            length = tempDecodeBuffer.readUInt16BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 2;
            value = tempDecodeBuffer.slice(tempDecodeBufferOffset, tempDecodeBufferOffset + length);
            tempDecodeBufferOffset += length;
            return value;
          case 198: // bin32
            length = tempDecodeBuffer.readUInt32BE(tempDecodeBufferOffset += 1);
            tempDecodeBufferOffset += 4;
            value = tempDecodeBuffer.slice(tempDecodeBufferOffset, tempDecodeBufferOffset + length);
            tempDecodeBufferOffset += length;
            return value;
        }
        throw Error('@internalDecode : Error decoding value.');
      }
    };
    const decode = (buffer) => {
      tempDecodeBuffer = buffer;
      tempDecodeBufferOffset = 0;
      const result = internalDecode();
      tempDecodeBuffer = undefined;
      return result;
    };
    return { encode, decode, register };
  };
  
  module.exports = { initialize };

/* Amplify Params - DO NOT EDIT
	AUTH_BIKEMATE9550CE989550CE98_USERPOOLID
	ENV
	REGION
Amplify Params - DO NOT EDIT */

const MessagePack = require('./msgpack');
const { encode, decode } = MessagePack.initialize(2 ** 22); // 4MB
const GeoJsonGeometriesLookup = require('geojson-geometries-lookup');
const AWS = require('aws-sdk');
AWS.config.update({ region: 'us-east-1' });
const iotdata = new AWS.IotData({ endpoint: 'xxxxxx-ats.iot.us-east-1.amazonaws.com' });
const dynamodb = new AWS.DynamoDB.DocumentClient();
const cognito = new AWS.CognitoIdentityServiceProvider({ apiVersion: '2016-04-18' });
const pinpoint = new AWS.Pinpoint();
const pinpointsmsvoice = new AWS.PinpointSMSVoice({apiVersion: '2018-09-05'});
const PINPOINT_PROJECT_ID = "xxxxxxx";
const OriginationPhoneNumber= '+xxxxxxxx';
const { v4: uuidv4 } = require('uuid');
const TEXT_COUNTER= 5;
const CALL_COUNTER=10;


const geojson = {
    type: 'FeatureCollection',
    features: [{
        type: 'Feature',
        geometry: {
            type: 'Polygon',
            coordinates: [
                [
                    [-72.21818402409554, 41.37813188439215],
                    [-72.21457913517952, 41.378558560875874],
                    [-72.21184328198433, 41.37603066313924],
                    [-72.21275523304939, 41.373164520113654],
                    [-72.21721842885017, 41.37315646897221],
                    [-72.21862390637398, 41.3751209179386],
                    [-72.21818402409554, 41.37813188439215]
                ]
            ]
        },
        properties: { prop2: 'value2' }
    }]
};

exports.handler = async (event) => {
    let payload = event.payload;
    let uuid = event.id;
    let deviceMap = {};
    let device;
    let username;
    let insideFence = true;
    let devicegeojson;
    let nt = 0; //last notification time
    console.log(payload);
    console.log(`UUID = ${uuid}`);

    const response = {
        statusCode: 200,
        body: JSON.stringify('message received from helium'),
    };

    let payloadJson = decode(Buffer.from(payload, 'base64'))
    payloadJson.l = parseFloat(payloadJson.l);
    payloadJson.t = parseFloat(payloadJson.t);
    payloadJson.s = parseFloat(payloadJson.s);

    console.log(payloadJson);
    if(payloadJson.l ==0 ){
        console.log("Ignore as location is empty");
        return response
    }

    //get device from dynamoDB
    if (uuid in deviceMap) {
        console.log("#### reading from cache ");
        device = deviceMap[uuid];
        username = deviceMap[uuid].username;
    } else {
        console.log("#### cache miss  ", uuid);
        
        var params = {
            TableName: "bikemate_device",
            KeyConditionExpression: "#uuid = :uuid",
            IndexName: "uuid-index",
            ExpressionAttributeNames: {
                "#uuid": "uuid"
            },
            ExpressionAttributeValues: {
                ":uuid": uuid
            }
        };

        let devices = await dynamodb.query(params).promise()
        if (devices.Items.length > 0) {
            username = devices.Items[0].username;
            deviceMap[uuid] = devices.Items[0];
            device = deviceMap[uuid];

        }
    }


    await iotdata.publish({
        topic: `helium/devices/${uuid}/up`,
        payload: JSON.stringify({ payload: payload, uuid: uuid }),
        qos: 0
    }).promise();

    const user = await cognito.adminGetUser({
        UserPoolId: process.env.AUTH_BIKEMATE9550CE989550CE98_USERPOOLID,
        Username: username,
    }).promise()


    if(device.geojson){
        devicegeojson = JSON.parse(device.geojson);
    }

    if (devicegeojson && devicegeojson.features[0].geometry.coordinates[0].length>2) {
        const glookup = new GeoJsonGeometriesLookup(devicegeojson);

        const point1 = { type: "Point", coordinates: [payloadJson.t, payloadJson.l] };

        insideFence = glookup.hasContainers(point1, { ignorePoints: true, ignoreLines: true });

        console.log("location inside geofencing? ", insideFence);

        if (!insideFence) {


            

            console.log(user.UserAttributes)

            let deviceTokenAttr = user.UserAttributes.filter(m=> m['Name']==='custom:devicetoken');

            if ( device.nt === undefined || device.nt ===0){
                //first time device is out of range
                console.log("1. device nt", device.nt);
                nt = new Date().getTime();
                if(deviceTokenAttr.length>0){
                    let tokens = deviceTokenAttr[0].Value.split(",");
                    
                    sendPushNotification(`${device.dName} is out of fence`,tokens);
    
                }
            }else{
                let datediff = new Date().getTime() - device.nt;
                nt = device.nt;
                console.log("2. device nt", device.nt, datediff);
                //device already out of range. Send after 1 hour
                if(deviceTokenAttr.length>0 &&   datediff >= 60*60*1000){
                    let tokens = deviceTokenAttr[0].Value.split(",");
                    nt = new Date().getTime();
                    console.log("sending still push and setting new value for nt");
                    sendPushNotification(`${device.dName} is still out of fence`,tokens);
    
                }else{
                    console.log("not yet time for next push");
                }
            }
            
            var params = {
            topic: `helium/devices/${uuid}/down`,
            payload: JSON.stringify({payload_raw:"AQ=="}),
            qos: 0
            };

            await iotdata.publish(params).promise();

        }else{
            console.log("device is inside fence, so reset nt timer");
            nt = 0;
        }

        

    }else{
        console.log(`GEO fence not setup for ${uuid}`);
    }

    //check if there is any  fall detected. 
    if( payloadJson.f >0){

        let phoneArr = user.UserAttributes.filter(m=> m['Name']==='custom:phone');
        let deviceTokenAttr = user.UserAttributes.filter(m=> m['Name']==='custom:devicetoken');

        if(phoneArr.length>0){
            let phone = phoneArr[0].Value;
            let shouldTextArr = user.UserAttributes.filter(m=> m['Name']==='custom:isTextEnabled');
            let shoulCallArr = user.UserAttributes.filter(m=> m['Name']==='custom:isCallEnabled');
            //send text/sms 
            if( payloadJson.f == TEXT_COUNTER && shouldTextArr.length > 0 && shouldTextArr[0].Value ==='Y'){
                await triggerText({'PhoneNumber': phone ,'Message':`BikeMate: Attention! ${device.dName} has fallen.`});
                if(deviceTokenAttr.length>0){
                    let tokens = deviceTokenAttr[0].Value.split(",");
                    
                    sendPushNotification(`Attention! ${device.dName} has fallen`,tokens);
    
                }
                

            }
            if( payloadJson.f == CALL_COUNTER && shoulCallArr.length > 0 && shoulCallArr[0].Value ==='Y'){
                await triggerCall({'PhoneNumber': phone ,'Message': `<speak>This is an emergency call from <emphasis>Bike Mate</emphasis><break strength='weak'/>${device.dName} has detected a fall and your attention is needed!<amazon:effect phonation='soft'>Thank you for listening.</amazon:effect></speak>` })
            }
        }

        
    }

    //update  device location 
    
    await dynamodb.update({
        TableName: "bikemate_device",
        Key:{
        "uuid": uuid,
        "username":username
        },
        UpdateExpression: "set lat = :lat, lon = :lon, infence = :infence, ts= :ts, speed= :speed, nt= :nt",
    
        ExpressionAttributeValues: {
            ":lat": payloadJson.l,
            ":lon": payloadJson.t,
            ":speed": parseInt(payloadJson.s),
            ":infence": insideFence,
            ":ts": new Date().getTime(),
            ":nt": nt

        },
        ReturnValues:"UPDATED_NEW"
    }).promise()
    
    payloadJson.f = insideFence;

    await dynamodb.put({
        TableName : 'bikemate_device_data',
        Item: {
            id: uuidv4(),
            uuid: uuid,
            data: payloadJson,
            ttl: new Date().getTime()/1000 + 3600*2 //live 24 hours
        }
    }).promise();


    
    return response;
};


function sendPushNotification(message, tokens) {

    tokens.forEach(async (token) => {

        var messageRequest = {
            'Addresses': {
                [token]: {
                    'ChannelType': 'APNS_SANDBOX'
                }
            },
            'MessageConfiguration': {
                'APNSMessage': {
                    'Body': message,
                    'SilentPush': false,
                    'Data': { 'silent': 'false' }
                }
            }
        };


        var params = {
            "ApplicationId": PINPOINT_PROJECT_ID,
            "MessageRequest": messageRequest
        };

        // Try to send the message.
        await pinpoint.sendMessages(params).promise();

    })


}

function triggerCall (eventData) {
    return new Promise (resolve => {
        var parms = {
            Content: {
                SSMLMessage: {
                    LanguageCode : 'en-US',
                    Text : eventData.Message,
                    VoiceId: 'Joanna'
                }
            },
            OriginationPhoneNumber: OriginationPhoneNumber,
            DestinationPhoneNumber: eventData.PhoneNumber
        };

        console.log ("Call Parameters: ", JSON.stringify(parms));
        pinpointsmsvoice.sendVoiceMessage (parms, function (err, data) {
            if (err) {
                console.log ("Error : "+ err.message);
                resolve(eventData.PhoneNumber + " " + err.message);
            }
            else {
                console.log (data);
                resolve(eventData.PhoneNumber + " OK");
            }
        });
    });
}

function triggerText (eventData) {
    return new Promise (resolve => {
        var params = {
            ApplicationId: PINPOINT_PROJECT_ID,
            MessageRequest: {
              Addresses: {
                [eventData.PhoneNumber]: {
                  ChannelType: 'SMS'
                }
              },
              MessageConfiguration: {
                SMSMessage: {
                  Body: eventData.Message,
                  MessageType: 'TRANSACTIONAL',
                  OriginationNumber: OriginationPhoneNumber
                }
              }
            }
          };

        pinpoint.sendMessages(params, function (err, data) {
            if (err) {
                console.log ("Error : "+ err.message);
                resolve(eventData.PhoneNumber + " " + err.message);
            }
            else {
                console.log (data);
                resolve(eventData.PhoneNumber + " OK");
            }
        });
    });
}