(ns auto-ap.utils)

(defn by
  ([f xs]
   (by f identity xs))
  ([f fv xs]
   (reduce
    #(assoc %1 (f %2) (fv %2))
    {}
    xs)))

(defn replace-if [f candidate existing]
  (reduce
   (fn [xs x]
     (if (f x candidate)
       (conj xs candidate)
       (conj xs x)))
   []
   existing))

(defn replace-by [xs f x]
  (let [found? (atom false)
        replaced (mapv
                  (fn [t]
                    (if (= (f t) (f x))
                      (do (reset! found? true)
                          x)
                      t))
                  xs)]
    (if @found?
      replaced
      (into [x] replaced))))

(defn dollars-0? [amt]
  (< -0.001 amt  0.001))

(defn dollars= [amt1 amt2]
  (dollars-0? (- amt1 amt2) ))

(defn deep-merge [v & vs]
  (letfn [(rec-merge [v1 v2]
            (if (and (map? v1) (map? v2))
              (merge-with deep-merge v1 v2)
              v2))]
    (if (some identity vs)
      (reduce #(rec-merge %1 %2) v vs)
      (last vs))))