export function wrap(func: Function, superFunc: Function) {
  if (!hasSuper(func)) {
    return func;
  }
  // ensure an unwrapped super that calls _super is wrapped with a terminal _super
  if (!IS_WRAPPED_FUNCTION_SET.has(superFunc) && hasSuper(superFunc)) {
    return _wrap(func, _wrap(superFunc, ROOT));
  }
  return _wrap(func, superFunc);
}

function inspectValue(value: any | null | undefined, depth: number, seen?: WeakSet<object>) {
  let valueIsArray = false;
  switch (typeof value) {
    case 'undefined':
      return 'undefined';
    case 'object':
      if (value === null) return 'null';
      if (isArray(value)) {
        valueIsArray = true;
        break;
      }
      // is toString Object.prototype.toString or undefined then traverse
      if (value.toString === objectToString || value.toString === undefined) {
        break;
      }
      // custom toString
      return value.toString();
    case 'function':
      return value.toString === functionToString
        ? value.name
          ? `[Function:${value.name}]`
          : `[Function]`
        : value.toString();
    case 'string':
      return stringify(value);
    case 'symbol':
    case 'boolean':
    case 'number':
    default:
      return value.toString();
  }
  if (seen === undefined) {
    seen = new WeakSet();
  } else {
    if (seen.has(value)) return `[Circular]`;
  }
  seen.add(value);

  return valueIsArray
    ? inspectArray(value, depth + 1, seen)
    : inspectObject(value, depth + 1, seen);
}

function _wrap(func: Function, superFunc: Function): Function {
  function superWrapper(this: { _super?: Function }) {
    let orig = this._super;
    this._super = superFunc;
    let ret = func.apply(this, arguments);
    this._super = orig;
    return ret;
  }

  IS_WRAPPED_FUNCTION_SET.add(superWrapper);
  setObservers(superWrapper, getObservers(func));
  setListeners(superWrapper, getListeners(func));

  return superWrapper;
}

export function isProxy(value: any | undefined | null): value is object {
  if (isObject(value)) {
    return PROXIES.has(value);
  }
  return false;
}

export function setProxy(object: object): void {
  if (isObject(object)) {
    PROXIES.add(object);
  }
}

export function isProxy(object: any | undefined | null) {
  if (isObject(object)) {
    return PROXIES.has(object);
  }
  return false;
}