"use strict";

// https://github.com/jamesallardice/patchwork.js
var patch = function () {
  /*jshint evil: true */
  'use strict'; // Get a reference to the global object

  var global = new Function('return this;')(); // Get the own ("static") properties of the Function constructor

  var fnProps = Object.getOwnPropertyNames(Function);
  return function (original, originalRef, patches) {
    var ref = global[originalRef] = original,
        // Maintain a reference to the original constructor as a new property on the global object
    args = [],
        newRef,
        // This will be the new patched constructor
    i;
    patches.called = patches.called || originalRef; // If we are not patching static calls just pass them through to the original function

    for (i = 0; i < original.length; i++) {
      // Match the arity of the original constructor
      args[i] = 'a' + i; // Give the arguments a name (native constructors don't care, but user-defined ones will break otherwise)
    }

    if (patches.constructed) {
      // This string is evaluated to create the patched constructor body in the case that we are patching newed calls
      args.push('\'use strict\'; return (!!this ? ' + patches.constructed + ' : ' + patches.called + ').apply(null, arguments);');
    } else {
      // This string is evaluated to create the patched constructor body in the case that we are only patching static calls
      args.push('\'use strict\'; return (!!this ? new (Function.prototype.bind.apply(' + originalRef + ', [{}].concat([].slice.call(arguments))))() : ' + patches.called + '.apply(null, arguments));');
    }

    newRef = new (Function.prototype.bind.apply(Function, [{}].concat(args)))(); // Create a new function to wrap the patched constructor

    newRef.prototype = original.prototype; // Keep a reference to the original prototype to ensure instances of the patch appear as instances of the original

    newRef.prototype.constructor = newRef; // Ensure the constructor of patched instances is the patched constructor

    Object.getOwnPropertyNames(ref).forEach(function (property) {
      // Add any "static" properties of the original constructor to the patched one
      if (fnProps.indexOf(property) < 0) {
        // Don't include static properties of Function since the patched constructor will already have them
        newRef[property] = ref[property];
      }
    });
    return newRef; // Return the patched constructor
  };
}();