cljam.io.sam.util.flag

(ns cljam.io.sam.util.flag)

(def ^:private ^:const flags
  {:multiple         1 ; template having multiple segments in sequencing
   :properly-aligned 2 ; each segment properly aligned according to the aligner
   :unmapped         4 ; segment unmapped
   :next-unmapped    8 ; next segment in the template unmapped
   :reversed        16 ; SEQ begin reverse complemented
   :next-reversed   32 ; SEQ of the next segment in the template being reverse complemented
   :first           64 ; the first segment in the template
   :last           128 ; the last segment in the template
   :secondary      256 ; secondary alignment
   :filtered-out   512 ; not passing filters, such as platform/vendor quality controls
   :duplicated    1024 ; PCR or optical duplicate
   :supplementary 2048 ; supplementary alignment
   })

(def ^:private ^:const flag-keywords
  (vec (map vector (map key (sort-by val flags)) (range))))

(defn- long-bit-test
  [^long x ^long n]
  (. clojure.lang.Numbers testBit x n))

(defn decode
  [^long f]
  (into #{} (for [[k i] flag-keywords :when (long-bit-test f i)] k)))

(defn encode
  [flag-set]
  (reduce + (map flags flag-set)))

(defmacro encoded
  [flag-set-literal]
  (let [f (encode flag-set-literal)]
    f))

(defn primary?
  [^long f]
  (zero? (bit-and f 0x900)))

(defn multiple?
  [^long f]
  (long-bit-test f 0))

(defn properly-aligned?
  [^long f]
  (long-bit-test f 1))

(defn unmapped?
  [^long f]
  (long-bit-test f 2))

(defn both-unmapped?
  [^long f]
  (zero? (bit-xor (bit-and f 0xC) 0xC)))

(defn reversed?
  [^long f]
  (long-bit-test f 4))

(defn r1?
  [^long f]
  (long-bit-test f 6))

(defn r2?
  [^long f]
  (long-bit-test f 7))

(defn r1r2
  ^long
  [^long f]
  (-> f
      (bit-and 0xC0) ;; last-bit first-bit
      (unsigned-bit-shift-right 6)))

(defn secondary?
  [^long f]
  (long-bit-test f 8))