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

(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 runagsim ()
  (do* ((requirements (generate-value-cost))
	(requirements (retrieve-initial-requirements requirements))
	(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)))
    ; check for end development
    (if (> current_iter (globdef-min_iters gv))
	(setf end_development (randbin1 (globdef-end_dev_prob gv)))
	)
    ; sort list
    (setf AG_Plan (sort (copy-list AG_Plan) #'> :key #'car))
    ; 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))))
    ; 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)))
    ; take a poission number of reqs from heap and add to plan
    (let ((pRandNum (pRandom (globdef-ave_new_req_per_iter gv))))
      ; append some poission number of reqs from heap to plan
      (setf AG_Plan (append AG_Plan (car (split-list pRandNum AG_Heap))))
      ; set new heap
      (setf AG_Heap (cdr (split-list pRandNum AG_Heap)))
      )
    ; update values of plan
    (setf AG_Plan (updatevalues AG_Plan))
    ; increment iteration
    (incf current_iter)
    )
)

    

   ; (if (= current_iter 1)
	;(sort AG_Plan (copy-list AG_Plan) #'> :key #'car)
	;(progn	  
	 ; (if (> current_iter (globdef-min_iters gv))
	  ;    (setf end_development (randbin1 (globdef-end_dev_prob gv)))
	   ;   )
	  ;(sort AG_Plan (copy-list AG_Plan)

    
;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 runinteration()
  (do* ((requirements (generate-value-cost))
        (current_iter 1)
        (end_development nil)
        )
       ((or (> current_iter 1 (globdef-num_iters gv))end_development))
    
    (if (> current_iter (globdef-min_iters gv))
        (setf end_development (randbin1 (globdef-end_dev_prob gv)))
        )

    ;put your code here
    (print "iter")
    (print current_iter)
    (incf current_iter)
    )
  )