// *******************************************************
// *   Student.java                                      *
// *                                                     *
// *   Student operations.                               *
// *   Author: Jurand Nogiec                             *
// *   Date:   April 11, 2007                            *
// *******************************************************

public class Student
{
    
    //4 private instance variables
    private String firstName;
    private String lastName;
    private String uid;
    private SemesterTranscript[] transcriptArray;
    
    //2 private instance methods 
    private Student()
	{
	    //no code necessary here
	}
    
//     private SearchResultPair findSemester(SemesterPair semester) 
// 	{
// 	    Error.Assert(
// 			 (semester != null),
// 			 "Student::findSemester(SemesterPair): " +
// 			 "parameter SemesterPair reference must not be null!");
	    
// 	    boolean semesterNotFound = true;
// 	    int semesterIndex = 0;
	    
// 	    //search the transcriptArray
	    
// 	    while(semesterNotFound && (semesterIndex < transcriptArray.length))
// 		{		    		    	          
// 		    if(transcriptArray[semesterIndex].getSemesterPair().compareTo(semester) == 0)
// 			    semesterNotFound = false;			

// 		    else
// 			semesterIndex++;


// 		}
	    
// 	    // from the SemesterTranscript.java file provided in part1
// 	    SearchResultPair resultPair = new SearchResultPair();
// 	    resultPair.index = semesterIndex;
// 	    resultPair.isFound = !(semesterNotFound); // if exits not finding it, semesterNotFound is true
// 	    return resultPair;                        // if exits finding it, semesterNotFound is false
	    
// 	}
    
    private SearchResultPair findSemester(SemesterPair semesterPair)
    {
	Error.Assert(
		     (semesterPair != null),
		     "Student::findSemester(SemesterPair): " +
		     "parameter SemesterPair reference must not be null!");
	
	SearchResultPair result = new SearchResultPair();
	
	// SemesterPair found

	
	if(transcriptArray.length == 0)
	    {
		result.index = 0;
		result.isFound = false;

		return result;
	    }

	for(int i=0; i < transcriptArray.length; i++)
	    {
		if(transcriptArray[i].getSemesterPair().equals(semesterPair))
		    {
			result.index = i;
			result.isFound = true;

			return result;
		    }

		else if( semesterPair.compareTo(transcriptArray[i].getSemesterPair().getSeason(),transcriptArray[i].getSemesterPair().getYear()) == -1 )
		{
			result.index = i;
			result.isFound = false;
			return result;
		}

			   
	    }
       //my code --------------
       if (i = transcriptArray.length -1)
       {
         result.index = i+1;
         result.isFound = false;
         return result;
       }
	//end my code---------

	// SemesterPair not found
	

			
	return result;
    }


    //15 public instance methods
    
    //constructor
    public Student(String theFirstName, String theLastName, String theUid)
	{
	    Error.Assert(
			 (theFirstName != null),
			 "Student::Student(String, String, String): " +
			 "parameter firstName reference must not be null!");
	    
	    Error.Assert(
			 (theLastName != null),
			 "Student::Student(String, String, String): " +
			 "parameter lastName reference must not be null!");
	    
	    Error.Assert(
			 (!theFirstName.equals("")),
			 "Student::Student(String, String, String): " +
			 "parameter String cannot be empty String!");
	    
	    Error.Assert(
			 (!theLastName.equals("")),
			 "Student::Student(String, String, String): " +
			 "parameter String cannot be empty String!");
	    
	    Error.Assert(
			 (verifyUID(theUid)),
			 "Student::Student(String, String, String): " +
			 "parameter String UID  must be valid String!");
	    
	    firstName = theFirstName;
	    lastName = theLastName;
	    uid = theUid;
	    transcriptArray = new SemesterTranscript[0]; // size 0
	}
    
    
    //constructor
    public Student(Student origStudent)
	{
	    Error.Assert(
			 (origStudent != null),
			 "Student::Student(String): " +
			 "parameter origStudent reference must not be null!");
	    
	    //independent copy, initialize object to be copy of parameter object
	    firstName  = origStudent.firstName;
	    lastName = origStudent.lastName;
	    uid = origStudent.uid;
	    transcriptArray = new SemesterTranscript[origStudent.transcriptArray.length];
	    
	    for(int i=0; i < transcriptArray.length; i++)
		transcriptArray[i] = origStudent.transcriptArray[i].copy();

	}
    
    public Student copy()
	{
	    Student studentCopy =  new Student(this);
	    return studentCopy;
	}
    
    public String getFirstName()
	{
	    return firstName;
	}

    public String getLastName()
	{
	    return lastName;
	}

    public String getUID()
	{
	    return uid;
	}

    public boolean addCourse(SemesterPair semesterPair, String courseName, int credit)
	{
	    Error.Assert(
			 (semesterPair != null),
			 "Student::addCourse(SemesterPair, String, int): " +
			 "parameter SemesterPair semester reference must not be null!");

	    Error.Assert(
			 (courseName != null),
			 "Student::addCourse(SemesterPair, String, int): " +
			 "parameter String courseName reference must not be null!");

	    Error.Assert(
			 !(courseName.equals("")),
			 "Student::addCourse(SemesterPair, String, int): " +
			 "parameter String courseName reference must not be empty!");

	    Error.Assert(
			 (credit > 0),
			 "Student::addCourse(SemesterPair, String, int): " +
			 "parameter int credit reference must be positive!");

	    int loc = findSemester(semesterPair).index;

	    	

	    if(findSemester(semesterPair).isFound)
	       return transcriptArray[loc].addCourse(courseName, credit);
	       
	    SemesterTranscript[] temp = new SemesterTranscript[transcriptArray.length];
	    

	    if (transcriptArray.length == 0) {
		transcriptArray[loc] = new SemesterTranscript(semesterPair); 
		return transcriptArray[loc].addCourse(courseName, credit);
	    }
	    
	    for(int i=0; i < transcriptArray.length; i++)                                   
		temp[i] = transcriptArray[i];                                          
	    
	    transcriptArray = new SemesterTranscript[temp.length + 1]; 
	    
	    for(int i=0; i < loc; i++) 
		transcriptArray[i] = temp[i]; 
	    //my code ---------
            if (loc == temp.length)
            {
               transcriptArray[loc] = new SemesterTranscript(semesterPair); 
	       return transcriptArray[loc].addCourse(courseName, credit);
            }
            //end my code-----
	    for(int i=loc+1; i < transcriptArray.length; i++) 
		transcriptArray[i] = temp[i];  
	    
	    transcriptArray[loc] = new SemesterTranscript(semesterPair); 
	    return transcriptArray[loc].addCourse(courseName, credit);
	    
	}
    
    public boolean removeCourse(SemesterPair semesterPair, String courseName)
    {
	int loc = findSemester(semesterPair).index;

	if(!findSemester(semesterPair).isFound)
	    return false;
	

	// else semester is found

	if(transcriptArray[loc].getNumCourses() <= 0)
	    {
		
		SemesterTranscript[] temp = new SemesterTranscript[transcriptArray.length];
		
		for(int i=0; i < transcriptArray.length; i++)
		    temp[i] = transcriptArray[i];
		
		transcriptArray = new SemesterTranscript[temp.length - 1];
		
		for(int i=0; i < loc; i++)
		    transcriptArray[i] = temp[i];
		
		for(int i=loc+1; i < temp.length; i++)
		    transcriptArray[i-1] = temp[i];
		
		return true;
	    }

	return transcriptArray[loc].removeCourse(courseName);
	
    }




    
    public boolean setCourseGrade(SemesterPair semesterPair, String courseName, String newGrade)
	{
	    Error.Assert(
			 (semesterPair != null),
			 "Student::setCourseGrade(SemesterPair, String, String): " +
			 "parameter SemesterPair semester reference must not be null!");
	    Error.Assert(
			 (courseName != null),
			 "Student::setCourseGrade(SemesterPair, String, String): " +
			 "parameter String courseName reference must not be null!");

	    Error.Assert(
			 (newGrade != null),
			 "Student::setCourseGrade(SemesterPair, String, String): " +
			 "parameter String newGrade reference must not be null!");

	    Error.Assert(
			 (!courseName.equals("")),
			 "Student::setCourseGrade(SemesterPair, String, String): " +
			 "parameter String courseName reference must not be empty!");
	    
	    Error.Assert(
			 (GradeEntry.verifyGrade(newGrade)),
			 "Student::setCourseGrade(SemesterPair, String, String): " +
			 "parameter String newGrade reference must be valid grade!");

	    int loc = findSemester(semesterPair).index;

	    if(findSemester(semesterPair).isFound)
		return transcriptArray[loc].setCourseGrade(courseName, newGrade); // return true

	    //else
		return false;
	}

    public GradeResultPair getCourseGrade(SemesterPair semesterPair, String courseName)
	{
	    Error.Assert(
			 (semesterPair != null),
			 "Student::getCourseGrade(SemesterPair, String): " +
			 "parameter SemesterPair semesterPair reference must not be null!");

	    Error.Assert(
			 (courseName != null),
			 "Student::getCourseGrade(SemesterPair, String): " +
			 "parameter String courseName reference must not be null!");

	    Error.Assert(
			 (!courseName.equals("")),
			 "Student::getCourseGrade(SemesterPair, String): " +
			 "parameter String courseName reference must not be empty!");

	    int loc = findSemester(semesterPair).index;

	    if(findSemester(semesterPair).isFound)
		return transcriptArray[loc].getCourseGrade(courseName); // returns a GradeResultPair

	    //else return an empty, false GradeResultPair
	    GradeResultPair result = new GradeResultPair();
	    result.grade = "";
	    result.isFound = false;
	    return result;

	}

    public GPAResultPair getGPA()
    {
	double totalCredit = 0;
	double totalGrade = 0;
	double curGrade = 0;


	for(int i=0; i < transcriptArray.length; i++)
	    {
		for(int j=0; j < transcriptArray[i].getGradeEntries().length; j++)
		    {
			GradeEntry grd = transcriptArray[i].getGradeEntries()[j];

			if(grd.getCourseGrade() != "-")
			    totalCredit = totalCredit + grd.getCourseCredit();
			if(grd.getCourseGrade().charAt(0)=='A')
			    curGrade = 4;
			if(grd.getCourseGrade().charAt(0)=='B')
			    curGrade = 3;
			if(grd.getCourseGrade().charAt(0)=='C')
			    curGrade = 2;
			if(grd.getCourseGrade().charAt(0)=='D')
			    curGrade = 1;
			if(grd.getCourseGrade().charAt(0)=='F')
			    curGrade = 0;

			if(grd.getCourseGrade().length() == 2)
			    {
				if(grd.getCourseGrade().charAt(1)=='-')
				    curGrade -= .3;
				else if (grd.getCourseGrade().charAt(1)=='+')
				    curGrade += .3;
			    }

			totalGrade += curGrade;
		    }
	    }

	GPAResultPair gpa = new GPAResultPair();
	
	//all pending
	if(totalCredit <= 0)
	    {
		gpa.isLegitimateGPA = false;
		gpa.GPA = 0;
	    }
	else
	    {
		gpa.isLegitimateGPA = true;
		gpa.GPA = totalGrade/totalCredit;
	    }
	    
	return gpa;

    }

    public OutputData getCourseOutput(SemesterPair semesterPair, String courseName)
	{
	    Error.Assert(
			 (semesterPair != null),
			 "Student::getCourseOutput(SemesterPair, String): " +
			 "parameter SemesterPair semesterPair reference must not be null!");

	    Error.Assert(
			 (courseName != null),
			 "Student::getCourseOutput(SemesterPair, String): " +
			 "parameter String courseName reference must not be null!");
    
	    Error.Assert(
			 (!courseName.equals("")),
			 "Student::getCourseOutput(SemesterPair, String): " +
			 "parameter String courseName reference must not be empty!");

	    int loc = findSemester(semesterPair).index;
	    if(findSemester(semesterPair).isFound)
		return transcriptArray[loc].getCourseOutput(courseName);
	    
	    //else
	    return new OutputData(); //empty
	}

    public OutputData getSemesterOutput(SemesterPair semesterPair)
	{
	    Error.Assert(
			 (semesterPair != null),
			 "Student::getSemesterOutput(SemesterPair): " +
			 "parameter SemesterPair semesterPair reference must not be null!");

	     int loc = findSemester(semesterPair).index;
	    if(findSemester(semesterPair).isFound)
		return transcriptArray[loc].getOutput();
	    
	    //else
	    return new OutputData(); //empty, no lines
	}

    public OutputData getOutput()
	    {
		OutputData data = new OutputData();
		
		data.append(lastName);
		data.append(firstName);
		data.append(uid);
		
		for(int i=0; i < transcriptArray.length; i++)
		    data.append(transcriptArray[i].getOutput());
		
		return data;
		
	}

    public void write(WriteFile writeHandle)
    {
	    
	{
	    Error.Assert(
			 (writeHandle != null),
			 "Student::write(WriteFile): " +
			 "parameter WriteFile reference must not be null!");
		
	    Error.Assert(
			 !writeHandle.isClosed(),
			 "Student::write(writeFile): " +
			 "cannot write to a closed file!");
		
	    writeHandle.println(firstName); // String
	    writeHandle.println(lastName); //String
	    writeHandle.println(uid); //String
	    
	    writeHandle.println(transcriptArray.length); // number of transcripts Int
	    
	    // in each SemesterTranscript, array of SemesterPair (season, year)
	    for(int i=0; i < transcriptArray.length; i++)
		{

		    writeHandle.println(transcriptArray[i].getSemesterPair().getSeason()); // season String
		    writeHandle.println(transcriptArray[i].getSemesterPair().getYear()); // year Int
		    writeHandle.println(transcriptArray[i].getNumCourses()); // number of courses in this semester Int
		    
		    // in each SemesterPair, array of GradeEntry (name, grade, credit)
		    for(int j=0; j < transcriptArray[i].getNumCourses(); j++)
			{
			    writeHandle.println(transcriptArray[i].getGradeEntries()[j].getCourseName()); // String
			    writeHandle.println(transcriptArray[i].getGradeEntries()[j].getCourseCredit()); // Int
			    writeHandle.println(transcriptArray[i].getGradeEntries()[j].getCourseGrade()); // String
 			}
		    
		}
	}
	
    }    
    
    
    //two public class methods

    public static Student read(ReadFile readHandle)
    {
	
	Error.Assert(
		     (readHandle != null),
		     "Student::read(ReadFile): " +
		     "parameter ReadFile reference must not be null!");
	
	Error.Assert(
		     !readHandle.isClosed(),
		     "Student::read(readFile): " +
		     "cannot read from a closed file!");
	
	Student initStudent = new Student(readHandle.readString(), readHandle.readString(), readHandle.readString());
	int transcriptNum = readHandle.readInt();

	for(int i=0; i < transcriptNum; i++)
	    {
		SemesterPair semesterPair = new SemesterPair(readHandle.readString(), readHandle.readInt());
		int courseNum = readHandle.readInt();
		for(int j=0; j < courseNum; j++)
		    {
			String courseName = readHandle.readString();
			int credit = readHandle.readInt();
			String grade = readHandle.readString();
			initStudent.addCourse(semesterPair, courseName, credit);
			initStudent.setCourseGrade(semesterPair, courseName, grade);
		    }
	    }

	return initStudent;
    }

    public static boolean verifyUID(String uid)
	{
	    if(uid.length() == 9)
		{
		    for(int i=0; i < uid.length(); i++)
			{
			    if(!Character.isDigit(uid.charAt(i)))
				return false;
			}
		    return true;
		}
	    
	    //else not 9
	    return false;
	    
	}

}