(defun knn (tbl row k &optional (? #'zeror))
  (knn1 tbl tbl row k ?))

(defun knn1 (tbl above row k ?)
  (let ((right-size  (>=  k (length (table-rows tbl))))
	(clustered   (table-west tbl))
	)
    (cond ((not clustered) (funcall ? above))
	  (right-size      (funcall ? tbl))
	  (t               (knn2 tbl above row k ?)))))

(defun knn2 (tbl above row k ?)
  (with-slots (left right rows west east c break) tbl
    (let* ((a (dist tbl row west))
	   (b (dist tbl row east))
	   (x (x a b c)))
      (if (<= x break)
	  (knn1 left  tbl row k ?) 
	  (knn1 right tbl row k ?)))))

(defun classify-leaf (tbl row k)
  (with-slots (up gray? color id) tbl
    (print row)
    (format t "~&gray? ~a color ~a~%" gray? color)
    (cond (color  color)
	  (gray?  (zeror (kneighbors tbl row k)))
	  (up     (classify up row k)))))

(defun zeror (tbl)
  (let ((max -1)
	(h (make-hash-table :test #'equal))
	out)
  (dov (row (table-rows tbl) out)
    (let* ((klass (sym-klass1 row tbl))
	   (n     (incf (gethash klass h 0))))
      (when (> n max)
	(setf max n
	      out klass))))))

(defun !classify-all (&key (k 2) (tbl 'weather) (enough '2))
  (dohash (klass result (classify-all (idea (data2tree tbl enough)) k))
    (with-slots (target pf prec pd f g) result
      (format t "~&target: ~a pf: ~a prec: ~a pd: ~a f: ~a g: ~a ~a~%"
	      target pf prec pd f g result))))

(defun !classify1 (&optional (tbl 'weather) (enough '2))
  (let* ((tbl (data2tree tbl enough))
	(rows (table-rows tbl))
	(row (svref rows 0)))
    (knn tbl row 2)))

(defun !classify-all (&key (tbl 'weather) (k 2) (enough 2))
  (classify-all (data2tree tbl enough)
		:k k))

(defun classify-all (&key
		     (tbl "data/weather.lisp")
		     (repeats 10)
		     (k 1))
  (let* ((tbl1 (data tbl))
	 (log (results0 tbl1)))
    (dotimes (r repeats)
      (multiple-value-bind (train test)
	  (traintest tbl1)
	(classify-all1 train test log k)))
    (results! log)
    (dovalues (values log)
      (print values))))

(defun classify-all1 (train test log k)
  (setf train (idea train))
  (setf test  (idea test))
  (dov (row (table-rows test))
    (let ((actual    (sym-klass1 row test))
	  (predicted (knn train row k)))
      (results+ log actual predicted))))

(defun !classify-alls (&optional (f 'weather))
  (let ((tbl (idea (data2tree f 2))))
    (dolist (k '(1 2 3 4  5 6 7 ))
      (print k)
      (classify-all tbl :k k))))

(defun traintest (tbl)
  (let (trainings testings train test (rows (shufflev (table-rows tbl))))
    (dovs (row n rows)
      (if (zerop (mod n (1- 10)))
	  (push row testings)
	  (push row trainings)))
    (setf train (copy-table tbl)
	  test  (copy-table tbl)
	  (table-rows train) (vector! trainings)
	  (table-rows test)  (vector! testings))
    (values train test)))

;target: YES n: 50 pf: 100 prec: 66 pd: 100 f: 80 g: 0 acc: 66 
;target: NO n: 0 pf: 0 prec: 0 pd: 0 f: 0 g: 0 acc: 66 NIL