(local {: contains} (require :lib.table))

(fn get-candidates [all-mills next-move]
  "a list of mills that contain next-move"
  (icollect [_ mill (ipairs all-mills)]
    (if (contains mill next-move) mill)))

(fn any [t]
  "take a list of booleans, returns true if any of them are true"
  (accumulate [acc false
               i x (ipairs t)]
               (or acc x)))

(fn move-mills [moves-list]
  (icollect [_ moves (ipairs moves-list)]
    (let [player (. moves 1)]
      (accumulate [acc true
                   _ m (ipairs moves)]
                  (and acc (not= m 0) (= player m))))))

(fn candidate-moves [moves candidates]
  "Just turning board spaces into player moves"
  (icollect [_ spaces (ipairs candidates)]
            (icollect [_ space (ipairs spaces)]
                      (. moves space))))

(fn mill-at? [all-mills current-moves move]
  "Is there a mill at this move?"
  (->> (get-candidates all-mills move)
       (candidate-moves current-moves) 
       (move-mills)
       (any)))

{: mill-at?
 ;; not for consumption,
 ;; just for testing:
 : get-candidates
 : candidate-moves
 : move-mills
 : any
 }