function EE() {
  if (!(this instanceof EE))
    throw new Error("EE should be called with new operator");
  this.listeners = {};
}

EE.prototype.on = function _on(event, callback, ctx) {
  return on(this, event, callback, ctx, false);
};

EE.prototype.once = function _once(event, callback, ctx) {
  return on(this, event, callback, ctx, true);
};

EE.prototype.off = function _off(event, callback) {
  return off(this, event, callback);
};

EE.prototype.emit = function _emit() {
  return emit.apply(null, [this].concat(Array.prototype.slice.call(arguments)));
};

function on(self, event, callback, ctx, once) {
  let listener = self.listeners[event] || (self.listeners[event] = []);

  listener.push({
    ctx,
    fn: callback,
    once: !!once
  });
  return self;
}

function off(self, event, callback) {
  let listener = self.listeners[event];
  if (!listener) {
    return false;
  }
  let flag;
  for (let i = 0; i < listener.length; ) {
    const item = listener[i];
    if (item.fn === callback) {
      flag = flag || true;
      listener.splice(i, 1);
    } else {
      i++;
    }
  }
  if (listener.length === 0) {
    delete self.listeners[event];
  }
  return flag;
}

function emit(self, event) {
  if (!self.listeners[event]) {
    return false;
  }
  const listener = self.listeners[event].slice();
  const payload = Array.prototype.slice.call(arguments, 2);

  for (let i = 0; i < listener.length; i++) {
    const item = listener[i];
    const fn = item.fn;
    if (item.once && self.listeners[event].indexOf(item) > -1) {
      self.listeners[event].splice(self.listeners[event].indexOf(item), 1);
    }
    if (item.ctx !== undefined) {
      fn.apply(item.ctx, payload);
    } else {
      fn.apply(void 0, payload);
    }
  }
  if (self.listeners[event].length === 0) {
    delete self.listeners[event];
  }
  return true;
}