//********************************************************************
//
// StudentGrades.java
// Program Title: Student Grade File Processing
//
//********************************************************************
//
// Program Description:
// -------------------
//
//	This is a program that updates a student's cumulative grade data after new grades 
//	for the most recent quarter have been recorded and prints out the new updated results and
//	the results for the information on the most recently completed quarter
//      
//
// Input Requirements:
// ------------------
//
//	A text file contains grade data for many students. Data for each student is stored on 
//	three lines of the file. This is called a record. There may be any number of records in 
//	a file, including zero. Data values on each line are separated from each other by white 
//	space. However, the Student Name field may contain embedded blanks. The description of 
//	the data fields in a record for one student is: 
//
//	First Line: Student identification data 
//		1. Student ID#: student's ID #: 9 decimal digits (with no dashes between the digits) 
//		2. Student name: student's last name, first name, and initial(s): 
//		There will be blank spaces within the name separating each part of the name. The 
//		number of parts of a name can be different for each student (some names may be 1 or 2 
//		words and others as many as 4 or 5 words).
//
//	Second Line: Cumulative grade data 
//		1. Cumulative number of quarters completed: the number of quarters the student has 
//		completed to date (not including the current quarter): an integer in the range 0-40 
//		2. Cumulative credits: the number of credits the student has completed to date (not 
//		including the current quarter): an integer in the range 0-300 
//		3. Overall GPA: the student's grade point average to date (not including the current 
//		quarter): a floating point number in the range 0.00-4.00 with two decimal places 
//
//	Third Line: Current quarter grade data 
//		1. Count of courses taken in the current quarter: 
//		an integer between 2 and 6 (each student may have a different count) 
//		2. Credit and grade data for each course (same number of credits and grades as the 
//		count value): 
//		This data appears in the order: # credits 1st course, grade for 1st course, # credits 
//		2nd course, grade for 2nd course, ... 
//		Each credit value is an integer in the range 2-5 and each grade value is a floating 
//		point number in the range 0.0 to 4.0.
//	
//	Last Line: 
//		1. The end of the input data is signaled by a sentinel value of zero as a student ID#. 
//		There is no other data after the zero.
//      
//
// Output Requirements:
// -------------------      
// 
//	The output includes three lines of text for each student. The output for each student is: 
//
//	First Line: Student identification data -- same as the input 
//		1. Student ID# 
//		2. Student name 
//		
//	Second Line: Cumulative grade data -- same as the input except quarters completed, credit 
//	units, and GPA are the new updated values. 
//		1. Cumulative number of quarters completed 
//		2. Cumulative credits 
//		3. Overall GPA 
//
//	Third Line: Current quarter grade data 
//		1. Count of courses current quarter (same as input file) 
//		2. Total credits current quarter: an integer 
//		3. Quality points current quarter: a floating point number with one decimal place 
//		4. GPA current quarter: a floating point number with two decimal places 
//		5. Letter grade current quarter: a single character, A, B, C, D, or F 
//		(no + and - grades are computed in this program)
//
//	Last Line: 
//		The end of the output is signaled by a sentinel value of zero as a student ID#. There 
//		is no other output after the zero     
//
// Problem Solution Discussion:
// ---------------------------
//	
//		This Program first reads the value of the ID number. if it is not equal to zero, it
//	enters the loop. Then, it inputs the name of sudent, cumulative number of quarters,
//	cumulative number of credits, overall GPA prior to this quarter, and number of courses in 
//	this quarter. It then runs another loop for the amount of times as the number of courses
//	the student is taking. In the loop, it inputs the amount of credits and grade for each
//	course taken in the quarter and takes the sum of each. To get the quality points for the
//	current quarter, the product of the grade and number of credits of each course are all
//  summed up. the total credits taken that quarter is also the sum of the credits of each 
//	course. exit loop. To get the quality points for the prior quarters, we multiply the 
//	cumulative number of credits prior to this quarter with the GPA prior to this quarter.
//	Then to get the average GPA for this quarter, the quality points of the quarter is divided
//	by the total credits taken this quarter. The cumulative number of quarters is incremented 
//	by one. The new cumulative credits is the cumulative credits before this quarter plus the
//	total credits taken this quarter. the new overall GPA is the sum of the quality points 
//	prior to this quarter and the quality points of this quarter all divided by the cumulative
//	amount of credits. The letter grade for the quarter is derived by the following:
//		if GPA current quarter >= 3.67, then A 
//		if current quarter GPA < 3.67 and >= 3.0, then B 
//		if current quarter GPA < 3.0 and >= 2.0, then C 
//		if current quarter GPA < 2.0 and >= 1.0, then D 
//		if current quarter GPA < 1.0, then F 
//	exit loop.
//
// Data Structures:
// ---------------
//
//		Name          Data Type      Description
//		---------     ---------      -----------------------------
//		IDNum,	 	   integer		student ID number
//		cumQuarters    integer		cumulative number of quarters completed
//		cumCredits     integer		cumulative number of credits completed
//		curNumCourses  integer		number of courses in current quarter
//		curCredits     integer		number of credits in course in current quarter
//		curTotCredits  integer		total number of credits in current quarter
//		count     	   integer		used to define amount of times to run loop		
//	    oldGPA		   float		overall GPA prior to current quarter
//    	curGrade	   float		grade in specific course taken this quarter
//     	curGPA		   float		GPA of current quarter
//     	curQualPts	   float		quality points in current quarter
//     	oldQualPts	   float		quality points prior to current quarter
//     	newGPA		   float		overall GPA after current quarter
//      name		   String		student name
//    	letterGrade	   String		average letter grade for current quarter
//
//
// Problem Solution Design Steps:
// -----------------------------
//
//input IDnum (priming read)
//run loop while IDnum not equal to zero (sentinel)
//	enter loop
//	
//		input name
//		input cumQuarters
//		input cumCredits
//		input oldGPA
//		input curNumCourses
//		set count equal to curNumCourses
//		run loop while count > 0
//		
//		enter loop
//			input curCredits
//			input curGrade
//			set curQualPts equal to curQualPts + {curCredits * curGrade)
//			set curTotCredits equal to curTotCredits + curCredits
//			reduce count by increment of 1
//      exit loop
//
//      set oldQualPts equal to (cumCredits * oldGPA)
//      set curGPA equal to (curQualPts / curTotCredits)
//      cumQuarters up by 1
//      set cumCredits equal to (cumCredits + curTotCredits)
//      set newGPA equal to ((oldQualPts + curQualPts) / cumCredits)
//
//    	if curGPA >= 3.67, then letterGrade = A 
//		if curGPA < 3.67 and >= 3.0, then letterGrade = B 
//		if curGPA < 3.0 and >= 2.0, then letterGrade = C 
//		if curGPA < 2.0 and >= 1.0, then letterGrade = D 
//		if curGPA < 1.0, then letterGrade = F 
//
//      print IDNum and name on same line
//      print cumQuarters, cumCredits, and newGPA (extended to 2 decimal places) on same line   
//      print curNumCourses, curCredits, curQualPts (extended to one decimal place), 
//      curGPA(extended to 2 decimal places), and letterGrade  on same line
//      input IDNum
//      	
//	exit loop
//    
//print 0     
//
//end
//********************************************************************

import cs1.Keyboard;			//textbook's Keyboard input class
import java.text.DecimalFormat;	//class to extend number out to # decimal places

public class StudentGrades
{
   
   //-----------------------------------------------------------------
   //  The class main method
   //-----------------------------------------------------------------
   public static void main (String[] args)
   {
   	
	int IDNum,	 		//student ID number
		cumQuarters,	//cumulative number of quarters completed
		cumCredits, 	//cumulative number of credits completed
		curNumCourses,	//number of courses in current quarter
		curCredits=0,	//number of credits in course in current quarter
		curTotCredits,	//total number of credits in current quarter
		count;			//used to define amount of times to run loop
		
	float oldGPA,		//overall GPA prior to current quarter
      	  curGrade,		//grade in specific course taken this quarter
      	  curGPA,		//GPA of current quarter
      	  curQualPts,	//quality points in current quarter
      	  oldQualPts,	//quality points prior to current quarter
      	  newGPA;		//overall GPA after current quarter
      	  
    String name,				//student name
    	   letterGrade = "";	//average letter grade for current quarter
    	   
    	   
    DecimalFormat fmtGPA = new DecimalFormat ("0.00");
    DecimalFormat fmtPts = new DecimalFormat ("#.0");
      	  
	//input IDnum (priming read)
	IDNum = Keyboard.readInt();
	
	//run loop while IDnum not equal to zero (sentinel)
	while (IDNum != 0)
	{	
		//initialize all necessary values to zero so program doesnt include prior student's stats as well
		cumQuarters = 0;
		cumCredits = 0;
		curNumCourses = 0;
		curTotCredits = 0;
		oldGPA = 0;
		curGrade = 0;
		curQualPts = 0;
		oldQualPts = 0;
		newGPA = 0;
		letterGrade = "";
		
		//input name
		name = Keyboard.readString();
		
		//input cumQuarters
		cumQuarters = Keyboard.readInt();
		
		//input cumCredits
		cumCredits = Keyboard.readInt();
		
		//input oldGPA
		oldGPA = Keyboard.readFloat();
		
		//input curNumCourses
		curNumCourses = Keyboard.readInt();
		
		//set count equal to curNumCourses
		//run loop while count > 0
		//reduce count by increment of 1
		for (count=curNumCourses; count > 0; count--)		
		{	
			//input curCredits
			curCredits = Keyboard.readInt();
			
			//input curGrade
			curGrade = Keyboard.readFloat();
			
			//set curQualPts equal to curQualPts + (curCredits * curGrade)
			curQualPts += (curCredits * curGrade);
			
			//set curTotCredits equal to curTotCredits + curCredits
			curTotCredits += curCredits;
      	}
      	
      	//set oldQualPts equal to (cumCredits * oldGPA)
      	oldQualPts = (cumCredits * oldGPA);
      	
      	//set curGPA equal to (curQualPts / curTotCredits)
      	curGPA = (curQualPts / curTotCredits);
      	
      	//cumQuarters up by 1
      	cumQuarters ++;
      	
      	//set cumCredits equal to (cumCredits + curTotCredits)
      	cumCredits += curTotCredits;
      	
      	//set newGPA equal to ((oldQualPts + curQualPts) / cumCredits)
      	newGPA = ((oldQualPts + curQualPts) / cumCredits);
      	//if curGPA >= 3.67, then letterGrade = A 
      	if (curGPA >= 3.67)
      		letterGrade = "A" ;
      		
		//if curGPA < 3.67 and >= 3.0, then letterGrade = B 
		else if (curGPA < 3.67 && curGPA >= 3.0)
			letterGrade = "B" ;
			
		//if curGPA < 3.0 and >= 2.0, then letterGrade = C 
		else if (curGPA < 3.0 && curGPA >= 2.0)
			letterGrade = "C"; 
			
		//if curGPA < 2.0 and >= 1.0, then letterGrade = D 
		else if (curGPA < 2.0 && curGPA >= 1.0)
			letterGrade = "D" ;
			
		//if curGPA < 1.0, then letterGrade = F 
  		else if (curGPA < 1.0)
  			letterGrade = "F"; 
      	
      	
      	//print IDNum and name on same line
      	System.out.println (IDNum + " " + name);
      	
      	//print cumQuarters, cumCredits, and newGPA (extended to 2 decimal places) on same line   
      	System.out.println (cumQuarters + " " + cumCredits + " " + fmtGPA.format(newGPA));
      	
      	//print curNumCourses, curTotCredits, curQualPts (extended to one decimal place), curGPA(extended to 2 decimal places), and letterGrade  on same line
      	System.out.println (curNumCourses + " " + curTotCredits + " " + fmtPts.format(curQualPts) + " " + fmtGPA.format(curGPA) + " " + letterGrade);
      	
      	//input IDNum
      	IDNum = Keyboard.readInt();
    }
    
    //print 0
    System.out.println (0);
    	
   } //end main

} // end class StudentGrades