import structure.*;
import com.mw.io.*;
import java.io.*;

// This program is a solution to lab 10 using the Vector as the 
// underlying data structure -- it works, but it's not very fast. 

public class Student implements Comparable {
  public int student_id;
  public int student_class;
  public int numDesired;         // no. of courses on first line of reg. card
  public int numChoices;         // total no. of courses listed on all lines
  public Vector student_choices; // course_names of all courses listed
  public int numEnrolled;        // no. of courses in which student is enrolled

  public Student() {
     student_id = 0;
     student_class = 0;
     numDesired = 0;             // number of courses on the first line of the card
     numChoices = 0;             // total number of courses provided on the card
     student_choices = new Vector();  //  vector of course choices
     numEnrolled = 0;
  }
  public boolean lessThan (Comparable other) {
    if (student_id < ((Student)other).student_id)
       return true;
    else return false;
  }
  public boolean equals (Student other) {
    if (student_id == other.student_id)
       return true;
    else return false;
  }
  public void display () {
    System.out.print(student_id+" "+student_class+" "+numDesired+" "+
         numChoices+" "+numEnrolled+" ");
    for (int i=0; i<student_choices.size(); i++)
         System.out.print(student_choices.elementAt(i) + " ");
    System.out.println();
  }
}

public class Course implements Comparable {
  public String course_name;
  public String course_times;
  public int capacity;
  public int enrollment = 0;            // initial values
  public int rejections = 0;
  public String same_as = "";
  public String title_instructor = "";

  public boolean lessThan (Comparable other) {
    char[] s = new char[10];
    char[] t = new char[10];
    boolean result = true;
    int i;
    String u = ((Course)other).course_name;
    course_name.getChars(0, course_name.length(), s, 0);
    u.getChars(0, u.length(), t, 0);
    for (i=0; i<10 && s[i]==t[i]; i++) {
       if (s[i] < t[i]) 
          break;
    }
    if (i>=10 || s[i] > t[i])
       result = false; 
    return result;
  }
  public boolean equals (Course other) {
    if (course_name.equals(other.course_name))
       return true;
    else return false;
  }
  public void display () {
    System.out.println(course_name+" "+course_times+" "+capacity+" "+
        enrollment+" "+rejections+" "+same_as+" "+title_instructor);
  }
  
  public void addToStats(Statistics stats, Vector conflicts) {
    int i;
    Conflict c = new Conflict();
    stats.num_courses++;
    for (i=0; i<conflicts.size(); i++) {
       c = (Conflict)(conflicts.elementAt(i));
       if ((c.a_time).equals(course_times))
          break;
    }
    if (i<conflicts.size()) 
       c.num_courses++;
    else {
       c = new Conflict();
       c.num_courses = 1;
       c.a_time = course_times;
    }
  }
}

public class Conflict {
  String a_time = "";
  int num_courses = 0;      // number of courses with this time
  int num_conflicts = 0;
  Vector conflicts = new Vector();
  
  public boolean equals(Conflict other) {
     if (a_time.equals(other.a_time))
        return true;
     else return false;
  }
  
  public void display() {
     System.out.print(a_time + " " + num_courses + " " + num_conflicts + " ");
     for (int i=0; i<num_conflicts; i++)
        System.out.print(conflicts.elementAt(i) + " ");
     System.out.println();
  }
  
}

public class Statistics {
  public int num_courses = 0;
  public int num_students = 0;
  public int[] wanting = {0,0,0,0,0};  // no. of students wanting 0, 1, 2, 3, and 4 courses
  public int[] getting = {0,0,0,0,0};  // no. of students getting 0, 1, 2, 3, and 4 courses
  public int time_rejections = 0;      // no. of rejections for time conflicts  
  public int capacity_rejections = 0;  // no. of rejections for class capacity exceeded
  public long load_time = 0;           // total milliseconds to load classes data structure
  public long register_time = 0;       // total milliseconds to register all students
 
}

public class Registerallen
{
    public static void displayStats(Vector courses, Statistics stats) {
       System.out.println("          Number of students");
       System.out.println("Course    Enrolled/Capacity/Rejected  Title");
       for (int i=0; i<courses.size(); i++) {
          Course c = (Course) courses.elementAt(i);
          if (c.same_as!="") {          // find the "same as" course's statistics in the vector
            for (int j=0; j<courses.size(); j++) {  
              Course a_course = (Course)courses.elementAt(j);
              if (c.same_as.equals(a_course.course_name)) {
                 c.enrollment = a_course.enrollment;
                 c.rejections = a_course.rejections;
                 break;
              }
            }
          }  
          System.out.println(c.course_name + "  " + c.course_times + " " + c.enrollment + " " + c.capacity + " " +
                             c.rejections + "      " + c.same_as + c.title_instructor);
       }
       System.out.println();
       System.out.println("Summary Statistics");
       System.out.println();              
       System.out.println("Total number of courses offered: " + stats.num_courses);
       System.out.println("Total number of students registering: " + stats.num_students);
       System.out.print("Number of students wanting ");
       for (int i=4; i>=0; i--)
          System.out.print(i + " = "  + stats.wanting[i] + "   ");
       System.out.println(" courses");
       System.out.print("Number of students getting ");
       for (int i=4; i>=0; i--)
          System.out.print(i + " = "  + stats.getting[i] + "   ");
       System.out.println(" courses");       
       System.out.println("Number of rejections for time conflicts: " + stats.time_rejections);
       System.out.println("Number of rejections for capacity exceeded: " + stats.capacity_rejections);       
    }
    
    public static void displayTimings(Statistics stats) {
       System.out.println();
       System.out.println("Run Time Statistics");
       System.out.println();       
       System.out.println("Time to load the course file: " + stats.load_time + " ms.");
       System.out.println("Time to register the students: " + stats.register_time + " ms.");
       System.out.println("Average time to register a student: " +
                           stats.register_time/stats.num_students + " ms.");
       long t = stats.load_time + stats.register_time;
       System.out.println("Total run time: " + t + " ms.");           
    }

    public static boolean hasConflict(String course_times, 
                                      Vector times_received, Vector conflicts) {
       // see if the times of a course is in conflict with any of the times 
       // for courses the student has already received.
       boolean result = false;
       int i, j;
       Conflict c = new Conflict();
       for (j=0; j<conflicts.size(); j++) {
           c = (Conflict)conflicts.elementAt(j);
           if ((c.a_time).equals(course_times))
              break;
       }
       if (j<conflicts.size()) {   // found that time in the table; check for conflicts
          for (i=0; i<times_received.size(); i++) {  // with other courses' times
              Conflict d = new Conflict();
              d.a_time = (String)times_received.elementAt(i);
              if (c.a_time.equals(d.a_time)) {
                 result = true;
              }
              else {
                 for (j=0; j<(c.conflicts).size(); j++) 
                     if (((String)(c.conflicts).elementAt(j)).equals(d.a_time)) {
                        result = true;
                        break;
                     }
              }
              if (result) return result;  // only need to find one conflicting time
          }
       }
       return result;      
    }
    
    public static void getCourse (ReadStream r, Course a_course) {
       a_course.course_name = r.readString() + r.readString();
       a_course.course_times = r.readString();
       a_course.capacity = r.readInt();
       a_course.same_as = r.readLine();
       if (((a_course.same_as).substring(0,1)).equals("="))
          a_course.same_as = strip((a_course.same_as).substring(2));
       else {
          a_course.title_instructor = a_course.same_as;
          a_course.same_as = "";
       }       
    }

    public static void getCard (ReadStream r, Student a_card) {
       a_card.student_id = r.readInt();
       a_card.student_class = r.readInt();
       a_card.numDesired = r.readInt();
       a_card.numChoices = r.readInt();
       a_card.student_choices.clear();   // clear previous student's choices
       for (int i=0; i<a_card.numChoices; i++)
          (a_card.student_choices).addElement(r.readString() + r.readString());      
    }
    
    public static void getConflict (ReadStream r, Conflict t) {
       t.a_time = r.readString();
       t.num_conflicts = r.readInt();
       for (int i=0; i<t.num_conflicts; i++)
          (t.conflicts).addElement(r.readString());
    }
    
    public static String strip (String s) {
       String t = "";
       for (int i=0; i<s.length(); i++)
         if (s.charAt(i)!=' ')
            t = t + s.charAt(i);
       return t;
    }
    
    public static void Register(Student a_card, Vector courses, 
                                Vector conflicts, Statistics stats) {
       int i, j;
       Course a_course = new Course();
       Vector times_received = new Vector();  // keep track of the times of
                                              // the courses this student received
       int num_received = 0;                  // and the number of courses received
       for (i=0; i<a_card.numDesired; i++) {
          String a_name = (String)((a_card.student_choices).elementAt(i));
          for (j=0; j<courses.size(); j++) {  // find the course in the vector
              a_course = (Course)courses.elementAt(j);
              if (a_name.equals(a_course.course_name))
                 break;
          }
          if (j>=courses.size()) break;       // course not offered; try next choice
          
          // check for "same as" course 
          if (a_course.same_as!="") {
            a_name = a_course.same_as;
            for (j=0; j<courses.size(); j++) {  // find the "same as" course in the vector
              a_course = (Course)courses.elementAt(j);
              if (a_name.equals(a_course.course_name))
                 break;
            }
          }  
          a_course = (Course) courses.elementAt(j);  
          if (hasConflict(a_course.course_times, times_received, conflicts)) {
              // check for conflicts
              a_course.rejections++;
              stats.time_rejections++;
          }
          else if (a_course.capacity == a_course.enrollment) {
              // check for course full
              a_course.rejections++;
              stats.capacity_rejections++;
          }
          else  {                            // add this student to the course
              times_received.addElement(a_course.course_times);
              num_received++;
              a_course.enrollment++;         // update the course enrollment
          }
          courses.setElementAt(a_course, j);  // and put updated course back       
       }
       stats.wanting[a_card.numDesired]++;        // update statistics
       stats.getting[times_received.size()]++;
    }

    public static void main(String args[])
    {
    long t1 = System.currentTimeMillis();     // starting time

    Vector courses = new Vector();     // course data structure; temporarily a Vector
    Course a_course;
    Vector conflicts = new Vector();   // time conflicts data structure
    Conflict a_time;     
    Student a_card = new Student();                       
    // a single student's registration card
    Statistics stats = new Statistics();  // totals needed as cards are processed
    String line_in;
 	
// load the time conflicts 
	try {
        InputStream times = new FileInputStream("times.data");
      	ReadStream r = new ReadStream(times);
	    a_time = new Conflict();       // create a new time slot record
	    getConflict(r, a_time);            
	while ( !r.eof() )
	{
	    conflicts.addElement(a_time);
	    a_time = new Conflict();       // create a new time slot record
	    getConflict(r, a_time);            
	}
	r.close();
	} catch (IOException e) {
	   System.err.println(e);
	   return;
	}
	System.out.println("Conflict data structure loaded");
	
// load the course data structure
	try {
        InputStream classes = new FileInputStream("classes.data");
      	ReadStream r = new ReadStream(classes);
        System.out.println("Here are the first few courses...");
	    a_course = new Course();           // create a new course record
	    getCourse(r, a_course);            
	while ( !r.eof() )
	{
	    courses.addElement(a_course);
	    if (stats.num_courses < 30)    // display the first 30 courses
	       a_course.display();
	    // a_course.addToStats(stats, conflicts); // account for this course
	    stats.num_courses++;           // increase the course count
	    a_course = new Course();       // create a new course record
	    getCourse(r, a_course);            
	}
	r.close();
	} catch (IOException e) {
	   System.err.println(e);
	   return;
	}
	System.out.println("Course data structure loaded");

    long t2 = System.currentTimeMillis();  // t2 - t1 is load time
	
    System.out.println("Here are the time blocks and conflicts...");
    for (int i=0; i<conflicts.size(); i++) {
        a_time = (Conflict)conflicts.elementAt(i);
        a_time.display();
    }

// read student records, one at a time, and register each one.
// keep statistics as you go.
    try {
        InputStream cards = new FileInputStream("cards.data");
      	ReadStream r = new ReadStream(cards);
        System.out.println("Here are the first few student cards...");
	    getCard(r, a_card);            
	// process each student card
   	while ( !r.eof() )
	{   
	    Register(a_card, courses, conflicts, stats); // now register the student
	    if (stats.num_students < 30)     // display the first 30 students
	       a_card.display();
	    stats.num_students++;            // increase the student count
	    getCard(r, a_card);              // and get the next card
	}
	r.close();
	} catch (IOException e) {
	   System.err.println(e);
	   return;
	}
	System.out.println("Student registration cards processed");
	
    long t3 = System.currentTimeMillis();  // t3 - t2 is registration time
    stats.load_time = t2 - t1;
    stats.register_time = t3 - t2;
    	
    displayStats(courses, stats);   // show final course enrollments and statistics
    displayTimings(stats);          // display run times  

}
}