// Copyright 2015 The Vanadium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

module.exports = {
  fromNativeValue: fromNativeValue,
  fromWireValue: fromWireValue,
  registerFromNativeValue: registerFromNativeValue,
  registerFromWireValue: registerFromWireValue,
  hasNativeType: hasNativeType,
  isNative: isNative,
  lookupNativeToType: lookupNativeToType
};

require('./es6-shim');

// A map from vdl type string to a function that produces
// a wire type from the vdl value.
var nativeToWire = {};

// A map from native constructor to vdl type string.
// Used to determine the type of a native value.
var nativeToType = new Map();

// A map from vdl type string to a function that produces
// a native type from the vdl value.
var wireToNative = {};

/**
 * Registers a converter that converts from wire type to native type.
 * @private
 * @param {Value} t The type to convert from
 * @param {function} f A function that takes in a wire type representation
 * and returns the native type for it.
 */
function registerFromWireValue(t, f) {
  wireToNative[t.toString()] = f;
}

/**
 * Registers a converter that converts from native type to wire type.
 * @private
 * @param {function} constructor The constructor for the native object.
 * @param {function} f A function that takes in a native object and returns
 * the wire type representation of it.
 * @param {Type} type The wiretype fo the native value.
 */
function registerFromNativeValue(constructor, f, t) {
  nativeToWire[t.toString()] = f;
  nativeToType.set(constructor, t);
}

/**
 * Converts v from native type to the wire type format.
 * @private
 * @param {function} v The value to convert
 * @returns {object} The wiretype respresentation of the object.  If
 * no conversion happened, v is returned.
 */
function fromNativeValue(t, v) {
  var transform = nativeToWire[t.toString()];
  if (transform) {
    return transform(v);
  }
  return v;
}

function lookupNativeToType(v) {
  var result = null;
  nativeToType.forEach(function(wire, native) {
    if (result === null && v instanceof native) {
      result = wire;
    }
  });
  return result;
}

/**
 * Converts v from wire type to native type.
 * @private
 * @param {Value} t The type of v
 * @param {function} v The value to convert
 * @returns {object} The native object that is equivalent to v.  If
 * no conversion happened, v is returned.
 */
function fromWireValue(t, v) {
  try {
    var transform = wireToNative[t.toString()];
    if (transform) {
      return transform(v);
    }
    return v;
  } catch (e) {
    throw e;
  }
}

/**
 * Returns whether this Type has a native converter registered
 * @private
 * @param {Value} t The type
 * @returns {boolean} True iff there is native converter for this type.
 */
function hasNativeType(t) {
  return !!wireToNative[t.toString()];
}

/**
 * Returns whether this value has a wiretype converter registered
 * @private
 * @param {*} v The object to check.
 * @returns {boolean} True iff there is wiretype converter for this
 * object.
 */
function isNative(v) {
  if (v === undefined || v === null) {
    return false;
  }
  return !!lookupNativeToType(v);
}