#+fw.dump
 (eval-when (:compile-toplevel :load-toplevel :execute)
   (load "~/quicklisp/setup.lisp")
   (require :uiop))
 
 #+fw.dump
 (ql:quickload '(:net.didierverna.clon :bit-smasher
                 :ironclad :lparallel :serapeum))
 
 (defpackage :fwoar.bloomutil
   (:use :cl)
   (:export ))
 (in-package :fwoar.bloomutil)
 
 (defun byte-array-to-integer (arr)
   (loop for cur across arr
         for sum = cur then (+ (ash sum 8) cur)
         finally (return sum)))
 
 (defun file->idx (filter hash fn)
   (mod (byte-array-to-integer (ironclad:digest-file hash fn))
        (length filter)))
 
 (defun bloom-file (filter hashes fn)
   (loop for hash in hashes
         do (setf (aref filter (file->idx filter hash fn)) 1))
   filter)
 
 (defun parse-filter (filter)
   (bitsmash:hex->bits filter))
 
 (defun serialize (filter)
   (bitsmash:bits->hex filter))
 
 (defun has-file (filter hashes file)
   (loop with matches = 0
         for hash in hashes
         for count from 1
         do
            (when (= (elt filter (file->idx filter hash file))
                     1)
              (incf matches))
         finally (return (= matches count))))
 
 (defvar *synopsis*
   (net.didierverna.clon:defsynopsis (:postfix "FILTER FILES..." :make-default nil)
     (flag :short-name "h" :long-name "help")
     (flag :short-name "c" :long-name "check")
     (flag :long-name "coord")))
 
 (defun main ()
   (let* ((context (net.didierverna.clon:make-context :synopsis *synopsis*))
          (net.didierverna.clon:*context* context)
          (lparallel:*kernel* (lparallel:make-kernel (serapeum:count-cpus)))
          (hashes '(:md5 :sha256)))
     (cond ((net.didierverna.clon:getopt :context context
                                         :long-name "help")
            (net.didierverna.clon:help))
           ((net.didierverna.clon:getopt :context context
                                         :long-name "check")
            (destructuring-bind (filter file)
                (net.didierverna.clon:remainder :context context)
              (if (has-file (parse-filter filter)
                            hashes
                            file)
                  (princ "true")
                  (princ "false")))
            (terpri))
           ((net.didierverna.clon:getopt :context context
                                         :long-name "coord")
            (destructuring-bind (filter . files)
                (net.didierverna.clon:remainder :context context)
              (loop for file in files
                    do (format t "(~{~4,' d~^ ~} ~a)~%"
                               (loop for hash in hashes
                                     collect (file->idx filter hash file))
                               file))
              (terpri)))
           (t
            (destructuring-bind (filter . files)
                (net.didierverna.clon:remainder :context context)
              (let ((bits (parse-filter filter)))
                (format t "~v,1,0,'0@a"
                        (length filter)
                        (serialize
                         (lparallel:preduce 'bit-ior
                                            (lparallel:pmap 'list
                                                            (lambda (file)
                                                              (bloom-file (copy-seq bits)
                                                                          hashes
                                                                          file))
                                                            files)
                                            :initial-value (copy-seq bits))))))
            (terpri)))))
 
 (defun dump ()
   (setf net.didierverna.clon:*context* nil
         *features* (remove :fw.dump *features*))
   (net.didierverna.clon:dump "bloomutil" main))