/**
 * Filename          : encoder_vb_doc-E_rev-5.js
 * Latest commit     : 70b3fdc0
 * Protocol document : E
 *
 * Release History
 *
 * 2021-04-14 revision 0
 * - initial version
 *
 * 2021-03-05 revision 1
 * - Uses scientific notation for sensor data scale
 *
 * 2021-05-14 revision 2
 * - Made it compatible with v1 and v2 (merged in protocol v1)
 *
 * 2021-06-28 revision 3
 * - rename unconfirmed_repeat to number_of_unconfirmed_messages
 * - Added limitation to base configuration
 * - Update minimum number of number_of_unconfirmed_messages
 * - Add value range assertion to encode_device_config
 * - Fixed the parsing of unconfirmed_repeat to number_of_unconfirmed_messages
 *
 * 2022-07-12 revision 4
 * - Fixed encode_sci_6 by making sure the power is clipped to the available range
 *
 * 2022-07-25 revision 5
 * - Fixed encode_sci_6 to allow it to try to round the coefficient of the scientific number.
 *
 * YYYY-MM-DD revision X
 * -
 *
 */

if (typeof module !== 'undefined') {
  // Only needed for nodejs
  module.exports = {
    Encode: Encode,
    Encoder: Encoder,
    EncodeBaseConfig: EncodeBaseConfig, // used by generate_config_bin.py
    EncodeSensorConfig: EncodeSensorConfig, // used by generate_config_bin.py
    EncodeSensorDataConfig: EncodeSensorDataConfig, // used by generate_config_bin.py
    encode_header: encode_header,
    encode_events_mode: encode_events_mode,
    encode_base_config: encode_base_config,
    encode_vb_sensor_config: encode_vb_sensor_config,
    encode_vb_sensor_data_config_v1: encode_vb_sensor_data_config_v1,
    encode_vb_sensor_data_config_v2: encode_vb_sensor_data_config_v2,
    encode_calculation_trigger: encode_calculation_trigger,
    encode_fft_trigger_threshold: encode_fft_trigger_threshold,
    encode_fft_selection: encode_fft_selection,
    encode_frequency_range: encode_frequency_range,
    encode_base_config_switch: encode_base_config_switch,
    encode_device_type: encode_device_type,
    encode_uint32: encode_uint32,
    encode_int32: encode_int32,
    encode_uint16: encode_uint16,
    encode_int16: encode_int16,
    encode_uint8: encode_uint8,
    encode_int8: encode_int8,
    encode_sci_6: encode_sci_6,
    calc_crc: calc_crc,
  };
}

var mask_byte = 255;


function Encode(fPort, obj) { // Used for ChirpStack (aka LoRa Network Server)
  // Encode downlink messages sent as
  // object to an array or buffer of bytes.
  var bytes = [];

  var PROTOCOL_VERSION_1 = 1;
  var PROTOCOL_VERSION_2 = 2;

  var MSG_BASE_CONFIG = 5;
  var MSG_SENSOR_CONFIG = 6;
  var MSG_SENSOR_DATA_CONFIG = 7;

  switch (obj.header.protocol_version) {
    case PROTOCOL_VERSION_1:
    case PROTOCOL_VERSION_2:
      {
        switch (obj.header.message_type) {
          case "base_configuration": {
            encode_header(bytes, MSG_BASE_CONFIG, obj.header.protocol_version);
            encode_base_config(bytes, obj);
            encode_uint16(bytes, calc_crc(bytes.slice(1)));

            break;
          }
          case "sensor_configuration": {
            switch (obj.device_type) {
              case "vb":
                encode_header(bytes, MSG_SENSOR_CONFIG, obj.header.protocol_version);
                encode_vb_sensor_config(bytes, obj);
                encode_uint16(bytes, calc_crc(bytes.slice(1)));

                break;
              default:
                throw new Error("Invalid device type!");
            }
            break;
          }
          case "sensor_data_configuration": {
            switch (obj.device_type) {
              case "vb":
                encode_header(bytes, MSG_SENSOR_DATA_CONFIG, obj.header.protocol_version);
                switch (obj.header.protocol_version) {
                  case PROTOCOL_VERSION_1:
                    encode_vb_sensor_data_config_v1(bytes, obj);
                    break;
                  case PROTOCOL_VERSION_2:
                    encode_vb_sensor_data_config_v2(bytes, obj);
                    break;
                  default:
                    throw new Error("Protocol version is not supported!");
                }
                encode_uint16(bytes, calc_crc(bytes.slice(1)));

                break;
              default:
                throw new Error("Invalid device type!");
            }
            break;
          }
          default:
            throw new Error("Invalid message type!");
        }
        break;
      }
    default:
      throw new Error("Protocol version is not supported!");
  }

  return bytes;
}

function Encoder(obj, fPort) { // Used for The Things Network server
  return Encode(fPort, obj);
}

function encodeDownlink(input) {
  try {
    obj = Encode(input.fPort, input.data);
    return {
      fPort: 15,
      bytes: obj
    }
  }
  catch (e) {
    return {
      errors: [e.toString()]
    };
  }
}

/**
 * Base configuration encoder
 *
 * This function is only being used by config generatore, therefore only support the latest version
 */
function EncodeBaseConfig(obj) {
  var bytes = [];
  encode_base_config(bytes, obj);

  return bytes;
}

function encode_base_config(bytes, obj) {
  // The following parameters refers to the same configuration, only different naming on different
  // protocol version.
  // Copy the parameter to a local one
  var number_of_unconfirmed_messages = 0;
  if (typeof obj.number_of_unconfirmed_messages != "undefined") {
    number_of_unconfirmed_messages = obj.number_of_unconfirmed_messages;
  } else if (typeof obj.unconfirmed_repeat != "undefined") {
    number_of_unconfirmed_messages = obj.unconfirmed_repeat;
  } else {
    throw new Error("Missing number_of_unconfirmed_messages OR unconfirmed_repeat parameter");
  }

  if (typeof obj.bypass_sanity_check == "undefined" || obj.bypass_sanity_check == false) {
    if (number_of_unconfirmed_messages < 1 || number_of_unconfirmed_messages > 5) {
      throw new Error("number_of_unconfirmed_messages is outside of specification: " + obj.number_of_unconfirmed_messages);
    }
    if (obj.communication_max_retries < 1) {
      throw new Error("communication_max_retries is outside specification: " + obj.communication_max_retries);
    }
    if (obj.status_message_interval_seconds < 60 || obj.status_message_interval_seconds > 604800) {
      throw new Error("status_message_interval_seconds is outside specification: " + obj.status_message_interval_seconds);
    }
    if (obj.lora_failure_holdoff_count < 0 || obj.lora_failure_holdoff_count > 255) {
      throw new Error("lora_failure_holdoff_count is outside specification: " + obj.lora_failure_holdoff_count);
    }
    if (obj.lora_system_recover_count < 0 || obj.lora_system_recover_count > 255) {
      throw new Error("lora_system_recover_count is outside specification: " + obj.lora_system_recover_count);
    }
  }
  encode_base_config_switch(bytes, obj.switch_mask);
  encode_uint8(bytes, obj.communication_max_retries);             // Unit: -
  encode_uint8(bytes, number_of_unconfirmed_messages);            // Unit: -
  encode_uint8(bytes, obj.periodic_message_random_delay_seconds); // Unit: s
  encode_uint16(bytes, obj.status_message_interval_seconds / 60); // Unit: minutes
  encode_uint8(bytes, obj.status_message_confirmed_interval);     // Unit: -
  encode_uint8(bytes, obj.lora_failure_holdoff_count);            // Unit: -
  encode_uint8(bytes, obj.lora_system_recover_count);             // Unit: -
  encode_uint16(bytes, obj.lorawan_fsb_mask[0]);                  // Unit: -
  encode_uint16(bytes, obj.lorawan_fsb_mask[1]);                  // Unit: -
  encode_uint16(bytes, obj.lorawan_fsb_mask[2]);                  // Unit: -
  encode_uint16(bytes, obj.lorawan_fsb_mask[3]);                  // Unit: -
  encode_uint16(bytes, obj.lorawan_fsb_mask[4]);                  // Unit: -
}

/**
 * VB sensor encoder
 *
 * This function is only being used by config generatore, therefore only support the latest version
 */
function EncodeSensorConfig(obj) {
  var bytes = [];
  encode_vb_sensor_config(bytes, obj);

  return bytes;
}

/**
 * VB sensor data encoder
 *
 * This function is only being used by config generatore, therefore only support the latest version
 */
function EncodeSensorDataConfig(obj) {
  var bytes = [];
  encode_vb_sensor_data_config_v2(bytes, obj);

  return bytes;
}

function encode_vb_sensor_config(bytes, obj) {
  encode_device_type(bytes, obj.device_type);

  // Timing configs
  encode_uint16(bytes, obj.measurement_interval_seconds);     // Unit: s
  encode_uint16(bytes, obj.periodic_event_message_interval);  // Unit: -
  encode_frequency_range(bytes,
    obj.frequency_range.rms_velocity,
    obj.frequency_range.peak_acceleration);

  // Events configs
  var idx = 0;
  for (idx = 0; idx < 6; idx++) {                             // Unit: -
    encode_events_mode(bytes, obj.events[idx].mode);

    // mode values
    if (obj.events[idx].mode != "off") {
      encode_int16(bytes, obj.events[idx].mode_value / 0.01);
    } else {
      encode_int16(bytes, 0);
    }
  }

}

function encode_vb_sensor_data_config_v1(bytes, obj) {
  encode_device_type(bytes, obj.device_type);

  encode_calculation_trigger(bytes, obj.calculation_trigger);
  encode_uint16(bytes, obj.calculation_interval);

  encode_uint16(bytes, obj.fragment_message_interval);
  if (obj.threshold_window % 2) throw new Error("threshold_window must be multiple of 2")
  encode_uint8(bytes, obj.threshold_window / 2);

  for (idx = 0; idx < 5; idx++) {
    encode_fft_trigger_threshold(
      bytes,
      obj.trigger_thresholds[idx].unit,
      obj.trigger_thresholds[idx].frequency,
      obj.trigger_thresholds[idx].magnitude);
  }

  encode_fft_selection(bytes, obj.selection);

  encode_uint16(bytes, obj.frequency.span.velocity.start);
  encode_uint16(bytes, obj.frequency.span.velocity.stop);

  encode_uint16(bytes, obj.frequency.span.acceleration.start);
  encode_uint16(bytes, obj.frequency.span.acceleration.stop);

  encode_uint8(bytes, obj.frequency.resolution.velocity);
  encode_uint8(bytes, obj.frequency.resolution.acceleration);

  if (obj.scale.velocity % 4) throw new Error("scale.velocity must be multiple of 4")
  encode_uint8(bytes, obj.scale.velocity / 4);
  if (obj.scale.acceleration % 4) throw new Error("scale.acceleration must be multiple of 4")
  encode_uint8(bytes, obj.scale.acceleration / 4);

}

function encode_vb_sensor_data_config_v2(bytes, obj) {
  // byte[1]
  encode_device_type(bytes, obj.device_type);

  // byte[2]
  encode_calculation_trigger(bytes, obj.calculation_trigger);

  // byte[3..4]
  encode_uint16(bytes, obj.calculation_interval);

  // byte[5..6]
  encode_uint16(bytes, obj.fragment_message_interval);
  if (obj.threshold_window % 2) throw new Error("threshold_window must be multiple of 2")

  // byte[7]
  encode_uint8(bytes, obj.threshold_window / 2);

  // byte[8..27]
  for (idx = 0; idx < 5; idx++) {
    encode_fft_trigger_threshold(
      bytes,
      obj.trigger_thresholds[idx].unit,
      obj.trigger_thresholds[idx].frequency,
      obj.trigger_thresholds[idx].magnitude);
  }

  // byte[28]
  encode_fft_selection(bytes, obj.selection);

  // byte[29..30]
  encode_uint16(bytes, obj.frequency.span.velocity.start);
  // byte[31..32]
  encode_uint16(bytes, obj.frequency.span.velocity.stop);

  // byte[33..34]
  encode_uint16(bytes, obj.frequency.span.acceleration.start);
  // byte[35..36]
  encode_uint16(bytes, obj.frequency.span.acceleration.stop);

  // byte[37]
  encode_uint8(bytes, obj.frequency.resolution.velocity);
  // byte[38]
  encode_uint8(bytes, obj.frequency.resolution.acceleration);

  // byte[39]
  encode_sci_6(bytes, obj.scale.velocity);

  // byte[40]
  encode_sci_6(bytes, obj.scale.acceleration);
}

/* Helper Functions *********************************************************/

// helper function to encode the header
function encode_header(bytes, message_type_id, protocol_version) {
  var b = 0;
  b += (message_type_id & 0x0F);
  b += (protocol_version & 0x0F) << 4;

  bytes.push(b);
}

// helper function to encode device type
function encode_device_type(bytes, type) {
  switch (type) {
    case 'ts':
      encode_uint8(bytes, 1);
      break;
    case 'vs-qt':
      encode_uint8(bytes, 2);
      break;
    case 'vs-mt':
      encode_uint8(bytes, 3);
      break;
    case 'tt':
      encode_uint8(bytes, 4);
      break;
    case 'ld':
      encode_uint8(bytes, 5);
      break;
    case 'vb':
      encode_uint8(bytes, 6);
      break;
    default:
      encode_uint8(bytes, 0);
      break;
  }
}

// helper function to encode event.mode
function encode_events_mode(bytes, mode) {
  // Check mode
  switch (mode) {
    case 'rms_velocity_x':
      encode_uint8(bytes, 1);
      break;
    case 'peak_acceleration_x':
      encode_uint8(bytes, 2);
      break;
    case 'rms_velocity_y':
      encode_uint8(bytes, 3);
      break;
    case 'peak_acceleration_y':
      encode_uint8(bytes, 4);
      break;
    case 'rms_velocity_z':
      encode_uint8(bytes, 5);
      break;
    case 'peak_acceleration_z':
      encode_uint8(bytes, 6);
      break;
    case 'off':
    default:
      encode_uint8(bytes, 0);
      break;
  }
}

// helper function to encode fft measurement mode
function encode_calculation_trigger(bytes, calculation_trigger) {
  var calculation_trigger_bitmask = 0;

  if (!(
    typeof calculation_trigger.on_event == "boolean"
    && typeof calculation_trigger.on_threshold == "boolean"
    && typeof calculation_trigger.on_button_press == "boolean"
  )) {
    throw new Error('calculation_trigger must contain: on_event, on_threshold and on_button_press boolean fields');
  }

  calculation_trigger_bitmask |= calculation_trigger.on_event ? 0x01 : 0x00;
  calculation_trigger_bitmask |= calculation_trigger.on_threshold ? 0x02 : 0x00;
  calculation_trigger_bitmask |= calculation_trigger.on_button_press ? 0x04 : 0x00;

  encode_uint8(bytes, calculation_trigger_bitmask);
}

// helper function to encode fft trigger threshold
function encode_fft_trigger_threshold(bytes, unit, frequency, magnitude) {
  var trigger;
  switch (unit) {
    case "velocity":
      trigger = 0;
      break;

    case "acceleration":
      trigger = 1;
      break;

    default:
      throw new Error("Invalid unit");
  }
  trigger |= ((frequency & 0x7FFF) << 1);
  trigger |= (((magnitude * 100) & 0xFFFF) << 16);

  encode_uint32(bytes, trigger);
}


// helper function to encode fft trigger threshold
function encode_fft_selection(bytes, obj) {
  var selection = 0;
  var axis;
  switch (obj.axis) {
    case "x":
      axis = 0;
      break;
    case "y":
      axis = 1;
      break;
    case "z":
      axis = 2;
      break;
    default:
      throw new Error("selection.axis must one of 'x', 'y' or 'z'")
  }

  var resolution;
  switch (obj.resolution) {
    case "low_res":
      resolution = 0;
      break;
    case "high_res":
      resolution = 1;
      break;
    default:
      throw new Error("selection.resolution must one of 'low_res' or 'high_res'")
  }

  if (typeof obj.enable_hanning_window != "boolean") {
    throw new Error('selection.enable_hanning_window must be a boolean');
  }
  var enable_hanning_window = obj.enable_hanning_window ? 1 : 0;

  var selection = axis;
  selection |= (resolution << 2);
  selection |= (enable_hanning_window << 3);
  encode_uint8(bytes, selection);
}

// helper function to encode frequency range
function encode_frequency_range(bytes, velocity, acceleration) {
  var range = 0;

  switch (velocity) {
    case "range_1":
      range += 0;
      break;
    case "range_2":
      range += 1;
      break;
    default:
      throw new Error("Invalid velocity range!" + velocity)
  }

  switch (acceleration) {
    case "range_1":
      range += 0;
      break;
    case "range_2":
      range += 2;
      break;
    default:
      throw new Error("Invalid acceleration range!" + acceleration)
  }

  encode_uint8(bytes, range);
}

// helper function to encode the base configuration switch_mask
function encode_base_config_switch(bytes, bitmask) {
  var config_switch_mask = 0;
  if (bitmask.enable_confirmed_event_message) {
    config_switch_mask |= 1 << 0;
  }
  if (bitmask.enable_confirmed_data_message) {
    config_switch_mask |= 1 << 2;
  }
  if (bitmask.allow_deactivation) {
    config_switch_mask |= 1 << 3;
  }
  bytes.push(config_switch_mask & mask_byte);
}

// helper function to encode an uint32
function encode_uint32(bytes, value) {
  bytes.push(value & mask_byte);
  bytes.push((value >> 8) & mask_byte);
  bytes.push((value >> 16) & mask_byte);
  bytes.push((value >> 24) & mask_byte);
}

// helper function to encode an int32
function encode_int32(bytes, value) {
  encode_uint32(bytes, value);
}

// helper function to encode an uint16
function encode_uint16(bytes, value) {
  bytes.push(value & mask_byte);
  bytes.push((value >> 8) & mask_byte);
}

// helper function to encode an int16
function encode_int16(bytes, value) {
  encode_uint16(bytes, value);
}

// helper function to encode an uint8
function encode_uint8(bytes, value) {
  bytes.push(value & mask_byte);
}

// helper function to encode an int8
function encode_int8(bytes, value) {
  encode_uint8(bytes, value);
}

// helper function to encode 6 bit scientific notation
function encode_sci_6(bytes, scale) {
  // Get power component of scientific notation
  // Range: -2 .. 1
  power = Number(scale.toExponential().split('e')[1]);

  // Clip power value based on range
  if (power < -2)
    power = -2;
  if (power > 1)
    power = 1;

  // Calculate coefficient
  // Range: 1 .. 15
  coeff = Math.round(scale / Math.pow(10, power));
  coeff_err_0 = Math.abs(scale - (coeff * Math.pow(10, power)));

  // See if we can increase resolution by decreasing power
  if (coeff_err_0 != 0 && power != -2) {
    // Recalculate notation based on decreased power
    power_down = power - 1;
    coeff_down = scale / Math.pow(10, power_down);

    // Clip power value based on range
    // Range: 1 .. 15
    if (coeff_down < 1)
      coeff_down = 1;
    if (coeff_down > 15)
      coeff_down = 15;

    coeff_err_1 = Math.abs(scale - (coeff_down * Math.pow(10, power_down)));

    if (coeff_err_1 < coeff_err_0 && coeff_down >= 1 && coeff_down <= 15) {
      // Use the new notation if coefficient is within range
      power = power_down;
      coeff = coeff_down;
    }
  }

  // Final check
  if (coeff < 1 || coeff > 15 || power < -2 || power > 1) {
    throw new Error("Out of bound, power: " + power + ", coefficient: " + coeff);
  }

  power = ((power + 2) & 0x03) << 4;
  coeff = coeff & 0x0F;
  bytes.push(coeff | power);
}

// calc_crc inspired by https://github.com/SheetJS/js-crc32
function calc_crc(buf) {
  function signed_crc_table() {
    var c = 0, table = new Array(256);

    for (var n = 0; n != 256; ++n) {
      c = n;
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      c = ((c & 1) ? (-306674912 ^ (c >>> 1)) : (c >>> 1));
      table[n] = c;
    }

    return typeof Int32Array !== 'undefined' ? new Int32Array(table) :
      table;
  }
  var T = signed_crc_table();

  var C = -1, L = buf.length - 3;
  var i = 0;
  while (i < buf.length) C = (C >>> 8) ^ T[(C ^ buf[i++]) & 0xFF];
  return C & 0xFFFF;
}