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

(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 [candidates moves]
  "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?"
  (let [candidates (get-candidates all-mills move)
        my-moves (candidate-moves candidates current-moves)
        my-mills (move-mills my-moves)
        result (any my-mills)
        ]
    result))

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