 (ns bench.core
-  (:require [kdtree :as k]
+  (:require [kdtree.core :as k]
+            [cljs.pprint :refer (pprint)]
             [cljs.nodejs :as node]))
 
 (enable-console-print!)
 
+;; --- Helpers
+
 (defn generate-points
-  [n]
-  (for [x (range 0 n)
-        y (range 0 n)]
-    #js [x y]))
+  ([n] (generate-points n 1))
+  ([n step]
+   (into-array
+    (for [x (range 0 n step)
+          y (range 0 n step)]
+      #js [x y]))))
 
-(defn bench-init-100
-  []
-  (js/console.time "init:100")
-  (let [points (into-array (generate-points 10))]
-    (k/create2d points)
-    (js/console.timeEnd "init:100")))
+;; --- Index Initialization Bechmark
 
-(defn bench-init-10000
+(defn- bench-init-10000
   []
   (js/console.time "init:10000")
-  (let [points (into-array (generate-points 100))]
+  (let [points (generate-points 1000 10)]
+    (println (count points))
     (k/create2d points)
     (js/console.timeEnd "init:10000")))
 
-(defn bench-init-160000
+(defn- bench-init-250000
   []
-  (js/console.time "init:160000")
-  (let [points (into-array (generate-points 400))]
+  (js/console.time "init:250000")
+  (let [points (generate-points 5000 10)]
+    (println (count points))
     (k/create2d points)
-    (js/console.timeEnd "init:160000")))
+    (js/console.timeEnd "init:250000")))
 
 (defn bench-init
   []
-  (bench-init-100)
   (bench-init-10000)
-  (bench-init-160000))
+  (bench-init-250000))
 
-(defn bench-knn-160000
+;; --- Nearest Search Benchmark
+
+(defn- bench-knn-160000
   []
-  (let [tree (-> (into-array (generate-points 400))
-                 (k/create2d))]
+  (let [tree (k/create2d (generate-points 4000 10))]
     (dotimes [i 100]
       (js/console.time "knn:160000")
       (let [pt #js [(rand-int 400)

        (.nearest tree pt 2))
      (js/console.timeEnd "knn:160000"))))

(defn bench-knn-360000
  []
  (let [tree (-> (into-array (generate-points 600))
                 (k/create2d))]
    (dotimes [i 100]
      (js/console.time "knn:360000")
      (let [pt #js [(rand-int 600)

  (bench-knn-160000)
  (bench-knn-360000))

;; --- Accuracity tests

(defn test-accuracity
  []
  (let [tree (k/create2d (generate-points 4000 20))]
    (print "[1742 1419]")
    (pprint (js->clj (.nearest tree #js [1742 1419] 6)))
    (print "[1742 1420]")
    (pprint (js->clj (.nearest tree #js [1742 1420] 6)))
    ))

(defn main
  [& [type]]
  (cond
    (= type "init")
    (bench-init)

    (= type "knn")
    (bench-knn)

    (= type "test")
    (test-accuracity)

    :else
    (println "not implemented")))

