(ns meta-clojure.core
  (:require [meta-clojure.stm.v0-native :as mc])
  (:require [clojure.string :as str])
  (:require [clojure.walk :as walk])
  (:require [clojure.core :as clj])
  (:use     [clojure.pprint :only (pp pprint)])
  (:import [java.util.concurrent LinkedBlockingQueue])
  (:gen-class))

(def queue (ref '()))

(defn contains-element [elements collection]
  (some (zipmap elements (repeat true)) collection))

(defn has-element
  [col e]
  (some #(= e %) col))

(defn find-first
         [f coll]
         (first (filter f coll)))

; This function is blocking, which is what I want.
; However, it spins and thus used a LOT of cpu,
; whit is *not* what I want..
(defn get-either
  [getthese queue]
  (dosync
    (let [match   (first (filter #(has-element getthese %) @queue))
          newlist (filter #(not= match %)  @queue)]

      (if (not (nil? match))
        (do (ref-set queue newlist)
            match)
        (recur)))))

(defn somethread
  [iwantthese]
  (let [element (get-either iwantthese queue)
        wanted  (filter #(not= % element) iwantthese)]
    (println (str "I got " element))
    (Thread/sleep 500)
    (recur wanted)))

(defn test
  []
  (.start (Thread. (fn [] (somethread '(3 4 5)))))

  (dosync (alter queue #(cons 1 %)))
  (println "Main: added 1")
  (Thread/sleep 1000)

  (dosync (alter queue #(cons 2 %)))
  (println "Main: added 2")
  (Thread/sleep 1000)

  (dosync (alter queue #(cons 3 %)))
  (println "Main: added 3")
  (Thread/sleep 1000)

  (dosync (alter queue #(cons 4 %)))
  (println "Main: added 4")
  (Thread/sleep 1000)

  (dosync (alter queue #(cons 5 %)))
  (println "Main: added 5")
  )