;; Backward Chaining

(ns backward)
(import '(java.util.concurrent Executors ExecutorCompletionService))

(declare start solve-goal solve-rule collect unify)

; Choose between using parallel collect or sequential collect.
(def use-parallel-collect true)

(def completion-service (ExecutorCompletionService.
    (Executors/newCachedThreadPool)))

(defn start []
    (loop []
        (print "Enter query: ") (flush)
        (let [query (read-line)
            truth (solve-goal (symbol query))]
            (printf "Answer is: %s\n" truth))
        (recur)))

(defn fetch-rules [goal]
    (case goal
        g '[[a,b,c],[d,e,f]]
        a '[[e,f]]
        b '[[c,d,e,f]]
        c '[[e,f]]
        d '[[e,f]]
        e '[[]]
        f '[[]]
        true (throw (Exception. "No applicable rule"))))

(defn solve-goal [goal]
    (let [rules (fetch-rules goal)]
        (if (some empty? rules)
            1.0     ; return a truth value
            (do
                (doseq [rule rules]
                    (.submit completion-service #(solve-rule rule)))
                (.get (.take completion-service))))))

; Move minimization logic here from collect.
(defn solve-rule [rule-tail]
    (let [truths (collect solve-goal rule-tail)]
        (apply + truths)))

; Accumulate results
(def collect (if use-parallel-collect pmap map))