(defvar treeSize 0)
(defun RDR (testTbl trainTbl &key
	    (RuleGenerator #'GenerateRuleMatchNB))
  (let ((results))
    ;(gc :full t)
    (let ((testdata (cross-index testTbl))
     (traindata (cross-index trainTbl)))
      (let ((ruleset (Train (make-RDRule :comment "Top Rule"
  					 :class (xindex-majority-class traindata)
  					 :bad traindata
  					 :good (cross-index (table-copy (xindex-table traindata) nil))
  					 :ugly (cross-index (table-copy (xindex-table traindata) nil))
  					 :fn #'(lambda (x) (not (null x))))
  			    RuleGenerator)))
	;(print (Test ruleset testdata))
	;(print (Show ruleset))
	;(if (= (parse-integer (nth 4 *posix-argv*)) 2) (pruneTree ruleset traindata))
	;(print "Done Training")
	(setf results (Test ruleset testdata))
	(format t "~A" *TREESIZE*)))
    (reverse results)))

(defun pruneTree (rules data)
  (Test rules data t)
  (removeBadNodes rules)
  rules)
  
(defun my-fround (x &optional (d 2))
  (float (/ (round (* x (expt 10 d))) (expt 10 d))))

(defmacro dofile ((var filename) &body body)
  (let ((stream (gensym)))
    `(with-open-file (,stream ,filename)
       (do ((,var (read-line ,stream nil nil) (read-line ,stream nil nil)))
	   ((null ,var))
	 ,@body))))

(defun tokens (str test start)
  (let ((p1 (position-if test str :start start)))
    (if p1
	(let ((p2 (position-if #'(lambda (c)
				   (not (funcall test c)))
			       str :start p1)))
	  (cons (subseq str p1 p2)
		(if p2
		    (tokens str test p2)
		    nil)))
	nil)))

(defun second-word (str)
  (let ((p1 (+ (position #\  str) 1)))
    (subseq str p1 (position #\  str :start p1))))

(defun arffToIccle (filepath)
  (let ((lines (list))
	(columns (list))
	name)
    (dofile (line filepath)
	    (cond 
	      ((equal (char line 0) #\%) nil)
	      ((equal (char line 0) #\@) (cond
					   ((equal (char line 1) #\r) (setf name line))
					   ((equal (char line 1) #\a) (push line columns))
					   (t nil)))
	      (t (push line lines))))
    ;(print name)
    ;(print columns)
    ;(print lines)
    
    (setf columns (mapcar #'(lambda (x) (intern (second-word x))) columns))
    (setf lines (mapcar #'(lambda (x) (tokens x #'(lambda (y) (not (equal (format nil "~A" y) ","))) 0)) lines))
    (setf name (second-word name))

    ;(print name)
    ;(print columns)
    ;(print lines)

    (data :name name :columns columns :egs lines)))

(defun increaseTrue (tbl)
  (let ((cross (cross-index tbl))
	(trueRows (remove-if-not #'(lambda (x) (equal (eg-class x) "true")) (table-rows tbl))))
    ;(print trueRows)
    (if (> (length trueRows) 0)
	(while (< (/ (gethash (list (xindex-classi cross) "true") (xindex-uniques cross) 0) (gethash (list (xindex-classi cross) "false") (xindex-uniques cross) 0.001)) .2)
	  ;(print (/ (gethash (list (xindex-classi cross) "true") (xindex-uniques cross) 0) (gethash (list (xindex-classi cross) "false") (xindex-uniques cross) 0.001)))
	  (dolist (row trueRows)
	    (counted+ row (table-all tbl)))
	  (setf cross (cross-index tbl))))
    tbl))

(defun decreaseFalse (tbl)
  (let ((cross (cross-index tbl)))
    (let ((true (gethash (list (xindex-classi cross) "true") (xindex-uniques cross) 0))
	  (false (gethash (list (xindex-classi cross) "false") (xindex-uniques cross) 0.001)))
      (let ((trueRows (mapcar #'eg-features (remove-if-not #'(lambda (x) (equal (eg-class x) "true")) (table-rows tbl))))
	    (falseRows (mapcar #'eg-features (remove-if-not #'(lambda (x) (equal (eg-class x) "false")) (table-rows tbl))))
	    (x 0))
	(if (and (> true 0) (> false 0))
	    ;(print true)
	    ;(print false)
	    (while (and (< (/ true false) .2) (< (incf x) 100))
	      ;(format t "~A ~A~%" true false)
	      (pop falseRows)
	      (decf false)))
					;(print "DONE")
	(table-copy tbl (append trueRows falseRows))))))