(load "globals.lisp")
(reset-seed)
(load "structs.lisp")
(load "macros.lisp")
(load "utils.lisp")
(load "utils2.lisp")
(load "dist.lisp")

(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) (pop (req-req_future_values x))))
                              )
                          x
                          )) inrequirements)
  )
    

(defun addnewrequirementsold(inrequirements)
  (append inrequirements (generate-value-cost (pRandom (globdef-ave_new_req_per_iter gv))))
  )

(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)
      )
    )
  )


;this function is wrong. needs to update req_heap somehow so we dont keep re-adding the same requirements
;(defun ag-additional-requirements (currentrequirements remainingrequirements)
  ;(let ((numreqstoadd (pRandom (globdef-ave_unimpl_req_per_iter gv)))
        ;)
    ;(if (< 1 (floor numreqstoadd))
        ;currentrequirments
        ;(append currentrequirements (justinsfunction remainingrequirements numreqstoadd))
        ;)
    ;currentrequirements
    ;)
;)

(defun averageResults(results fn)
  (remove nil (mapcar #'(lambda (x)
              (if (= (length (remove nil x)) 0)
                  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) 5)
  (setf (globdef-ave_new_req_per_iter gv) 1.4)
  (setf (globdef-req_value_sigma gv) .15)
  (runtrials)
  )

(defun runtrials()
  (let ((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))
      (reset-seed)
      (setf PB_currentresult (list (runpbsim)))
      (print (sumcost (third (car PB_currentresult))))
      (setf PB_resultlist (append PB_resultlist PB_currentresult))
      (reset-seed)
      (setf AG_currentresult (list (runagsim "ag")))
      (print (sumcost (third (car AG_currentresult))))
      (setf AG_resultlist (append AG_resultlist AG_currentresult))
      (reset-seed)
      (setf AG2_currentresult (list (runagsim "ag2")))
      (print (sumcost (third (car AG2_currentresult))))
      (setf AG2_resultlist (append AG2_resultlist AG2_currentresult))
      (reset-seed)
      (setf HY_currentresult (list (runhysim)))
      (setf HY_resultlist (append HY_resultlist HY_currentresult))
      
    )
    (outputResults "plotpbresult.dat" (list (averageResults PB_resultlist #'first) (averageResults PB_resultlist #'second)))
    (outputResults "plotagresult.dat" (list (averageResults AG_resultlist #'first) (averageResults AG_resultlist #'second)))
    (outputResults "plotag2result.dat" (list (averageResults AG2_resultlist #'first) (averageResults AG2_resultlist #'second)))
    (outputResults "plothyresult.dat" (list (averageResults HY_resultlist #'first) (averageResults HY_resultlist #'second)))
 
  )
)

(defun runpbsim()
  (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)
        )
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost PB_Completed #'sumvalue) (cumulativecost PB_Completed #'sumcost) PB_Completed))

    (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)))
        (if (= current_iter 4)
            (setf end_development t)
            )
        )
    (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)
    (incf current_iter)
    )
  )
    
(defun runagsim (simtype)
  (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)
	)
       ((or (> current_iter (globdef-num_iters gv)) end_development) (list (cumulativecost AG_Completed #'sumvalue) (cumulativecost AG_Completed #'sumcost) AG_Completed))
    ; check for end development
    (if (> current_iter (globdef-min_iters gv))
	;(setf end_development (randbin1 (globdef-end_dev_prob gv)))
        (if (= current_iter 4)
            (setf end_development t)
            )
	)
    
    (if (= current_iter 1)
        (progn
          (print requirementsi)
          ;(print PB_Plan)
        ))
    ; sort list
    (if (string= simtype "ag")
        (setf AG_Plan (sort (copy-list AG_Plan) #'> :key #'car))
        (setf AG_Plan (sort (copy-list AG_Plan) #'> :key #'(lambda (x) (/ (first x) (second x)))))
        )
    ;(print "Debug 1")

    (do ((AG_RequirementCompleted))
        ((or (= (length AG_Plan) 0) (> (+ (second (car AG_Plan)) (sumcost AG_Completed)) (/ (* AG_TotalCost current_iter) (globdef-num_iters gv)))))
      ;(print "trying")
      (setf AG_Completed (append AG_Completed (list (pop AG_Plan))))
      )
    ;(print AG_Completed)
    ; take 80% of plan and put in requirements
    ;(setf AG_Completed (append AG_Completed (car (split-list (floor (* (- 1 (globdef-AVE_UNIMPL_REQ_PER_ITER_MULTI gv)) (length AG_Plan))) AG_Plan))))
    ;(print "Debug 2")
    ; make remaining 20% the new plan (i.e. remove 80% from the plan)
    ;(setf AG_Plan (cdr (split-list (floor (* (- 1 (globdef-AVE_UNIMPL_REQ_PER_ITER_MULTI gv)) (length AG_Plan))) AG_Plan)))

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

    (setf AG_Plan (addnewrequirements AG_Plan))
    ;(if (string= simtype "ag")
        ;(setf AG_Heap (sort (copy-list AG_Heap) #'> :key #'car))
        ;(setf AG_Heap (sort (copy-list AG_Heap) #'> :key #'(lambda (x) (/ (first x) (second x)))))
        ;)

    
    ;(print "Debug 3")
    
    ; take a poission number of reqs from heap and add to plan
    (let ((pRandNum (pRandom (globdef-ave_unimpl_req_per_iter gv))))
      ;(print AG_Plan)
      ;(print AG_Heap)
      ; append some poission number of reqs from heap to plan
      (if (> pRandNum (length AG_Heap))
          (setf pRandNum (length 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)))
      )
    ;(print "Before")
    ;(print AG_Heap)
    
    ;(print "After")
    ;(print AG_Heap)
    ;(print "Debug 4")
    ; update values of plan
    
 
    ; increment iteration
    (incf current_iter)
    )
)

(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) HY_Completed))

    (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) (null (req-req_active x))) 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)
	(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)
	)
	
      ;(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
    (incf current_iter)
    ;(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)
    )
  )