function deep_copy(from) { return json.decode(json.encode(from)); }

function valdiff(from,to)
{
  if (typeof from !== typeof to) return from;
  if (typeof from === 'function') return undefined;
  if (typeof from === 'undefined') return undefined;

  if (typeof from === 'number') {
      return to;
      
    return undefined;
  }

  if (typeof from === 'object')
    return ediff(from,to);

  if (from !== to) return to;

  return undefined;
}

function ediff(from,to)
{
  var ret = {};
  
  if (!to)
//    return ediff(from, {});
    return deep_copy(from);
  
  Object.entries(from).forEach(function([key,v]) {
    if (typeof v === 'function') return;
    if (typeof v === 'undefined') return;


    if (Array.isArray(v)) {
      if (!Array.isArray(to[key]) || v.length !== to[key].length) {
        var r = ediff(v,[]);
        if (r) ret[key] = Object.values(r);
        return;
      }

      var diff = ediff(from[key], to[key]);
      if (diff && !Object.empty(diff))
	      ret[key] = Object.values(ediff(v,[]));

      return;
    }

    if (typeof v === 'object' && v !== null) {
      var diff = ediff(v, to[key]);
      if (diff && !Object.empty(diff))
	     ret[key] = diff;	
      return;
    }

    if (typeof v === 'number' || v === null) {
      if (!isFinite(v)) v = null; // Squash infinity to null
      if (v !== to[key])
	ret[key] = v;
      return;
    }

    if (!to || v !== to[key])
      ret[key] = v;
  });
  if (Object.empty(ret)) return undefined;
  
  return ret;
}

ediff.doc = "Given a from and to object, returns an object that, if applied to from, will make it the same as to. Does not include deletion; it is only additive. If one element in an array is different, the entire array is copied. Squashes infinite numbers to null for use in JSON.";

function samediff(from, to)
{
  var same = [];
  if (!to) return same;
  if (typeof to !== 'object') {
    console.warn("'To' must be an object. Got " + to);
    return same;
  }
  Object.keys(from).forEach(function(k) {
    if (Object.isObject(from[k])) {
      samediff(from[k], to[k]);
      return;
    }

//    if (Array.isArray(from[k])) {
//      var d = valdiff(from[k], to[k]);
//      if (!d)
//    }

    var d = valdiff(from[k], to[k]);
    if (!d)
      delete from[k];
  });

  return same;
}

samediff.doc = "Given a from and to object, returns an array of keys that are the same on from as on to.";

return {
  deep_copy,
  ediff,
  samediff,
}