#|
How to use to characterize the mapping when using fact++

;; load results
(setq *ecoycyc-ucsd-merge-log* (make-instance 'taxonomy.log :path <path to taxonomy.log, default "bug:iJR904;Taxonomy.log">))

;; give statistics on counts of each size of equivalence set
(report-on-reaction-equivalences *ecoycyc-ucsd-merge-log*)

;; how many unmapped ucsd reactions ? (ignore EX_ reactions) (ignore reverse reactions)
(count-unmapped-ucsd-reactions *ecoycyc-ucsd-merge-log*)

;; how many unmapped ecocyc reactions
(count-unmapped-ecocyc-reactions *ecoycyc-ucsd-merge-log*)

;; list unmapped reactions (ignore EX_ reactions) (ignore reverse reactions)
(list-unmapped-reactions *ecoycyc-ucsd-merge-log*)

|#

(defparameter *fact++-readtable* (copy-readtable))

(defun braces-reader (stream char )
   (declare (ignore char))
   (read-delimited-list #\} stream t))

(defun handle-colon (stream char)
  (declare (ignore stream char))
  :colon)

; { starts a list
(set-macro-character #\{ 'braces-reader nil  *fact++-readtable*)

; } ends a list
(set-macro-character #\} (get-macro-character #\) *fact++-readtable*) nil *fact++-readtable*)

(set-macro-character #\: 'handle-colon nil *fact++-readtable*)

(defun fact++-read (stream &optional (eof-marker :eof))
  (let ((*readtable* *fact++-readtable*)
	(*package* (load-time-value (find-package :keyword))))
    (read stream nil eof-marker)))

(defclass taxonomy.log ()
  ((forms :initarg :forms :initform nil :accessor forms)
   (path :initarg :path :initform "bug:iJR904;Taxonomy.log" :accessor path)
   ))

(defmethod initialize-instance ((l taxonomy.log) &key)
  (call-next-method)
  (read-taxonomy.log l))

(defmethod read-taxonomy.log ((l taxonomy.log))
  (with-open-file (f (path l))
    (loop for line = (read-line f nil :eof)
       when (equal line "") sum 1 into count
       until  (= count 2))
    (setf (forms l)
	  (loop for form = (fact++-read f :eof)
	     until (eq form :eof)
	     collect form 
	       ))
    (length (forms l))))

(defvar *ecoycyc-ucsd-merge-log* (make-instance 'taxonomy.log :path "bug:iJR904;Taxonomy.log"))
  

(defmethod get-reaction-mapping ((l taxonomy.log))
  (let ((forms (forms l)))
    (let ((equivalence-forms 
	   (mapcar (lambda(e) (remove := e)) 
		   (remove-if-not 
		    (lambda(el) (and (listp el) (member ':= el) (some (lambda(s) (and (stringp s) (search "reaction" s))) el)))
		    forms ))))
      equivalence-forms)))

(defmethod count-unmapped ((l taxonomy.log))
  (let ((forms (forms l)))
    (let ((equivalence-forms 
	   (mapcar (lambda(e) (remove := e)) 
		   (remove-if-not 
		    (lambda(el) (and (listp el) (member ':= el) (some (lambda(s) (and (stringp s) (search "reaction" s))) el)))
		    forms ))))
      equivalence-forms)))

(defmethod cross-mappings ((l taxonomy.log))
  (loop for equiv in (get-reaction-mapping l)
     when (and (some (lambda(r) (search "ecocyc" r)) equiv)
	       (some (lambda(r) (search "gcrg" r)) equiv)
	       (< (length equiv) 20))
       collect equiv))

(defmethod count-unmapped-ucsd-reactions ((l taxonomy.log))
  (length (remove-if-not (lambda(a)
			      (and (stringp a) 
				   (search "reaction" a)
				   (search "gcrg" a)
				   (not (search "EX_" a))
				   (not (search "reverse" a))))
			    (forms *ecoycyc-ucsd-merge-log*))))

(defmethod count-unmapped-ecocyc-reactions ((l taxonomy.log))
  (length (remove-if-not (lambda(a) (and (stringp a)
					 (search "reaction" a)
					 (search "ecocyc" a)))
			 (forms *ecoycyc-ucsd-merge-log*))))

(defmethod report-on-reaction-equivalences ((l taxonomy.log))
  (let ((table (make-hash-table)))
    (loop for equiv in (get-reaction-mapping l)
       when (and (some (lambda(r) (search "ecocyc" r)) equiv)
		 (some (lambda(r) (search "gcrg" r)) equiv))
	 do (incf (gethash (length equiv) table 0)))
    (let ((keys (sort (loop for k being the hash-keys of table collect k) '<)))
      (loop for k in keys
	   do (format t "~a: ~a~%" k (gethash k table))))
    (values)))

(defmethod list-unmapped-reactions ((l taxonomy.log))
  (format t "~{~A~%~}" 
	  (sort (remove-if-not
		 (lambda(a) 
		   (and (stringp a)
			(search "reaction" a) 
			(not (search "EX_" a))
			(not (search "reverse" a))
			)) 
		 (forms *ecoycyc-ucsd-merge-log*))
		'string-lessp)))