(defun runonce()
  (setf *seed0* (+ *seed0* 25))
  (setf end_development_cache (generate-end-development))
  (reset-seed)
  (print "PB:")
  (print (runpbsim end_development_cache))
  (reset-seed)
  (print "AG:")
  (print (runagsim "ag" end_development_cache))
  (reset-seed)
  (print "AG2:")
  (print (runagsim "ag2" end_development_cache))
  (reset-seed)
  (print "HY:")
  (print (runhysim end_development_cache))
  *seed0*
  )

(defun updatevaluesold(inrequirements)
  (mapcar #'(lambda(x) (progn
                         (setf (car x) (+ (car x) (randnorm 0 (globdef-req_value_sigma gv))))
                         x
                         )) inrequirements)
)

(defun updatevalues(inrequirements)
  (mapcar #'(lambda (x) (progn
                          (if (req-req_active x)
                              (setf (req-req_value x) (+ (req-req_value x) (* (req-req_value x) (pop (req-req_future_values x)))))
                              )
                          x
                          )) inrequirements)
  )
    


(defun addnewrequirements(inrequirements iteration)
  (mapcar #'(lambda (x) (if (and (not (null (req-req_activate_at_iter x))) (= (req-req_activate_at_iter x) iteration))
                            (progn
                              (setf (req-req_active x) t)
                              x
                              )
                            x
                            )) inrequirements)
  )

(defun retrieve-initial-requirements (allrequirements)
  (split-list (random-between-int (* (globdef-initial_bound_lower gv) (globdef-num_reqs gv)) (* (globdef-initial_bound_upper gv) (globdef-num_reqs gv))) allrequirements)
 )

(defun propersort (inrequirements conditionfunction keyfunction)
  (let ((sortablerequirements (remove-if #'(lambda (x) (null (req-req_active x))) inrequirements))
        (unsortablerequirements (remove-if #'(lambda (x) (not (null (req-req_active x)))) inrequirements))
        )
    (progn
      (setf sortablerequirements (sort sortablerequirements conditionfunction :key keyfunction))
      (append sortablerequirements unsortablerequirements)
      )
    )
  )

(defun averageResults(results fn)
  (remove nil (mapcar #'(lambda (x)
                          (if (< (length (remove nil x))
                                 (/ (globdef-num_trials gv) 20)
                                 )
                  nil
                  (/ (float (apply #'+ (remove nil x))) (length (remove nil x)))
                  )
              )
          (do ((i 0)
       (newlists nil))
      ((> i 50) newlists)
    (setf newlists (append newlists (list (mapcar #'(lambda (x) (nth i x)) (mapcar #'(lambda (x) (funcall fn x)) results)))))

    ;(print newlists)
    (incf i)
    
    )
          ))
)

(defun outputResults (filename results)
  (with-open-file (out filename :direction :output :if-exists :supersede :if-does-not-exist :create)
    (do ((i 0))
        ((> i (- (length (car results)) 1)))
      (format out "~,2F ~T ~,2F ~%" (nth i (car (cdr results))) (nth i (car results)))
      (incf i)
    )
    )
  )

;(defun runtest()
  ;(setf (globdef-num_trials gv) 1000)
  ;(setf (globdef-ave_new_req_per_iter gv) 20)
  ;(setf (globdef-req_value_sigma gv) 2)
  ;(runtrials)
  ;)

(defun runpom1()
  (runlow)
  (runmed)
  (runhigh)
  )

(defun runlow()
  (setf (globdef-num_trials gv) 1000)
  (setf (globdef-ave_new_req_per_iter gv) .001)
  (setf (globdef-req_value_sigma gv) .001)
  (runtrials)
)

(defun runmed()
  (setf (globdef-num_trials gv) 1000)
  (setf (globdef-ave_new_req_per_iter gv) 1.4)
  (setf (globdef-req_value_sigma gv) .15)
  (runtrials)
)

(defun runhigh()
  (setf (globdef-num_trials gv) 1000)
  (setf (globdef-ave_new_req_per_iter gv) 20)
  (setf (globdef-req_value_sigma gv) 2)
  (runtrials)
)

(defun runtrials()
  (let ((OF_resultlist nil)
        (OF_currentresult nil)
        (OI_resultlist nil)
        (OI_currentresult nil)
        (PB_resultlist nil)
        (PB_currentresult nil)
        (AG_resultlist nil)
        (AG_currentresult nil)
        (AG2_resultlist nil)
        (AG2_currentresult nil)
        (HY_resultlist nil)
        (HY_currentresult nil)
        )
    
    (dotimes (i (globdef-num_trials gv)
              )
      (setf *seed0* (+ 10000 (* i 25)))
      (setf end_development_cache (generate-end-development))
      (reset-seed)
      (setf OF_currentresult (list (runOFsim end_development_cache)))
     ; (print OF_currentresult)
      (setf OF_resultlist (append OF_resultlist OF_currentresult))
     ; (print OF_resultlist)
      (reset-seed)
      (setf OI_currentresult (list (runOIsim  end_development_cache)))
      (setf OI_resultlist (append OI_resultlist OI_currentresult))
      (reset-seed)
      (setf PB_currentresult (list (runpbsim end_development_cache)))
      ;(print (sumcost (third (car PB_currentresult))))
      (setf PB_resultlist (append PB_resultlist PB_currentresult))
      (reset-seed)
      (setf AG_currentresult (list (runagsim "ag" end_development_cache)))
      ;(print (sumcost (third (car AG_currentresult))))
      (setf AG_resultlist (append AG_resultlist AG_currentresult))
      (reset-seed)
      (setf AG2_currentresult (list (runagsim "ag2" end_development_cache)))
      ;(print (sumcost (third (car AG2_currentresult))))
      (setf AG2_resultlist (append AG2_resultlist AG2_currentresult))
      (reset-seed)
      (setf HY_currentresult (list (runhysim end_development_cache)))
      (setf HY_resultlist (append HY_resultlist HY_currentresult))
      
    )
    
    (outputResults "proj2-pom1/plotOFresult.dat" (list (averageResults OF_resultlist #'first) (averageResults OF_resultlist #'second)))
    (outputResults "proj2-pom1/plotOIresult.dat" (list (averageResults OI_resultlist #'first) (averageResults OI_resultlist #'second)))
    (outputResults "proj2-pom1/plotpbresult.dat" (list (averageResults PB_resultlist #'first) (averageResults PB_resultlist #'second)))
    (outputResults "proj2-pom1/plotagresult.dat" (list (averageResults AG_resultlist #'first) (averageResults AG_resultlist #'second)))
    (outputResults "proj2-pom1/plotag2result.dat" (list (averageResults AG2_resultlist #'first) (averageResults AG2_resultlist #'second)))
    (outputResults "proj2-pom1/plothyresult.dat" (list (averageResults HY_resultlist #'first) (averageResults HY_resultlist #'second)))
    (run-program "proj2-pom1/graph.sh" nil :wait   nil :pty    nil :input  :stream :error :output :output t)
 
  )
)

(defun runpbsim(end_developement_cache)
  (do* ((requirements (generate-value-cost))
        (PB_TotalCost (sumcost requirements))
        (PB_Plan (propersort (copy-list requirements) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        (PB_Completed (list))
        (current_iter 1)
        (end_development nil)
        (end_development_list (copy-list end_developement_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost PB_Completed #'sumvalue) (cumulativecost PB_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )
    ;(print "iter")
    ;(print current_iter)
    (do ((PB_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) PB_Plan))) (> (+ (req-req_cost (car PB_Plan)) (sumcost PB_Completed)) (/ (* PB_TotalCost current_iter) (globdef-num_iters gv)))))
      (setf PB_RequirementCompleted (pop PB_Plan))
      ;(print PB_RequirementCompleted)
      ;(incf PB_TotalIterationCost (second PB_RequirementCompleted))
      (setf (req-req_satisfied PB_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter PB_RequirementCompleted) current_iter)
      (setf PB_Completed (append PB_Completed (list PB_RequirementCompleted)))
      )
    ;put your code here
   
    ;(print "Plan before Update")
    ;(print PB_Plan)
    (setf PB_Plan (updatevalues PB_Plan))
    (setf PB_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             PB_Plan))
    (setf PB_Plan (addnewrequirements PB_Plan current_iter))
    ;(print "Plan after Update")
    ;(print PB_Plan)
    ;(format t "PB Iter ~D" current_iter)
    (incf current_iter)
    )
  )

(defun runOIsim(end_developement_cache)
  (do* ((requirements (generate-value-cost))
        (OI_TotalCost (sumcost requirements))
        (OI_Plan (propersort (copy-list requirements) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        (OI_Completed (list))
        (current_iter 1)
        (end_development nil)
        (end_development_list (copy-list end_developement_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost OI_Completed #'sumvalue) (cumulativecost OI_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )
    (do ((OI_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) OI_Plan)))
             (> (+ (req-req_cost (car OI_Plan)) (sumcost OI_Completed))
                (/ (* OI_TotalCost current_iter) (globdef-num_iters gv)))))
      (setf OI_RequirementCompleted (pop OI_Plan))
      ;(print PB_RequirementCompleted)
      ;(incf PB_TotalIterationCost (second PB_RequirementCompleted))
      (setf (req-req_satisfied OI_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter OI_RequirementCompleted) current_iter)
      (setf OI_Completed (append OI_Completed (list OI_RequirementCompleted)))
      )
 
    (incf current_iter)
    )
  )


(defun runOFsim (end_development_cache)
  (do* ((requirementsi (generate-value-cost))
        (OF_TotalCost (sumcost requirementsi))
	;(requirements (retrieve-initial-requirements requirementsi))
	(OF_Plan requirementsi)
	;(AG_Heap (getHeap requirements))
	(OF_Completed (list))
	(current_iter 1)
	(end_development nil)
        (end_development_list (copy-list end_development_cache))
	)
       ((or (> current_iter (globdef-num_iters gv)) end_development)
        (list (cumulativecost OF_Completed #'sumvalue) (cumulativecost OF_Completed #'sumcost)))
    ; check for end development
    (if (> current_iter (globdef-min_iters gv))
	(setf end_development (pop end_development_list))
	)
    
    (if (= current_iter 1)
        (progn
          ;(print requirementsi)
          ;(print PB_Plan)
        ))
    ; sort list
    (setf OF_Plan (propersort (copy-list OF_Plan) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
  
    (do ((OF_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) OF_Plan)))
             (> (+ (req-req_cost (car OF_Plan)) (sumcost OF_Completed))
                (/ (* OF_TotalCost current_iter) (globdef-num_iters gv)))))
      (setf OF_RequirementCompleted (pop OF_Plan))
      (setf (req-req_satisfied OF_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter OF_RequirementCompleted) current_iter)
      (setf OF_Completed (append OF_Completed (list OF_RequirementCompleted)))
      )

    (setf OF_Plan (updatevalues OF_Plan))
    (setf OF_Plan (addnewrequirements OF_Plan current_iter))

    (incf current_iter)
    )
)
    
(defun runagsim (simtype end_development_cache)
  (do* ((requirementsi (generate-value-cost))
        (AG_TotalCost (sumcost requirementsi))
	(requirements (retrieve-initial-requirements requirementsi))
	(AG_Plan (getPlan requirements))
	(AG_Heap (getHeap requirements))
	(AG_Completed (list))
	(current_iter 1)
	(end_development nil)
        (end_development_list (copy-list end_development_cache))
	)
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost AG_Completed #'sumvalue) (cumulativecost AG_Completed #'sumcost)))
    ; check for end development
    (if (> current_iter (globdef-min_iters gv))
	(setf end_development (pop end_development_list))
	)
    
    (if (= current_iter 1)
        (progn
          ;(print requirementsi)
          ;(print PB_Plan)
        ))
    ; sort list
    (if (string= simtype "ag")
        (setf AG_Plan (propersort (copy-list AG_Plan) #'> #'(lambda (x) (req-req_value x))))
        (setf AG_Plan (propersort (copy-list AG_Plan) #'> #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        )
    ;(print "Debug 1")

    (do ((AG_RequirementCompleted))
        ((or (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) AG_Plan))) (> (+ (req-req_cost (car AG_Plan)) (sumcost AG_Completed)) (/ (* AG_TotalCost current_iter) (globdef-num_iters gv)))))
      (setf AG_RequirementCompleted (pop AG_Plan))
      ;(print PB_RequirementCompleted)
      ;(incf PB_TotalIterationCost (second PB_RequirementCompleted))
      (setf (req-req_satisfied AG_RequirementCompleted) t)
      (setf (req-req_satisfied_in_iter AG_RequirementCompleted) current_iter)
      (setf AG_Completed (append AG_Completed (list AG_RequirementCompleted)))
      )

    (setf AG_Plan (updatevalues AG_Plan))
    (setf AG_Heap (updatevalues AG_Heap))
    
    (setf AG_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             AG_Plan))
    (setf AG_Heap (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             AG_Heap))

    (setf AG_Heap (addnewrequirements AG_Heap current_iter))

    
    ; take a poission number of reqs from heap and add to plan
    (let ((pRandNum (pRandom (globdef-ave_unimpl_req_per_iter gv))))

      ; append some poission number of reqs from heap to plan
      (if (> pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) AG_Heap)))
          (setf pRandNum (length (remove-if #'(lambda (x) (null (req-req_active x))) AG_Heap)))
          )
      (setf AG_Plan (append AG_Plan (car (split-list pRandNum AG_Heap))))
      ;(print "debug 3.1")
      ; set new heap
      (setf AG_Heap (cdr (split-list pRandNum AG_Heap)))
      )

    ; update values of plan
    
    ;(format t "AG Iter ~D" current_iter)
    ; increment iteration
    (incf current_iter)
    )
)

(defun runhysimold()
  (do* ((requirements (generate-value-cost))
        (HY_Plan (sort (copy-list requirements) #'> :key #'(lambda (x) (/ (first x) (second x)))))
        (HY_Completed (list))
        (current_iter 1)
        (end_development nil)
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost HY_Completed #'sumvalue) (cumulativecost HY_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (randbin1 (globdef-end_dev_prob gv)))
        )

    (setf HY_Plan (sort (copy-list HY_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
    ;(print "iter")
    ;(print current_iter)
    (do* ((HY_RequirementCompleted)
          (HY_TurningPoint (float (/  (sumvalue HY_Plan) (sumcost HY_Plan))))
          )
        ((or  (= 0 (length HY_Plan)) (< (/ (first (first HY_Plan)) (second (first HY_Plan))) HY_TurningPoint)))
      (setf HY_RequirementCompleted (pop HY_Plan))
      ;(print PB_RequirementCompleted)
      (setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
      )
    ;put your code here
    (incf current_iter)
    ;(print "Plan before Update")
    ;(print HY_Plan)
    (setf HY_Plan (updatevalues HY_Plan))
    (setf HY_Plan (remove-if #'(lambda (x) (if (<= (car x) 0)
                                               t
                                               nil
                                               ))
                             HY_Plan))
    (setf HY_Plan (addnewrequirements HY_Plan))
    (if (= (length HY_Plan) 0)
        (setf end_development t)
        )
    ;(print "Plan after Update")
    ;(print HY_Plan)
    )
  )


(defun runhysim(end_development_cache)
  (do* ((requirements (generate-value-cost))
	(HY_TotalCost (sumcost requirements))
        (HY_Plan (propersort (copy-list requirements) #'>  #'(lambda (x) (/ (req-req_value x) (req-req_cost x)))))
        (HY_Completed (list))
        (current_iter 1)
        (end_development nil)
	(end_development_list (copy-list end_development_cache))
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost HY_Completed #'sumvalue) (cumulativecost HY_Completed #'sumcost)))

    (if (= current_iter 1)
        (progn
          ;(print requirements)
          ;(print PB_Plan)
        ))
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (pop end_development_list))
        )

    ;(setf HY_Plan (sort (copy-list HY_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
    ;(print "iter")
    ;(print current_iter)
    (do* ((HY_RequirementCompleted)
          (HY_TurningPoint (float (/  (sumvalue HY_Plan) (sumcost HY_Plan))))
          )
	 ((or (= 0 (length (remove-if #'(lambda (x) (or (null (req-req_active x))
                                                        (< (/ (req-req_value x) (req-req_cost x)) HY_TurningPoint))) HY_Plan)))
              (> (+ (req-req_cost (car HY_Plan)) (sumcost HY_Completed)) (/ (* HY_TotalCost current_iter) (globdef-num_iters gv)))))
        ;((or  (= 0 (length HY_Plan)) (< (/ (first (first HY_Plan)) (second (first HY_Plan))) HY_TurningPoint)))
      
      (do* ((HY_RequirementCheck)
	    (found nil)
	    (i 0)
	    )
	   ((or (equal (nth i (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)) nil) found)
	    )
	(setf HY_RequirementCheck (nth i HY_Plan))
	;(print HY_RequirementCheck)
        ;(print i)
	(if (>= (/ (req-req_value HY_RequirementCheck) (req-req_cost HY_RequirementCheck)) HY_TurningPoint)
	    (progn
	      (setf HY_RequirementCompleted HY_RequirementCheck)
	      (setf HY_Plan (remove-nth i HY_Plan))
	      (setf (req-req_satisfied HY_RequirementCompleted) t)
	      (setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
	      (setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
	      (setf found t)
	      )
	    )
	(incf i)
	)

      ;(print 'done)
      ;(setf HY_RequirementCompleted (pop HY_Plan))
      ;(print PB_RequirementCompleted)
      ;(setf (req-req_satisfied HY_RequirementCompleted) t)
      ;(setf (req-req_satisfied_in_iter HY_RequirementCompleted) current_iter)
      ;(setf HY_Completed (append HY_Completed (list HY_RequirementCompleted)))
      )
    ;put your code here
   
    ;(print "Plan before Update")
    ;(print HY_Plan)
    (setf HY_Plan (updatevalues HY_Plan))
    (setf HY_Plan (remove-if #'(lambda (x) (if (<= (req-req_value x) 0)
                                               t
                                               nil
                                               ))
                             HY_Plan))
    (setf HY_Plan (addnewrequirements HY_Plan current_iter))
    (if (= 0 (length (remove-if #'(lambda (x) (null (req-req_active x))) HY_Plan)))
        (setf end_development t)
        )
    ;(print "Plan after Update")
    ;(print HY_Plan)
    (incf current_iter)
    )
  )