(def N 2)
(def counter (atom 0))

(defn rate-limit-exceeded? []
  (>= @counter N))

(def balancer (agent {}))

(def queue (atom clojure.lang.PersistentQueue/EMPTY))

(defn enqueue! [value]
  (swap! queue conj value)
  nil)

(defn dequeue! []
  (let [[old new] (swap-vals! queue pop)]
    (peek old)))

(defn request [_]
  (when-not (rate-limit-exceeded?)
    (swap! counter inc)
    (when-let [item (dequeue!)]
      (let [word (:word item)]
        (println "request" word "...")
        (future
          (Thread/sleep (+ (rand-int 1000) 1000))
          (when-not (realized? (:promise item))
            (deliver (:promise item) {word (str "http://google.com?q=" word)}))
          (swap! counter dec))))))

(defn counter-watcher [key atom old-state new-state]
  (send-off balancer request))

(add-watch counter :watcher counter-watcher)

(defn get-url [word]
  (let [response (promise)
        item {:word word :promise response}]
    (enqueue! item)
    (send-off balancer request)
    response))

(def fixtures [
               "ocaml haskell erlang"
               "clojure racket scheme"
               "ruby python php"
               ])

(defn get-urls [words]
  (apply merge (pmap (fn [word] @(get-url word)) words)))

(defn endpoint []
  (println (pmap #(get-urls (clojure.string/split % #" ")) fixtures)))

(endpoint)
(shutdown-agents)