<?php

require_once("ObjList.php");

class _CourseList extends ObjList
{
	// This inherits most of its classes from ObjList,
	// but, it has to be able to do special functions
	// specific to Courses.  Use parent:: to access
	// a parent function within ObjList.
	// Example: parent::indexOf();
	//public $arrayCourseIDList = array();

	/**
	 * Used to cast a regular ObjList object into a CourseList.
	 *
	 * @param ObjList $obj
	 * 
	 * @return CourseList
	 */
	static public function cast(ObjList $obj)
	{ // This can be used to cast a regular ObjList
		// into a CourseList object.
		// Use the syntax:  CourseList::cast($x);
		$new_c_l = new CourseList();
		$new_c_l->array_list = $obj->array_list;
		$new_c_l->is_empty = $obj->is_empty;
		$new_c_l->reset_counter();

		return $new_c_l;

	}


	/**
	 * Give every course in the list a minimum grade.
	 *
	 * @param string $min_grade
	 */
	function assign_min_grade($min_grade)
	{
		// Go through the list and give every course the specified
		// min grade.

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$course->min_grade = $min_grade;
		}


	}


	/**
	 * Go through the list and find any course whose hours are greater
	 * than $hours.  Make that course "unselectable."  Used in the groups.
	 * 
	 * For example, if a student may only select 3 hours from a group, we don't
	 * want to give them the option of selecting a 5 hour course.  But we also
	 * don't want to remove that course either.  We want to display it so they
	 * know it was an option (and possibly need to substitute or move things
	 * around if they need it).
	 *
	 * Returns TRUE if anything got assigned, FALSE if nothing got assigned.
	 * 
	 * @param int $hours
	 * 
	 * @return bool
	 */
	function assign_unselectable_courses_with_hours_greater_than($hours)
	{
		// Go through the list and assign bool_unselectable courses whose minHour
		// is greater than $hours.
		// Returns TRUE if it did assign something,
		// false if it didn't.

		$bool_assigned = false;

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->subject_id == "")
			{
				$course->load_descriptive_data();
			}
			
			if ($course->min_hours > $hours)
			{
				$course->bool_unselectable = true;
				$bool_assigned = true;
			}
		}

		return $bool_assigned;

	}

	/**
	 * Find and return a specific course from the list.
	 *
	 * @param int $course_id
	 *       - The course_id to look for.  Do not set if using
	 *         $use_course.
	 * 
	 * @param int $term_id
	 *       - The term_id for the course to look for.  Do not set if using
	 *         $use_course.
	 * 
	 * @param bool $bool_transfer
	 *       - Is the course we are looking for a transfer course?  Do not
	 *         use if using $use_course.
	 * 
	 * @param bool $bool_exclude_substitutions
	 *       - If TRUE, we will not consider courses which have been used
	 *         in a substitution.
	 * 
	 * @param Course $use_course
	 *       - Optional.  If you already have a course object which can be used
	 *         as a template to search for, specify it here.  Otherwise, set to
	 *         NULL.  If using this, then $course_id, $term_id, and $bool_transfer
	 *         will be ignored.
	 * 
	 * 
	 * @return Course
	 */
	function find_specific_course($course_id = 0, $term_id = 0, $bool_transfer = false, $bool_exclude_substitutions = true, Course $use_course = null)
	{
		if ($use_course != null && is_object($use_course))
		{
			$course_id = $use_course->course_id;
			$term_id = $use_course->term_id;
			$bool_transfer = $use_course->bool_transfer;
		}
		// Look through the array for a course with this id, termId, and
		// transfer credit status.
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];

			$check_course_id = $course->course_id;
			if ($bool_transfer == true && is_object($course->course_transfer))
			{
				$check_course_id = $course->course_transfer->course_id;
			}

			if ($check_course_id == $course_id && $course->term_id == $term_id && $course->bool_transfer == $bool_transfer)
			{

				if ($bool_exclude_substitutions == true)
				{
					if ($course->bool_substitution == true)
					{
						continue;
					}

				}

				return $course;
			}
		}

		return false;
	}


	/**
	 * Call the $course->load_course_descriptive_data() on 
	 * every course in the list.
	 *
	 */
	function load_course_descriptive_data()
	{
		// Call the load_descriptive_data() method
		// for every course in the list.

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$course->load_descriptive_data();
		}
	}


  /**
   * Using the parent's function of find_all_matches, this
   * will return a CourseList of all courses which match
   * the Course object.
   *
   * @param Course $course_c
   * @return CourseList
   */
	function find_all_matches(Course $course_c)
	{
		if (!$list_matches =  parent::find_all_matches($course_c))
		{
			return false;
		}


		$list_matches = CourseList::cast($list_matches);
		return $list_matches;
	}


	/**
	 * Returns a match to the Course courseC which does
	 * not have any courses fulfilling it.  Usefull for finding
	 * course requirement matches in a list which have not
	 * yet been assigned.
	 *
	 * @param Course $course_c
	 * @return Course
	 */
	function find_first_unfulfilled_match(Course $course_c)
	{
		// Returns match to courseC which does not have
		// any courses fulfilling it.  Useful for finding
		// course requirement matches in a list which have not
		// yet been assigned.

		for ($t = 0; $t < $this->count; $t++)
		{
			if ($this->array_list[$t]->equals($course_c) && $this->array_list[$t]->course_list_fulfilled_by->is_empty == true)
			{
				return $this->array_list[$t];
			}
		}

		return false;
	}

	/**
	 * Go through the list and set the $bool_exclude_repeat flag to TRUE
	 * for all matches of $course in this list.
	 *
	 * Returns FALSE if no matches could be found.
	 * 
	 * @param Course $course
	 * @return bool
	 */
	function mark_repeats_exclude(Course $course)
	{
		// Set the bool_exclude_repeat flag to TRUE for all
		// occurances of $course in THIS list.

		if (!$list_matches =  parent::find_all_matches($course))
		{
			return false;
		}

		$list_matches = CourseList::cast($list_matches);
		$list_matches->reset_counter();
		while($list_matches->has_more())
		{
			$c = $list_matches->get_next();
			$c->bool_exclude_repeat = true;
		}

		return true;

	}

	/**
	 * Find a list of matches to Course courseC, which fulfill 
	 * the min_grade requirement, ordered by most recently taken.
	 *
	 * Returns FALSE if no matches were found, else it will 
	 * return the matched Course object.
	 * 
	 * @param Course $course_c
	 * @param string $min_grade
	 * @param bool $bool_mark_repeats_exclude
	 * 
	 * @return Course
	 */
	function find_most_recent_match(Course $course_c, $min_grade = "D", $bool_mark_repeats_exclude = false)
	{
		// Get a list of all matches to courseC, and
		// then order them by the most recently taken course
		// first.
		// We should, too, check for minimum grades here
		// as well.


		if (!$list_matches =  parent::find_all_matches($course_c))
		{
			return false;
		}


		$list_matches = CourseList::cast($list_matches);


		// Don't just return if it's only got a size of 1,
		// so that it forces it to do the min grade checking.
		/*		if ($list_matches->getSize() == 1)
		{
		return $list_matches->get_next();
		}
		*/
		if ($list_matches->is_empty)
		{
			return false;
		}

		// If we are here, then we have more than one match.
		// Meaning, we have more than one class which might fit
		// into this course requirement.

		// Sort the courses into most recently taken first.
		$list_matches->sort_most_recent_first();


		// So, now that it's sorted, we should look through the list,
		// checking the min grade requirements (if any).  When we find
		// a good one, we will select it.

		$list_matches->reset_counter();
		while($list_matches->has_more())
		{
			$c = $list_matches->get_next();
			
			if ($c->bool_exclude_repeat == true)
			{
				continue;
			}
			//////////////////////////////////////////
			///  Check for min grade, etc, here.
			if (!$c->meets_min_grade_requirement_of(null, $min_grade))
			{
				if ($bool_mark_repeats_exclude == true)
				{
					// Since this course does not meet the min_grade,
					// check to see if it may be repeated.  If it can't,
					// then we must mark ALL previous attempts at this
					// course as being excluded from further consideration.
					// (ULM policy on repeats).
					// We don't do this consideration if they simply
					// withdrew from a course...
					if ($c->grade == "W") { continue; }

          if ($c->min_hours < 1 || $c->min_hours == "") {
					  $c->load_descriptive_data();  // make sure we get hour data for this course.
					}					
					
					if ($c->repeat_hours <= $c->min_hours)
					{
						// No repeats.
						$this->mark_repeats_exclude($c);
						return false;

					} else {
						// Repeats allowed, so just continue.
						continue;
					}

				} else {
					continue;
				}
			}

			// Has the course already been assigned?
			if ($c->bool_has_been_assigned)
			{ // Skip over it.  Now, this is an important part here, because actually, we should
				// only skip it (and look at the next one) if this course is allowed to be
				// repeated.  If it cannot be repeated, or if the student has taken the
				// maximum allowed hours, then we should return false right here.
				continue;
			}

			return $c;
		}

		return false;

	}

	/**
	 * @todo implement this function.
	 *
	 */
	function sort_best_grade_first()
	{
		// This will look very similar to sort_most_recent_first
		// when I get a chance to fool with it.
	}

	
	/**
	 * Remove courses from THIS list which appear in listCourses under
	 * these conditions:
	 *   - the listCourses->"assigned_to_group_id" != $group_id
	 * This function is being used primarily with $list_courses being the
	 * list of courses that students have taken.
	 * Also checking substitutions for courses substituted into groups.

	 * @param CourseList $list_courses
	 * @param int $group_id
	 * @param bool $bool_keep_repeatable_courses
	 * @param SubstitutionList $list_substitutions
	 */
	function remove_previously_fulfilled(CourseList $list_courses, $group_id, $bool_keep_repeatable_courses = true, $list_substitutions)
	{

		$rtn_list = new CourseList();

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];

			if ($bool_keep_repeatable_courses == true)
			{ // We can always keep repeatable courses in the list.
				if ($course->repeat_hours > $course->min_hours)
				{
					$rtn_list->add($course);
					continue;
				}
			}

			// Has the course been substituted?
			if ($test_sub = $list_substitutions->find_requirement($course,false, -1))
			{
				// it WAS substituted, so we should NOT add it to our
				// rtnList.
				continue;
			}
			
			
			// Okay, now check if $course is anywhere in $list_courses
			if ($test_course = $list_courses->find_match($course))
			{
				// Yes, it found a match.
				// I am taking out this part where I say if it is in
				// this group then we can keep it.  I think that shouldn't
				// be in.
				// This course is in another group, so do nothing
				// and skip it.
				
				// perhaps the course is on the degreePlan in excess with a W
				// or F?
				if (!$test_course->meets_min_grade_requirement_of(null, "D"))
				{
					// Meaning, this was a failed attempt, so we can add
					// our original course back in.
					$rtn_list->add($course);
					continue;
				}
				
				// perhaps this course was purposefully excluded from
				// this list because it did not meet the min grade
				// requirements?  If this is the case, $course should
				// still appear in THIS list.
				if (!$test_course->meets_min_grade_requirement_of($course))
				{
					// Meaning, this was attempt did not meet the
					// min grade of the original requirement, so we can add
					// our original requirement back in.
					$rtn_list->add($course);
					continue;
				}
															
			} else {
				// The course was NOT found in the courseList,
				// so its safe to add it back in.
				$rtn_list->add($course);
			}

		}


		$this->array_list = $rtn_list->array_list;
		$this->reset_counter();

	}


	/**
	 * Returns an array containing the unique subject_id's of
	 * the courses in this list.  Its assumed to be ordered
	 * already!
	 *
	 * @param bool $bool_ignore_excluded
	 * @return array
	 */
	function get_course_subjects($bool_ignore_excluded = true)
	{
		// returns an array containing the unique subject_id's
		// of the courses in this list.

		// IMPORTANT:  The list is assumed to be ordered already!  Either
		// alphabetically or reverse alphabetically.
		$old_subject_id = "";
		$rtn_array = array();

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->subject_id == "")
			{
				$course->load_descriptive_data();
			}

			
			// Go through all valid names for this course.
			for ($x = 0; $x < count($course->array_valid_names); $x++)
			{
				$temp = explode("~",$course->array_valid_names[$x]);
				$subj = strtoupper($temp[0]);

				if (in_array($subj, $rtn_array))
				{ // skip ones with subjects we have already looked at.
					continue;
				}

				if ($course->db_exclude == 1)
				{
					continue;
				}


				// We have a new subject.  Add it to the array.
				$rtn_array[] = $subj;
			}

		}

		return $rtn_array;
	}

	/**
	 * Go through the courseList and take out any course
	 * which does not have the $subject as its subject_id.
	 *
	 * @param string $subject
	 * @param bool $bool_reassign_valid_name
	 *     - If set to TRUE, we will look at other possible valid names
	 *       for this course.  If we find one, we will reassign the course's
	 *       subject_id and course_num to the new valid name.
	 * 
	 */
	function exclude_all_subjects_except($subject, $bool_reassign_valid_name = true)
	{

		$new_course_list = new CourseList();

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->subject_id == $subject)
			{
				$new_course_list->add($course);
				continue;
			}
			
			// Not the right subject-- but perhaps the course has another
			// valid name with this subject?  Ex: CSCI 373 and MATH 373.
			
			if ($bool_reassign_valid_name == true && count($course->array_valid_names) > 1)
			{
				for ($x = 0; $x < count($course->array_valid_names); $x++)
				{
					if (strstr($course->array_valid_names[$x], $subject))
					{
						$temp = explode("~",$course->array_valid_names[$x]);
						$course->subject_id = $temp[0];
						$course->course_num = $temp[1];

						$new_course_list->add($course);
						continue;
					}
				}
				
			}
			
			
		}

		// Now, transfer ownership of the arraylist.
		$this->array_list = $new_course_list->array_list;

	}


	/**
	 * This re-sorts the CourseList so that fulfilled courses
	 * are first, in alphabetical order, followed by
	 * unfulfilled courses, in alphabetical order.
	 * This is most useful for making the groups
	 * show up correctly.
	 * 
	 */
	function sort_fulfilled_first_alphabetical()
	{

		$tarray = array();
		for ($t = 0; $t < $this->count; $t++)
		{
			//if (!is_object($this->array_list[$t]->courseFulfilledBy))
			if ($this->array_list[$t]->course_list_fulfilled_by->is_empty == true)
			{ // Skip if not fulfilled.
				continue;
			}

			$c = $this->array_list[$t];
			$str = "$c->subject_id ~~ $c->course_num ~~ $t";
			array_push($tarray,$str);
		}

		sort($tarray);

		$new_list = new CourseList();
		for($t = 0; $t < count($tarray); $t++)
		{
			$temp = explode(" ~~ ",$tarray[$t]);
			$i = $temp[2];

			$new_list->add($this->array_list[$i]);
		}


		// Alright, now we do it again, but with unfulfilled courses.
		$tarray = array();
		for ($t = 0; $t < $this->count; $t++)
		{
			//if (is_object($this->array_list[$t]->courseFulfilledBy))
			if ($this->array_list[$t]->course_list_fulfilled_by->is_empty != true)
			{ // Skip if fulfilled.
				continue;
			}

			$c = $this->array_list[$t];
			$str = "$c->subject_id ~~ $c->course_num ~~ $t";
			array_push($tarray,$str);
		}

		sort($tarray);

		$new_list2 = new CourseList();
		for($t = 0; $t < count($tarray); $t++)
		{
			$temp = explode(" ~~ ",$tarray[$t]);
			$i = $temp[2];

			$new_list2->add($this->array_list[$i]);
		}

		// Now, combine the two lists.
		$new_list->add_list($new_list2);

		// And, transfer the newList into this list.
		$this->array_list = $new_list->array_list;


	}



  /**
   * This re-sorts the CourseList so that advised courses
   * are last, in alphabetical order, preceeded by
   * unfulfilled courses, in alphabetical order.
   * 
   *
   */
	function sort_advised_last_alphabetical()
	{

		$tarray = array();
		for ($t = 0; $t < $this->count; $t++)
		{
			if ($this->array_list[$t]->bool_advised_to_take == true)
			{ // Skip if not fulfilled.
				continue;
			}

			$c = $this->array_list[$t];
			$str = "$c->subject_id ~~ $c->course_num ~~ $t";
			array_push($tarray,$str);
		}

		sort($tarray);


		// Alright, now we do it again, but with advised courses.
		$t2array = array();
		for ($t = 0; $t < $this->count; $t++)
		{
			if ($this->array_list[$t]->bool_advised_to_take == false)
			{ // Skip if not advised
				continue;
			}

			$c = $this->array_list[$t];
			$str = "$c->subject_id ~~ $c->course_num ~~ $t";
			array_push($t2array,$str);
		}

		sort($t2array);

		$t3array = array_merge($tarray, $t2array);

		$new_list = new CourseList();
		for($t = 0; $t < count($t3array); $t++)
		{
			$temp = explode(" ~~ ",$t3array[$t]);
			$i = $temp[2];

			$new_list->add($this->array_list[$i]);
		}

		// And, transfer the newList into this list.
		$this->array_list = $new_list->array_list;


	}


	/**
	 * This function will resort this courselist for which a substitution
	 * has been made in listSubstitutions.
	 *
	 * @param SubstitutionList $list_substitutions
	 * @param int $group_id
	 */
	function sort_substitutions_first($list_substitutions, $group_id = 0)
	{
		// This will sort courses in a list for which
		// a substitution has been made in listSubstitutions.
		// It will place those courses at the top of the list.

		$top_array = array();

		// Since I need the indexes, I will have to go through the array
		// myself...
		for ($t = 0; $t < $this->count; $t++)
		{
			$c = $this->array_list[$t];
			// So-- does this course have a substitution somewhere in
			// the list (for the supplied groupID) ?
			if ($substitution = $list_substitutions->find_requirement($c, true, $group_id))
			{
				// yes, there is a sub for this group (or bare degree plan)
				$top_array[] = $t;
			}

		}

		// Okay, we now have, in the topArray, a list of indexes which should
		// appear at the top.
		$new_list = new CourseList();
		for ($j = 0; $j < count($top_array); $j++)
		{
			$new_list->add($this->array_list[$top_array[$j]]);
		}

		// Now, add everything else in the array (except indecies
		// appearing in topArray)

		for ($t = 0; $t < $this->count; $t++)
		{
			if (in_array($t, $top_array))
			{
				continue;
			}
			$new_list->add($this->array_list[$t]);
		}

		$this->array_list = $new_list->array_list;
		$new_list->reset_counter();

	}


	/**
	 * This will sort so that courses with the smallest hours
	 * (first trying hours_awarded, then min_hours)
	 * are at the top of the list.  If the list contains more
	 * than one course with a set of hours (like there are 30   
	 * courses all worth 3 hours) then it orders those as
	 * most-recently-taken first. 
	 *
	 */
	function sort_smallest_hours_first()
	{
		
		$tarray = array();

		// Since I need the indexes, I will have to go through the array
		// myself...
		for ($t = 0; $t < $this->count; $t++)
		{
			$c = $this->array_list[$t];
			$hours = $c->hours_awarded*1;
			if ($hours < 1)
			{
				$hours = $c->min_hours*1;
			}
			$str = "$hours ~~ $t";
			array_push($tarray,$str);
		}

		// Now, sort the array...
		//print_pre(print_r($tarray));
		sort($tarray);
		//print_pre(print_r($tarray));

		// Now, convert the array back into a list of courses.
		$new_list = new CourseList();
		for($t = 0; $t < count($tarray); $t++)
		{
			$temp = explode(" ~~ ",$tarray[$t]);
			$i = $temp[1];

			$new_list->add($this->array_list[$i]);
		}

		// Okay, now $new_list should contain the correct values.
		// We will transfer over the reference.
		$this->array_list = $new_list->array_list;


	}


	/**
	 * This method will sort by the most recently taken
	 * courses (determined by the term_id).
	 * The easiest way I can think to do this is to temporarily
	 * put their term_id's and index#'s into an array, and then
	 * have PHP sort the array itself.  PHP's sorting algorithm
	 * is faster than anything I can program right now, anyway.
	 *
	 * @param bool $bool_maintain_alpha_order
	 */
	function sort_most_recent_first($bool_maintain_alpha_order = true)
	{
		$tarray = array();

		
		// Since I need the indexes, I will have to go through the array
		// myself...
		for ($t = 0; $t < $this->count; $t++)
		{
			$c = $this->array_list[$t];
			$cn = "";
			if ($bool_maintain_alpha_order == true)
			{
				// We say 1000- the course number in order to give
				// us the complement of the number.  That is so it will
				// reverse-sort in the correct order.  Strange, but it fixes
				// a small display issue where PHYS 207 and PHYS 209, taken at
				// the same time, causes PHYS 209 to be displayed first.
				// We also reverse the subject_id, again, so that
				// MATH will be sorted above ZOOL, when taken at the same time.
				// This might not work at all, though...
				
				$cn = strrev($c->subject_id) . "," . (1000 - $c->course_num);

			}
			$str = "$c->term_id ~~ $cn ~~ $t";

			array_push($tarray,$str);
		}

		// Now, sort the array...
		rsort($tarray);

		// Now, convert the array back into a list of courses.
		$new_list = new CourseList();
		for($t = 0; $t < count($tarray); $t++)
		{
			$temp = explode(" ~~ ",$tarray[$t]);
			$i = $temp[2];

			$new_list->add($this->array_list[$i]);
		}

		// Okay, now $new_list should contain the correct values.
		// We will transfer over the reference.
		$this->array_list = $new_list->array_list;

	}

	/**
	 * Convienence function.  It simply calls sort_alphabetical_order(), but
	 * passes the boolean value to make it be reversed.
	 *
	 */
	function sort_reverse_alphabetical_order()
	{
		$this->sort_alphabetical_order(true);
	}


	/**
	 * Sorts the course list into alphabetical order.  If load_descriptive_data()
	 * has not already been called for each course, it will call it.
	 *
	 * @param bool $bool_reverse_order
	 *         - If set to TRUE, the list will be in reverse order.
	 * 
	 * @param unknown_type $bool_only_transfers
	 *         - Only sort the transfer courses.
	 * 
	 * @param unknown_type $bool_set_array_index
	 *         - If set to true, it will set the $course->array_index value
	 *           to the index value in $this's array_list array.
	 * 
	 */
	function sort_alphabetical_order($bool_reverse_order = false, $bool_only_transfers = false, $bool_set_array_index = false)
	{
		// Sort the list into alphabetical order, based
		// on the subject_id and course_num.
		$tarray = array();
		// Since I need the indexes, I will have to go through the array
		// myself...
		for ($t = 0; $t < $this->count; $t++)
		{
			$c = $this->array_list[$t];
			if ($c->subject_id == "")
			{
				$c->load_descriptive_data();
			}


			if ($bool_only_transfers == true)
			{
				// Rarer.  We only want to sort the transfer credits.  If the course doesn not
				// have transfers, don't skip, just put in the original.  Otherwise, we will be using
				// the transfer credit's SI and CN.
				if (is_object($c->course_transfer))
				{
					$str = $c->course_transfer->subject_id . " ~~ " . $c->course_transfer->course_num ." ~~ $t";
				} else {
					// There was no transfer!
					$str = "$c->subject_id ~~ $c->course_num ~~ $t";
				}
			} else {

				// This is the one which will be run most often.  Just sort the list
				// in alphabetical order.

				$str = "$c->subject_id ~~ $c->course_num ~~ $t";
			}
			array_push($tarray,$str);
		}

		// Now, sort the array...
		//print_pre(print_r($tarray));

		if ($bool_reverse_order == true)
		{
			rsort($tarray);
		} else {
			sort($tarray);
		}
		//print_pre(print_r($tarray));

		// Now, convert the array back into a list of courses.
		$new_list = new CourseList();
		for($t = 0; $t < count($tarray); $t++)
		{
			$temp = explode(" ~~ ",$tarray[$t]);
			$i = $temp[2];
			if ($bool_set_array_index == true)
			{
				$this->array_list[$i]->array_index = $i;
			}
			$new_list->add($this->array_list[$i]);
		}

		// Okay, now $new_list should contain the correct values.
		// We will transfer over the reference.
		$this->array_list = $new_list->array_list;

	}


	/**
	 * Returns an array of db_group_requirement_id's from the courses
	 * in this list.
	 *
	 * @return array
	 */
	function get_group_requirement_id_array()
	{
		// Return an array of db_group_requirement_id's
		// from the courses in this list, indexed by the
		// id's.

		$rtn_array = array();
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$rtn_array[$course->db_group_requirement_id] = true;
		}

		return $rtn_array;
	}

	
	
	/**
	 * Returns TRUE if this list has a course which contains
	 * $id for it's db_group_requirement_id property.
	 *
	 * @param int $id
	 *         - This is the id to test for.
	 * 
	 * @return bool
	 */
	function contains_group_requirement_id($id)
	{
		// Returns true if the list has a course
		// which contains $id for it's db_group_requirement_id.
		// False if it cannot be found.
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->db_group_requirement_id == $id)
			{
				return true;
			}
		}

		return false;

	}

	
  /**
	 * Returns the first course in the list
	 * which the user may select for advising.  This
	 * method is used by the popup window to determine
	 * what exactly is the first element of the course list.
	 * (so it can make that radio button checked).
	 * 
	 * Returns FALSE if it cannot find a selectable course.
   *
   * @return Course
   */
	function find_first_selectable()
	{
		/*

		*/
		$temp_i = $this->i;  // preserve the counter.
		$this->reset_counter();

		while($this->has_more())
		{
			$c = $this->get_next();
			if ($c->bool_advised_to_take == true)
			{
				continue;
			}
			if (!$c->course_list_fulfilled_by->is_empty)
			{
				continue;
			}
			if ($c->bool_unselectable == true)
			{
				continue;
			}

			// $c is our valid course...
			$this->i = $temp_i;
			//print_pre($c->to_string());
			return $c;


		}

		$this->i = $temp_i;
		return false;

	}


	/**
	 * Returns TRUE if there is at least one course in this list which
	 * is selected (for advising).
	 *
	 * @return bool
	 */
	function has_any_course_selected()
	{
		/*
		Returns TRUE if there is at least one course
		in this list which is "selected."  FALSE, otherwise.
		*/
		$temp_i = $this->i;  // preserve the counter.
		$this->reset_counter();
		$rtn = false;
		while($this->has_more())
		{
			$c = $this->get_next();
			if ($c->bool_selected == true)
			{
				$rtn = true;
				break;
			}
		}

		$this->i = $temp_i;
		return $rtn;
	}


	/**
	 * Mark every course in this list as bool_has_been_displayed = true.
	 * Used for making sure we don't display the same course twice on
	 * screen.
	 * 
	 * Returns FALSE if we did not mark any courses.
	 *
	 * @param int $semester_num
	 *         - If > -1, we will first make sure the course
	 *           falls into this semesterNum.  This way we can only
	 *           perform this operation on a particular semester.
	 * 
	 * @return bool
	 */
	function mark_as_displayed($semester_num = -1)
	{

	  $temp_i = $this->i;  // preserve the counter.
		$this->reset_counter();
		$rtn = false;
		while($this->has_more())
		{
			$c = $this->get_next();
			if ($semester_num != -1)
			{ // A semesterNum was specified.
				// Make sure the course is in the correct semester.
				if ($c->assigned_to_semester_num != $semester_num)
				{
					continue;
				}
			}

			$c->bool_has_been_displayed = true;
			$rtn = true;

		}

		$this->i = $temp_i;
		return $rtn;
	}


	/**
	 * Returns a CourseList of all the courses matching course_id
	 * that has bool_has_been_assigned == TRUE.
	 *
	 * @param int $course_id
	 * @return CourseList
	 */
	function get_previous_assignments($course_id)
	{
		// Return a courseList of all the times a course matching
		// course_id has the bool_has_been_assigned set to TRUE.

		$rtn_list = new CourseList();

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->course_id == $course_id && $course->bool_has_been_assigned == true)
			{
				$rtn_list->add($course);
			}
		}

		return $rtn_list;

	}

	/**
	 * Find the "best" match for this course, based on what
	 * the university considers a best match.
	 * This largely has to do with repeats.
	 * If the student has more than one credit, what is
	 * the "best" match?
	 * 
	 * For example, at ULM we consider the best match to be the
	 * most recent that meets the minimum requirements.
	 * Other schools might simply take the best grade.
	 *
	 * @param Course $course_c
	 * @param string $min_grade
	 * @param bool $bool_mark_repeats_exclude
	 *
	 * @return Course
	 */
	function find_best_match(Course $course_c, $min_grade = "D", $bool_mark_repeats_exclude = false)
	{

		return $this->find_most_recent_match($course_c, $min_grade, $bool_mark_repeats_exclude);

	}



	/**
	 * Adds the supplied CourseList to the bottom of $this's list.
	 *
	 * @param CourseList $course_l
	 */
	function add_list(CourseList $course_l)
	{
		for ($t = 0; $t < count($course_l->array_list); $t++)
		{
			$this->add($course_l->array_list[$t]);
		}

	}


	/**
	 * Returns hour many hours are in $this CourseList.
	 *
	 * @todo The ignore list should be database-based.  Should just get it
	 *       from the settings.
	 * 
	 * @param string $requirement_type
	 *         - If specified, we will only count courses which match this
	 *           requirement_type.
	 * 
	 * @param bool $bool_use_ignore_list
	 * @return int
	 */
	function count_hours($requirement_type = "", $bool_use_ignore_list = false, $bool_correct_ghost_hour = true, $bool_force_zero_hours_to_one_hour = false)
	{
		// Returns how many hours are being represented in this courseList.
		// A requirement type of "uc" is the same as "c"
		// (university capstone is a core requirement)

		$count = 0;
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];

			if ($bool_use_ignore_list == true)
			{
				// Do ignore some courses...
				$temp_course_name = $course->subject_id . " " . $course->course_num;
				// Check in our settings to see if we should ignore this course
				// (configured in /custom/settings.php)
				if (in_array($temp_course_name, csv_to_array($GLOBALS["fp_system_settings"]["ignore_courses_from_hour_counts"]))) {
					continue;
				}
				
			}
			
			if ($course->bool_substitution_new_from_split == true)			
			{
				// Do not count the possible fragments that are created
				// from a new substitution split.  This is causing problems
				// in getting accurate numbers on the pie charts.
				
				// BUT-- only skip if this new fragment isn't also being
				// substituted somewhere else!
				if ($course->bool_substitution == false)
				{ // not being used in another sub, so skip it.				  
					continue;
				}
			}

			$h_get_hours = $course->get_hours();
			
			
			if ($bool_correct_ghost_hour) {
  			// If this course has a ghosthour, then use the
  			// hours_awarded (probably 1).  However, if it was substituted,
  			// then we actually want the 0 hour.  Confusing, isn't it?
  			if ($course->bool_ghost_hour) {
  			  $h_get_hours = $course->hours_awarded;
  			}
			}
			
			if ($bool_force_zero_hours_to_one_hour) {			  
			  // We want to force anything with a 0 hour to be 1 hour.
			  // Helps when selecting 0 hour courses from groups.
			  if ($h_get_hours == 0) {			    
			    $h_get_hours = 1;
			  }
			}
			
			
			if ($requirement_type == "")
			{
				$count = $count + $h_get_hours;
			} else {
				// Requirement Type not blank, so only count these hours
				// if it has the set requirement type.
				if ($course->requirement_type == $requirement_type)
				{
					$count = $count + $h_get_hours;
					continue;
				}

				// For specifically "university capstone" courses...
				if ($course->requirement_type == "uc" && $requirement_type == "c")
				{
					$count = $count + $h_get_hours;
				}

				if ($course->requirement_type == "um" && $requirement_type == "m")
				{
					$count = $count + $h_get_hours;
				}


			}
		}

		return $count;
	}

	
	/**
	 * Removes courses which have neither been fulfilled or advised.
	 *
	 */
	function remove_unfulfilled_and_unadvised_courses()
	{
		// remove courses from THIS list
		// which have not been fulfilled AND
		// are not currently advised.
		$rtn_list = new CourseList();
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->course_list_fulfilled_by->is_empty == false)
			{
				// something IS fulfilling it!
				$rtn_list->add($course);

			} else if ($course->bool_advised_to_take == true)
			{
				// Was not being fulfilled, but, it was advised
				// to take.
				$rtn_list->add($course);
			}



		}

		$this->array_list = $rtn_list->array_list;
		$this->reset_counter();
	}


	/**
	 * Removes courses from this list which have not been fulfilled
	 * (ther course_list_fulfilled_by is empty).
	 *
	 */
	function remove_unfulfilled_courses()
	{
		// remove courses in THIS list
		// which have nothing in their course_list_fulfilled_by
		// object.
		$rtn_list = new CourseList();
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->course_list_fulfilled_by->is_empty == false)
			{
				$rtn_list->add($course);
			}
		}

		$this->array_list = $rtn_list->array_list;
		$this->reset_counter();

	}

	
	/**
	 * Returns a clone CourseList of $this.
	 *
	 * @param bool $bool_return_new_courses
	 *         - If set to TRUE, it will create new Course objects
	 *           based on the course_id's of the ones in $this's list.
	 *           If set to FALSE, this will add the exact same Course
	 *           objects by reference to the new list.
	 * 
	 * @return CourseList
	 */
	function get_clone($bool_return_new_courses = false)
	{
		// This will return a clone of this list.
		// If boolReturnNewCourses is true, then it will
		// return a new list of new instances of courses
		// from this list.
		$rtn_list = new CourseList();
		
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			
			if ($bool_return_new_courses == true)
			{
				$new_course = new Course();
				$new_course->course_id = $course->course_id;
				$rtn_list->add($new_course);
			} else {
				$rtn_list->add($course);
			}	
			
		}	
		
		return $rtn_list;
			
	}
	

	/**
	 * Returns a CourseList of all the fulfilled or advised courses
	 * in $this's list.
	 *
	 * @param bool $bool_return_new_courses
	 *         - Works the same as get_clone()'s boolReturnNewCourses
	 *           variable.
	 * 
	 * @return Course
	 */
	function get_fulfilled_or_advised($bool_return_new_courses = false)
	{
		
		$rtn_list = new CourseList();
		
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$add_course = $course;
			
			if ($bool_return_new_courses == true)
			{
				$add_course = new Course();
				$add_course->course_id = $course->course_id;
			}
			
			if ($course->bool_advised_to_take == true)
			{
				$rtn_list->add($add_course);
			}
			
			// Several ways to tell if a course is here by credit...
			if (!$course->course_list_fulfilled_by->is_empty)
			{
				$rtn_list->add($add_course);
			} else if ($course->grade != "") {
				$rtn_list->add($add_course);
			} else if ($course->bool_substitution == true)
			{
				$rtn_list->add($add_course);
			}			
		}
		
		return $rtn_list;
		
	}
	
	/**
	 * Returns the number of courses in this list which have either
	 * been fulfilled or advised to take.  It does not count hours,
	 * just the courses themselves.
	 *
	 * @return int
	 */
	function count_fulfilled_or_advised()
	{
		// This function returns the number of courses in this
		// courseList which is either fulfilled or has been advised
		// to take.  It does care about hours, just the number of
		// courses themselves.
		$count = 0;
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->bool_advised_to_take == true)
			{
				$count++;
			}
			
			// Several ways to tell if a course is here by credit...
			if (!$course->course_list_fulfilled_by->is_empty)
			{
				$count++;
			} else if ($course->grade != "") {
				$count++;
			} else if ($course->bool_substitution == true)
			{
				$count++;
			}			
		}
		
		return $count;
		
	}
	
	
	/**
	 * Returns a CourseList of courses which have bool_advised_to_take == true.
	 *
	 * @return CourseList
	 */
	function get_advised_courses_list()
	{
		// Return a courseList object of courses in THIS
		// list which have bool_advised_to_take == true.
		$rtn_list = new CourseList();
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->bool_advised_to_take == true)
			{
				$rtn_list->add($course);
			}
		}

		return $rtn_list;

	}


	/**
	 * Similar to count_hours, but this will only count courses
	 * which have been taken and have a grade.
	 * 
	 * @todo ignore list should be db-based, in the settings.
	 *
	 * @param string $requirement_type
	 *         - If set, we will only look for courses matching this requirement_type.
	 * 
	 * @param bool $bool_use_ignore_list
	 * @param bool $bool_ignore_enrolled
	 * @return int
	 */
	function count_credit_hours($requirement_type = "", $bool_use_ignore_list = false, $bool_ignore_enrolled = false, $bool_qpts_grades_only = FALSE)
	{
		// Similar to count_hours, but this will only
		// count courses which have been taken (have a grade).


		$count = 0;

		// Let's find out what our quality point grades & values are...
		$qpts_grades = array();
    $tlines = explode("\n", variable_get("quality_points_grades", "A ~ 4\nB ~ 3\nC ~ 2\nD ~ 1\nF ~ 0\nI ~ 0"));
    foreach ($tlines as $tline) {
      $temp = explode("~", trim($tline));      
      if (trim($temp[0]) != "") {
        $qpts_grades[trim($temp[0])] = trim($temp[1]);
      }
    }
    
    
		
		$enrolled_grades = csv_to_array($GLOBALS["fp_system_settings"]["enrolled_grades"]);
		$retake_grades = csv_to_array($GLOBALS["fp_system_settings"]["retake_grades"]);
		
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			
			if ($bool_use_ignore_list == true)
			{
				// Do ignore some courses...
        $temp_course_name = $course->subject_id . " " . $course->course_num;
				// Check in our settings to see if we should ignore this course
				// (configured in /custom/settings.php)
				if (in_array($temp_course_name, csv_to_array($GLOBALS["fp_system_settings"]["ignore_courses_from_hour_counts"]))) {
					continue;
				}				

			}
			

			
			if ($bool_ignore_enrolled == true)
			{
			  
        if (in_array($course->grade, $enrolled_grades)) {
          continue;
        }
			  
			  /*
				if ($course->is_completed() == false)
				{
  
					if ($course->course_list_fulfilled_by->is_empty)
					{
						continue;
					} else {
						if ($course->course_list_fulfilled_by->get_first()->is_completed() == false)
						{
							continue;
						}
					}
				}
				*/
			}

			// Only allowing grades which we have quality points for?
			if ($bool_qpts_grades_only) {
			  if ($course->grade != "" && !isset($qpts_grades[$course->grade])) {
			    continue;
			  }
			}
			else {
			  // Is this grade a "retake" grade?  If so, skip it.
			  if (in_array($course->grade, $retake_grades)) continue;
			}

			if ($course->grade != "")// || !($course->course_list_fulfilled_by->is_empty))
			{			  
			  
			  // If we require the grade to be a qpts_grade, then check that now.
			  if ($bool_qpts_grades_only && !isset($qpts_grades[$course->grade])) {
			    continue;
			  }
			  
			  
				if ($requirement_type == "")
				{
				  $h = $course->get_hours();
					$count = $count + $h;
				} else {
				  
					if ($course->requirement_type == $requirement_type)
					{
						$count = $count + $course->get_hours();						
						continue;
					}

					// For specifically "university capstone" courses...
					if ($course->requirement_type == "uc" && $requirement_type == "c")
					{
						$count = $count + $course->get_hours();
					}

					if ($course->requirement_type == "um" && $requirement_type == "m")
					{
						$count = $count + $course->get_hours();
					}


				}
			} else {

				// maybe it's a substitution?
				if ($requirement_type == "" || ($requirement_type != "" && $requirement_type == $course->requirement_type))
				{
					if ($course->course_list_fulfilled_by->is_empty == false)
					{
						$cc = $course->course_list_fulfilled_by->get_first();
						if ($cc->bool_substitution)
						{
						  
      			  // If we require the grade to be a qpts_grade, then check that now.
      			  if ($bool_qpts_grades_only && !isset($qpts_grades[$cc->grade])) {      			    
      			    continue;
      			  }
						  
						  
							$h = $cc->substitution_hours;
														
							
							if ($cc->bool_ghost_hour) {
							  $h = 0;
							}
							
							$count = $count + $h;							
						}
					}
				}
				
			}
		}

    		
		return $count;

	}

	

	/**
	 * Similar to count_credit_hours, but this will only count courses
	 * which have been taken and have a grade.  We will return back
	 * a sum of their quality points.
	 * 
	 * @todo ignore list should be db-based, in the settings.
	 *
	 * @param string $requirement_type
	 *         - If set, we will only look for courses matching this requirement_type.
	 * 
	 * @param bool $bool_use_ignore_list
	 * @param bool $bool_ignore_enrolled
	 * @return int
	 */
	function count_credit_quality_points($requirement_type = "", $bool_use_ignore_list = false, $bool_ignore_enrolled = false)
	{

		$points = 0;
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];

			if ($bool_use_ignore_list == true)
			{
				// Do ignore some courses...
        $temp_course_name = $course->subject_id . " " . $course->course_num;
				// Check in our settings to see if we should ignore this course
				// (configured in /custom/settings.php)
				if (in_array($temp_course_name, csv_to_array($GLOBALS["fp_system_settings"]["ignore_courses_from_hour_counts"]))) {
					continue;
				}				

			}


			if ($bool_ignore_enrolled == true)
			{
				if ($course->is_completed() == false)
				{
					if ($course->course_list_fulfilled_by->is_empty)
					{
						continue;
					} else {
						if ($course->course_list_fulfilled_by->get_first()->is_completed() == false)
						{
							continue;
						}
					}
				}
			}

			if ($course->grade != "")
			{
				if ($requirement_type == "")
				{
				  $p = $course->get_quality_points();
					$points = $points + $p;
				} else {
					if ($course->requirement_type == $requirement_type)
					{
						$p = $course->get_quality_points();
					  $points = $points + $p;
						continue;
					}

					// For specifically "university capstone" courses...
					if ($course->requirement_type == "uc" && $requirement_type == "c")
					{
						$p = $course->get_quality_points();
					  $points = $points + $p;
					}

					if ($course->requirement_type == "um" && $requirement_type == "m")
					{
            $p = $course->get_quality_points();
  					$points = $points + $p;
					}


				}
			} else {

				// maybe it's a substitution?
								
				
				if (($requirement_type == "") || ($requirement_type != "" && $requirement_type == $course->requirement_type))
				{
					if ($course->course_list_fulfilled_by->is_empty == false)
					{
						$cc = $course->course_list_fulfilled_by->get_first();
						if ($cc->bool_substitution)
						{
						  
							//$h = $cc->substitution_hours;
							
							//if ($cc->bool_ghost_hour) {
							//  $h = 0;
							//}
							
							// What are the quality points for this course?						
							$p = $cc->get_quality_points();
							
							$points = $points + $p;
						}
					}

				}
			}
		}

		return $points;

	}	
	
	

	/**
	 * Assign a groupID to every course in the list.
	 *
	 * @param int $group_id
	 */
	function assign_group_id($group_id)
	{
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$course->assigned_to_group_id = $group_id;
		}
	}


	/**
	 * Assign a semesterNum to every course in the list.
	 *
	 * @param int $semester_num
	 */
	function assign_semester_num($semester_num)
	{
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$course->assigned_to_semester_num = $semester_num;
		}
	}

	/**
	 * Sets the bool_has_been_assigned property of every course in
	 * the list.
	 *
	 * @param bool $bool_has_been_assigned
	 *         - What to set each course's->boolhasBeenAssigned property
	 *           to.
	 * 
	 */
	function set_has_been_assigned($bool_has_been_assigned = true)
	{
		// Set the bool_has_been_assigned for all items
		// in this list.
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$course->bool_has_been_assigned = $bool_has_been_assigned;
		}

	}


	/**
	 * Set's each course's bool_substitution value.
	 *
	 * @param bool $bool_s
	 *         - What to set each course's bool_substitution value to.
	 */
	function set_bool_substitution($bool_s = true)
	{
		// Set the bool_substitution for all items
		// in this list.
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$course->bool_substitution = $bool_s;
		}

	}

	/**
	 * Sets each course's $course_substitution value to the supplied
	 * Course object.
	 *
	 * @param Course $course_s
	 * @param string $sub_remarks
	 */
	function set_course_substitution(Course $course_s, $sub_remarks = "")
	{
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			$course->course_substitution = $course_s;
			$course->sub_remarks = $sub_remarks;
		}

	}



	/**
	 * Go through the list and decrement the specified_repeats
	 * value for all instances of Course $course.
	 *
	 * @param Course $course
	 */
	function dec_specified_repeats(Course $course)
	{
		// Go through the list, and decrement the specified_repeats
		// value for all instances of $course.
		for ($t = 0; $t < $this->count; $t++)
		{
			$course2 = $this->array_list[$t];
			if ($course2->course_id == $course->course_id)
			{
				$course2->specified_repeats--;
			}
		}

	}


	/**
	 * Go through the list and set the specified_repeats value to $num
	 * for all instances of $course.
	 *
	 * @param Course $course
	 * @param int $num
	 */
	function set_specified_repeats(Course $course, $num)
	{
		for ($t = 0; $t < $this->count; $t++)
		{
			$course2 = $this->array_list[$t];
			if ($course2->course_id == $course->course_id)
			{
				$course2->specified_repeats = $num;
				$course2->bool_specified_repeats = true;
			}

		}

	}


	/**
	 * Removes excluded courses from the list (courses that
	 * have db_exclude == 1)
	 *
	 */
	function remove_excluded()
	{
		// Removes courses from the list that have a db_exclude == 1.
		$new_list = new CourseList();
		// Do this by adding elements to an array.
		// course_id => index in list.
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course->subject_id == "")
			{ // load descriptive data (include exclude info)
				$course->load_descriptive_data();
			}
			
			if ($course->db_exclude == 1)
			{
				continue;
			}

			$new_list->add($course);

		}

		$this->array_list = $new_list->array_list;
		$this->reset_counter();

	}


	/**
	 * Removes null's and duplicate courses from the list.
	 *
	 */
	function remove_duplicates()
	{
		// Go through and remove duplicates from the list.
		// Also remove null's

		$tarray = array();
		$new_list = new CourseList();
		// Do this by adding elements to an array.
		// course_id => index in list.
		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course == null)
			{
				continue;
			}

			$tarray[$course->course_id] = -1;
		}

		for ($t = 0; $t < $this->count; $t++)
		{
			$course = $this->array_list[$t];
			if ($course == null)
			{
				continue;
			}

			//if (is_object($course->courseFulfilledBy))
			if (!($course->course_list_fulfilled_by->is_empty))
			{
				$tarray[$course->course_id] = $t;
				continue;
			}

			if ($tarray[$course->course_id]*1 < 0)
			{
				$tarray[$course->course_id] = $t;
			}

		}

		// Now, go through tarray and rebuild the newList.
		foreach($tarray as $course_id => $i)
		{
			$new_list->add($this->array_list[$i]);
		}

		// Switch over the reference.
		$this->array_list = $new_list->array_list;
		$this->reset_counter();

	}

} // end class CourseList