#!/usr/bin/env python3
"""Build a DCSO-format bloom filter from files of hex digest lines.

Standalone, zero dependencies — everything needed to reproduce the
.bloom files in this dataset from the digest lists / harvest scripts
alongside it.

Format (github.com/DCSO/bloom, the format CIRCL hashlookup uses):
48-byte header of little-endian u64s (version=1, n capacity, p as f64
bits, k, m, N inserted) followed by ceil(m/64) u64 words of bit array.
Keys are hex digest STRINGS: UPPERCASE for sha1 (the hashlookup
convention), lowercase for everything else.

Membership hashing (Go semantics preserved from the reference
implementation): h = FNV-1 64(key) mod M with M = 2^64 - 87, then k
rounds of h = (h * g mod 2^64) mod M with g = 18446744073709550147,
setting bit h mod m each round.

Usage:
  dcso_bloom_build.py OUT.bloom SCHEME HEXFILE... [--fpp 0.0001]
  (SCHEME in md5|sha1|sha256 — sets required line length + key case)
"""
import math
import struct
import sys

MOD = 2**64 - 87
G = 18446744073709550147
MASK = 2**64 - 1

HEX_LEN = {"md5": 32, "sha1": 40, "sha256": 64}


def fnv1_64(data: bytes) -> int:
    h = 0xCBF29CE484222325
    for b in data:
        h = (h * 0x100000001B3) & MASK
        h ^= b
    return h


def main() -> None:
    args = [a for a in sys.argv[1:] if not a.startswith("--")]
    fpp = 0.0001
    for a in sys.argv[1:]:
        if a.startswith("--fpp"):
            fpp = float(a.split("=", 1)[1] if "=" in a else sys.argv[sys.argv.index(a) + 1])
    if len(args) < 3 or args[1] not in HEX_LEN:
        sys.exit(__doc__)
    out, scheme, inputs = args[0], args[1], args[2:]
    hex_len = HEX_LEN[scheme]
    upper = scheme == "sha1"

    n = 0
    for path in inputs:
        with open(path) as f:
            for line in f:
                t = line.strip()
                if not t:
                    continue
                if len(t) != hex_len or not all(c in "0123456789abcdefABCDEF" for c in t):
                    sys.exit(f"{path}: line {t!r} is not a {hex_len}-char hex digest")
                n += 1
    if n == 0:
        sys.exit("no digests found in input")

    ln2 = math.log(2)
    m = math.ceil(n * -math.log(fpp) / (ln2 * ln2))
    k = max(1, round((m / n) * ln2))
    words = bytearray((m + 63) // 64 * 8)
    print(f"building {out}: {n} keys, p={fpp}, {len(words) >> 20} MiB", file=sys.stderr)

    done = 0
    for path in inputs:
        with open(path) as f:
            for line in f:
                t = line.strip()
                if not t:
                    continue
                key = (t.upper() if upper else t.lower()).encode()
                h = fnv1_64(key) % MOD
                for _ in range(k):
                    h = (h * G & MASK) % MOD
                    bit = h % m
                    words[bit >> 6 << 3 | (bit >> 3) & 7] |= 1 << (bit & 7)
                done += 1
                if done % 50_000_000 == 0:
                    print(f"  … {done}/{n}", file=sys.stderr)

    with open(out, "wb") as f:
        f.write(struct.pack("<6Q", 1, n, struct.unpack("<Q", struct.pack("<d", fpp))[0], k, m, n))
        f.write(words)
    print(f"wrote {out}", file=sys.stderr)


if __name__ == "__main__":
    main()