import eventBus from "../utils/broadcast-channel-pubsub";

export default (name, getObjKey) => {
  let cache = {};

  // update data cached on another node
  eventBus.on("cache-key-set-" + name, ({ key, value }, isLocal) =>
    !isLocal ? set(key, value, false) : null
  );
  eventBus.on("cache-all-set" + name, ({ data }, isLocal) =>
    !isLocal ? setAll(data, false) : null
  );
  eventBus.on("cache-merge-" + name, ({ data }, isLocal) =>
    !isLocal ? merge(data, false) : null
  );
  eventBus.on("cache-key-forget-" + name, ({ key }, isLocal) =>
    !isLocal ? forget(key, false) : null
  );
  eventBus.on("cache-flush-" + name, (_, isLocal) =>
    !isLocal ? flush(false) : null
  );

  const set = (key, value, emitEvent = true) => {
    cache[key] = value;

    if (emitEvent) eventBus.publish("cache-key-set-" + name, { key, value });

    return value;
  };

  const setAll = (data, emitEvent = true) => {
    cache = data;

    if (emitEvent) eventBus.publish("cache-all-set-" + name, { data });

    return cache;
  };
  const merge = (data, emitEvent = true) => {
    cache = { ...cache, ...data };

    if (emitEvent) eventBus.publish("cache-merge-" + name, { data });

    return cache;
  };

  const get = async (key, fetchFunc) => {
    if (cache.hasOwnProperty(key)) return cache[key];

    const value = await fetchFunc();

    return set(key, value);
  };

  const getByFilter = async (fetchFunc, filterFunc) => {
    if (filterFunc) {
      const obj = Object.values(cache).find(filterFunc);
      if (obj) return obj;
    }

    const value = await fetchFunc();
    if (value === undefined) return value;

    const key = getObjKey(value);

    return set(key, value);
  };

  const getAll = () => cache;

  const has = (key) => cache[key] !== undefined;

  const getKeys = () => Object.keys(cache);

  const forget = (key, emitEvent = true) => {
    delete cache[key];

    if (emitEvent) eventBus.publish("cache-key-forget-" + name, { key });

    return cache;
  };

  const forgetByFilter = (filterFunc, emitEvent = true) => {
    if (!filterFunc) return false;

    Object.keys(cache)
      .filter((key) => filterFunc(cache[key]))
      .forEach((key) => {
        delete cache[key];

        if (emitEvent) eventBus.publish("cache-key-forget-" + name, { key });
      });

    return true;
  };

  const flush = (emitEvent = true) => {
    cache = {};

    if (emitEvent) eventBus.publish("cache-flush-" + name, {});

    return cache;
  };

  return {
    has,
    get,
    getByFilter,
    getAll,
    set,
    setAll,
    merge,
    getKeys,
    forget,
    forgetByFilter,
    flush,
  };
};