(ns gym.core)

(def db
  {:equipment {:dumbells {:equipment :dumbells
                          :weights (vec (range 10 40 2))}
               :barbell {:equipment :barbell
                         :weights (vec (range 20 300 2.5))}
               :barbell2 {:equipment :barbell
                          :weights (vec (range 20 300 5))}}

   :exercises {:bench {:exercise :bench
                       :equipment :barbell}
               :squat {:exercise :squat
                       :equipment :barbell2}
               :press {:exercise :press
                       :equipment :barbell}
               :deadlift {:exercise :deadlift
                          :equipment :barbell2}}

   :ranges {:t1 {:range :t1
                 :reps (vec (range 3 6))}
            :t2 {:range :t2
                 :reps (vec (range 6 10))}
            :t3 {:range :t3
                 :reps (vec (range 8 12))}}

   :percentages {1 {:reps 1
                    :pc 100}
                 2 {:reps 2
                    :pc 95}
                 3 {:reps 3
                    :pc 92.5}
                 4 {:reps 4
                    :pc 90}
                 5 {:reps 5
                    :pc 87.5}
                 6 {:reps 6
                    :pc 85}
                 7 {:reps 7
                    :pc 82.5}
                 8 {:reps 8
                    :pc 80}
                 9 {:reps 9
                    :pc 77.5}
                 10 {:reps 10
                     :pc 75}
                 11 {:reps 11
                     :pc 75}
                 12 {:reps 12
                     :pc 70}
                 13 {:reps 13
                     :pc 68}
                 14 {:reps 14
                     :pc 66}
                 15 {:reps 15
                     :pc 65}}})

(defn normalise
  "Normalise the rep max"
  [opts]
  (let [{:keys [weight reps]} opts
        {:keys [pc]} (get-in db [:percentages reps])]
    (.divide (bigdec weight) (* (bigdec pc) 0.01M) 3 BigDecimal/ROUND_HALF_UP)))

(defn recommend
  "Return a few options to increase the rep max for an exercise, given the equipment"
  [opts]
  (let [{:keys [exercise range reps weight]} opts
        {:keys [equipment]} (get-in db [:exercises exercise])
        {:keys [weights]} (get-in db [:equipment equipment])
        rm (normalise {:weight weight :reps reps})]
    (->> (for [w weights
               r (get-in db [:ranges range :reps])
               :let [m (normalise {:reps r :weight w})
                     percent-increase (* (- (.divide m rm 3 BigDecimal/ROUND_HALF_UP) 1) 100M)]
               :when (< 0 percent-increase 10)]
           {:weight w
            :reps r
            :percent-increase (format "%.1f" percent-increase)})
         (sort-by :percent-increase))))

(recommend {:exercise :bench
            :range :t1
            :reps 5
            :weight 65})
; =>
({:weight 67.5, :reps 4, :percent-increase "1.0"}
 {:weight 70.0, :reps 3, :percent-increase "1.9"}
 {:weight 67.5, :reps 5, :percent-increase "3.8"}
 {:weight 70.0, :reps 4, :percent-increase "4.7"}
 {:weight 72.5, :reps 3, :percent-increase "5.5"}
 {:weight 70.0, :reps 5, :percent-increase "7.7"}
 {:weight 72.5, :reps 4, :percent-increase "8.4"}
 {:weight 75.0, :reps 3, :percent-increase "9.1"})