/*                  CSC 17 OOP Assignment (lab 5)

	           Due one week from date assigned

  A programmer who thinks that he knows Java and object oriented programming
was asked to write a program to keep track of students at a university.
There are two kinds of students: grads and undergrads.  All students have a
name and a gpa and take a certain number of credit hours.  Graduate students
have a thesis topic while undergraduates have a major.  The algorithm
to compute the tuition for grads is also different from that for undergrads.
Our programmer created the following program.  Not only is it not really
object oriented (no meaningful use of dynamic dispatch), but because he 
relied on too many if and if-else statements, there is a mistake in the 
program (can you figure out where?)

Your task is to rewrite the program using an abstract class and inheritance
and take advantage of dynamic dispatch.  

First, study the program to understand how it works and what it's supposed
to do.  Be sure to run it to see what happens.  Then follow the instructions 
in comments at the end.
*/

class student
{
    public final String name;
    protected boolean isgraduate = false; // is this student a grad student?
    protected double gpa;
    protected int credits; // number of credit hours taken
    protected String major=null; // used only for undergraduates
    protected String thesistopic=null; // used only for graduates
    public boolean isgraduate() { return isgraduate;}

    static String[] mjs= {"comp sci", "poly sci", "engineering", "math", "physics","biology","psychology", "history", "leisure studies"};
    static String[] topics = {"p equals np", "halting problem", "distributed os", "real time fault tolerance", "compiler design", "cryptography", "machine learning"};
    
    // constructor takes name and graduate/undergrad flag, randomizes rest
    public student(String n, boolean g)
    {
	name = n;
	isgraduate = g;
	gpa = ((int)(Math.random()*401))/100.0; // set random gpa
	credits = 3 + (int)(Math.random()*15); //number of credits being taken
	if (isgraduate) 
	    thesistopic = topics[(int)(Math.random()*topics.length)];
	else
	    major = mjs[(int)(Math.random()*mjs.length)];
    }//student constructor

    // compute tuition: undergrads pay $1200 per credit, grads pay $1600
    public double tuition()
    {
	if (isgraduate) return 1600*credits;
	else return 1200*credits;
    }
}// student class


public class stu1
{
    public static void main(String[] argv)
    {
	String[] names = {"Matthew","Taiga","Michael","Stefan","Piper","Jules","Ahmed","Christopher","Ricky","Yonghyeon","Dylan","Peyton","Tito","Kevin","Max","Nishad","David","Justin"};
	student[] roster = new student[names.length];
	// create random roster of students, alternating between grads and
	// undergrads
	for(int i=0;i<roster.length-1;i+=2)
	    {
		roster[i] = new student(names[i],true);  // grad
		roster[i+1] = new student(names[i+1],false); //undergrad
	    }
	//compute total tuition of all students
	double total = 0;
	for(student s:roster) total += s.tuition();
	System.out.println("total tution is "+total);

    // undergrad students with gpa < 2.0 are on academic probation,
    // while grad students with gpa < 3.0 are also on academic probation.
    // the following loop prints names of all students on probation, plus
    // some additional information about each student:
	for(student s:roster)
	    {
		if (!s.isgraduate() && s.gpa<2.0)
		    System.out.println("Undergraduate student "+s.name+", majoring in "+s.major+", has an amazingly low gpa of "+s.gpa);
		else if (s.gpa < 3.0)
		    System.out.println("Graduate student "+s.name+", who is writing a thesis on "+s.thesistopic+", has a gpa of only " + s.gpa);
	    }
    }//main
}

/*
   There are many ways in which this program can be improved.  For example,
every student object contains both a major and a thesis topic.  Not only
does this waste memory but it would be possible for a programmer to 
accidentally refer to the thesis topic of an undergraduate, or the
major of a graduate student, which would be a *type error* that the 
compiler will not be able to catch.

The code to find students on academic probation in main should also
be *encapsulated* within the objects ("let objects decide for themselves").

=======YOUR ASSIGNMENT: =======

You need to restructure the program using a more advanced "object
oriented design."  You must use an abstract class in your design.  One
of the goals you should have in your new program is to **minimize**
the use of if and if-else statements (no more than a couple). You will
have to come up with your own object oriented design (i.e. what
methods to declare in the abstract class).

1. Rewrite the main from the sample program using your new oop design.

***YOU MAY USE AT MOST 2 IF STATEMENTS IN THE PROGRAM (only when you're 
testing if a numerical value is less than 2.0 or 3.0).

2. Add a new type of student to your design, without changing the design (i.e.
add only a subclass). Think of something like "nonmatriculated student"
or "weird student" with unique attributes that distinguish them
from grads and undergrads.  The class can also be a sub-subclass, such
as a "studentathlete" that's a subclass of "undergrad".
*/