(defn cmp-order
  ([a b] (cmp-order a b >))
  ([a b pred]
     (if (pred (:price a) (:price b))
       true
       (if (== (:price a) (:price b))
         (if (< (:id a) (:id b))
           true
           false)
         false))))

(def bids (ref (sorted-set-by #(cmp-order % %2 >))))
(def offers (ref (sorted-set-by #(cmp-order % %2 <))))
(def execs (ref []))
(def bookmap {:bid bids :offer offers})
(def revbookmap {:bid offers :offer bids})
(def orderid (ref 0))
(defstruct order :price :quant :side :id)
(def preds {:bid #(>= % %2) :offer #(<= % %2)})

(defn match
  [price quant side]
  (let [book (side revbookmap)
        pred (side preds)]
    (loop [bets @book quant-remain quant]
      (println "in loop" quant-remain)
      (if (pos? quant-remain)
        (if-let [bet (first bets)]
          (if (pred price (:price bet))
            (let [quant-to-ex (if (> quant-remain (:quant bet))
                                (:quant bet)
                                quant-remain)
                  new-quant-remain (- quant-remain quant-to-ex)]
              (dosync
               (alter execs conj [(:price bet) quant-to-ex])
	       (alter book disj bet)
	       (let [quant-in-book (- (:quant bet) quant-to-ex)]
		 (if (pos? quant-in-book)
		   (alter book conj
			  (struct order (:price bet) quant-in-book
				  side
				  (:id bet))))))
              (recur (next bets) new-quant-remain))
            (recur (next bets) quant-remain))
          quant-remain)
        quant-remain))))

(defn bet
  [price quant side]
  (let [remain (match price quant side)]
    (if (pos? remain)
      (dosync
       (alter (side bookmap) conj
              (struct order price remain side @orderid))
       (alter orderid inc)))))