const hashers = (value, times) => {
  const hash = crypto.createHash('sha1').update(value).digest();
  const h1 = hash.readUInt32BE(8);
  const h2 = hash.readUInt32BE(12);
  const hashes = [];
  //only two hash functions are necessary to effectively implement a Bloom filter without 
  //any loss in the asymptotic false positive probability
  for (let i = 1; i <= times; i++) {
    hashes.push(h1 + h2 * i);
  }

  return hashes;
};

class BloomFilter {
  constructor({ cache, size = 1000000, errorRate = 0.005 }) {
    if (cache) {
      const [mark, m, k, e, bits] = cache;

      this._m = m;
      this._k = k;
      this._e = e;

      this._bits = new Bits(0, bits);
    } else {
      this._m = Math.round((-1 * size * Math.log(errorRate)) / LN2_SQUARE);
      if (this._m % BYTE_LEN) {
        this._m += (BYTE_LEN - (this._m % BYTE_LEN));
      }

      this._k = Math.max(1, Math.round(this._m / size * Math.LN2));
      this._e = errorRate;

      this._bits = new Bits();
    }
  }

  add(value) {
    if (isInteger(value)) {
      this._bits.set(value);
    } else {
      hashers(value, this._k).forEach(_ => this._bits.set(_ % this._m));
    }

    return this;
  }

  has(value) {
    if (isInteger(value)) {
      return this._bits.get(value);
    }
    return hashers(value, this._k).every(_ => this._bits.get(_ % this._m));
  }
}
module.exports = BloomFilter;