HORIZON PROJECT

/*global Blob,File*/

/**

 * Module requirements

 */

var isArray = require('isarray');

var isBuf = require('./is-buffer');

var toString = Object.prototype.toString;

var withNativeBlob = typeof global.Blob === 'function' || toString.call(global.Blob) === '[object BlobConstructor]';

var withNativeFile = typeof global.File === 'function' || toString.call(global.File) === '[object FileConstructor]';

/**

 * Replaces every Buffer | ArrayBuffer in packet with a numbered placeholder.

 * Anything with blobs or files should be fed through removeBlobs before coming

 * here.

 *

 * @param {Object} packet - socket.io event packet

 * @return {Object} with deconstructed packet and list of buffers

 * @api public

 */

exports.deconstructPacket = function(packet) {

  var buffers = [];

  var packetData = packet.data;

  var pack = packet;

  pack.data = _deconstructPacket(packetData, buffers);

  pack.attachments = buffers.length; // number of binary 'attachments'

  return {packet: pack, buffers: buffers};

};

function _deconstructPacket(data, buffers) {

  if (!data) return data;

  if (isBuf(data)) {

    var placeholder = { _placeholder: true, num: buffers.length };

    buffers.push(data);

    return placeholder;

  } else if (isArray(data)) {

    var newData = new Array(data.length);

    for (var i = 0; i < data.length; i++) {

      newData[i] = _deconstructPacket(data[i], buffers);

    }

    return newData;

  } else if (typeof data === 'object' && !(data instanceof Date)) {

    var newData = {};

    for (var key in data) {

      newData[key] = _deconstructPacket(data[key], buffers);

    }

    return newData;

  }

  return data;

}

/**

 * Reconstructs a binary packet from its placeholder packet and buffers

 *

 * @param {Object} packet - event packet with placeholders

 * @param {Array} buffers - binary buffers to put in placeholder positions

 * @return {Object} reconstructed packet

 * @api public

 */

exports.reconstructPacket = function(packet, buffers) {

  packet.data = _reconstructPacket(packet.data, buffers);

  packet.attachments = undefined; // no longer useful

  return packet;

};

function _reconstructPacket(data, buffers) {

  if (!data) return data;

  if (data && data._placeholder) {

    return buffers[data.num]; // appropriate buffer (should be natural order anyway)

  } else if (isArray(data)) {

    for (var i = 0; i < data.length; i++) {

      data[i] = _reconstructPacket(data[i], buffers);

    }

  } else if (typeof data === 'object') {

    for (var key in data) {

      data[key] = _reconstructPacket(data[key], buffers);

    }

  }

  return data;

}

/**

 * Asynchronously removes Blobs or Files from data via

 * FileReader's readAsArrayBuffer method. Used before encoding

 * data as msgpack. Calls callback with the blobless data.

 *

 * @param {Object} data

 * @param {Function} callback

 * @api private

 */

exports.removeBlobs = function(data, callback) {

  function _removeBlobs(obj, curKey, containingObject) {

    if (!obj) return obj;

    // convert any blob

    if ((withNativeBlob && obj instanceof Blob) ||

        (withNativeFile && obj instanceof File)) {

      pendingBlobs++;

      // async filereader

      var fileReader = new FileReader();

      fileReader.onload = function() { // this.result == arraybuffer

        if (containingObject) {

          containingObject[curKey] = this.result;

        }

        else {

          bloblessData = this.result;

        }

        // if nothing pending its callback time

        if(! --pendingBlobs) {

          callback(bloblessData);

        }

      };

      fileReader.readAsArrayBuffer(obj); // blob -> arraybuffer

    } else if (isArray(obj)) { // handle array

      for (var i = 0; i < obj.length; i++) {

        _removeBlobs(obj[i], i, obj);

      }

    } else if (typeof obj === 'object' && !isBuf(obj)) { // and object

      for (var key in obj) {

        _removeBlobs(obj[key], key, obj);

      }

    }

  }

  var pendingBlobs = 0;

  var bloblessData = data;

  _removeBlobs(bloblessData);

  if (!pendingBlobs) {

    callback(bloblessData);

  }

};