StudentManagementSystem.java

import java.nio.charset.StandardCharsets;
import java.util.*;
import java.io.*;

// Core class responsible for managing students, courses, departments, and programs
public class StudentManagementSystem {
    // Stores students by their ID
    private Map<String, Student> students;
    // Stores academic members  by their ID
    private Map<String, AcademicMember> academicMembers;
    // Stores courses by their code
    private Map<String, Course> courses;
    // Stores departments by their code
    private Map<String, Department> departments;
    // Stores academic programs by their code
    private Map<String, Program> programs;

    // Initializes all entity maps with insertion order preserved
    public StudentManagementSystem() {
        students = new LinkedHashMap<>();
        academicMembers = new LinkedHashMap<>();
        courses = new LinkedHashMap<>();
        departments = new LinkedHashMap<>();
        programs = new LinkedHashMap<>();
    }

    // Loads student and academic member records from a file
    public void loadPersons(String filename, BufferedWriter writer) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), StandardCharsets.UTF_8));
        String line;
        while ((line = reader.readLine()) != null) {
            String[] parts = line.split(",");
            String type = parts[0].trim();
            String id = parts[1].trim();
            String name = parts[2].trim();
            String email = parts[3].trim();
            String department = parts[4].trim();

            try {
                if (!type.equals("S") && !type.equals("F")) {
                    throw new ExceptionManager.InvalidPersonTypeException(type);
                }
                if (type.equals("S")) {
                    students.put(id, new Student(id, name, email, department));
                } else {
                    academicMembers.put(id, new AcademicMember(id, name, email, department));
                }
            } catch (ExceptionManager.InvalidPersonTypeException e) {
                writer.write(e.getMessage() + "\n");
            }
        }
        reader.close();
    }

    // Loads departments and assigns heads if available
    public void loadDepartments(String filename, BufferedWriter writer) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), StandardCharsets.UTF_8));
        String line;
        while ((line = reader.readLine()) != null) {
            try {
                String[] parts = line.split(",");
                String code = parts[0].trim();
                String name = parts[1].trim();
                String description = parts[2].trim();
                String headId = parts[3].trim();
                Department department = new Department(code, name, description);

                if (academicMembers.containsKey(headId)) {
                    department.setHead(academicMembers.get(headId));
                } else {
                    writer.write(new ExceptionManager.NonExistentAcaMemberException(headId).getMessage() + "\n");
                }
                departments.put(code, department);
            } catch (Exception e) {
                writer.write("An error occurred while reading department line: " + e.getMessage() + "\n");
            }
        }
        reader.close();
    }

    // Loads programs and verifies department names
    public void loadPrograms(String filename, BufferedWriter writer) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), StandardCharsets.UTF_8));
        String line;
        while ((line = reader.readLine()) != null) {
            String[] parts = line.split(",");
            try {
                String code = parts[0].trim();
                String name = parts[1].trim();
                String departmentName = parts[3].trim();
                String degreeLevel = parts[4].trim();
                int requiredCredits = Integer.parseInt(parts[5].trim());
                Department department = null;

                for (Department dept : departments.values()) {
                    if (dept.getName().equalsIgnoreCase(departmentName)) {
                        department = dept;
                        break;
                    }
                }

                if (department == null) {
                    throw new ExceptionManager.NonExistentDeptException(departmentName);
                }

                programs.put(code, new Program(code, name, departmentName, degreeLevel, requiredCredits));
            } catch (Exception e) {
                writer.write(e.getMessage() + "\n");
            }
        }
        reader.close();
    }

    // Loads courses, validates department and optional program
    public void loadCourses(String filename, BufferedWriter writer) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), StandardCharsets.UTF_8));
        String line;
        while ((line = reader.readLine()) != null) {
            String[] parts = line.split(",");
            try {
                String code = parts[0].trim();
                String name = parts[1].trim();
                String departmentName = parts[2].trim();
                int credits = Integer.parseInt(parts[3].trim());
                String semester = parts[4].trim();
                String programCode = parts.length > 5 ? parts[5].trim() : null;
                Department department = null;

                for (Department d : departments.values()) {
                    if (d.getName().equalsIgnoreCase(departmentName)) {
                        department = d;
                        break;
                    }
                }

                if (department == null) {
                    throw new ExceptionManager.NonExistentDeptException(departmentName);
                }
                if (programCode != null && !programs.containsKey(programCode)) {
                    throw new ExceptionManager.NonExistentProgException(programCode);
                }

                Course course = new Course(code, name, departmentName, credits, semester, programCode);
                courses.put(code, course);

                if (programCode != null) {
                    programs.get(programCode).addCourse(course);
                }
            } catch (Exception e) {
                writer.write(e.getMessage() + "\n");
            }
        }
        reader.close();
    }

    // Loads course assignments
    public void loadAssignments(String filename, BufferedWriter writer) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), StandardCharsets.UTF_8));
        String line;
        while ((line = reader.readLine()) != null) {
            String[] parts = line.split(",");
            try {
                String type = parts[0].trim();
                String id = parts[1].trim();
                String courseCode = parts[2].trim();

                if (type.equals("S") && !students.containsKey(id)) {
                    throw new ExceptionManager.NonExistentStudentException(id);
                }
                if (type.equals("F") && !academicMembers.containsKey(id)) {
                    throw new ExceptionManager.NonExistentAcaMemberException(id);
                }
                if (!courses.containsKey(courseCode)) {
                    throw new ExceptionManager.NonExistentCourseException(courseCode);
                }

                Course course = courses.get(courseCode);

                if (type.equals("S")) {
                    Student student = students.get(id);
                    course.enrollStudent(student);
                    student.enrollCourse(course);
                } else if (type.equals("F")) {
                    AcademicMember acaMem = academicMembers.get(id);
                    course.assignInstructor(acaMem);
                    acaMem.assignCourse(course);
                }
            } catch (Exception e) {
                writer.write(e.getMessage() + "\n");
            }
        }
        reader.close();
    }

    // Loads and assigns grades to students for specific courses
    public void loadGrades(String filename, BufferedWriter writer) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(filename), StandardCharsets.UTF_8));
        String line;
        while ((line = reader.readLine()) != null) {
            String[] parts = line.split(",");
            try {
                String grade = parts[0].trim();
                String studentId = parts[1].trim();
                String courseCode = parts[2].trim();

                if (!students.containsKey(studentId)) {
                    throw new ExceptionManager.NonExistentStudentException(studentId);
                }
                if (!courses.containsKey(courseCode)) {
                    throw new ExceptionManager.NonExistentCourseException(courseCode);
                }
                if (!GradeConverter.isValidGrade(grade)) {
                    throw new ExceptionManager.InvalidGradeException(grade);
                }

                Course course = courses.get(courseCode);
                Student student = students.get(studentId);
                course.assignGrade(student, grade);
                student.assignGrade(course, grade);
            } catch (Exception e) {
                writer.write(e.getMessage() + "\n");
            }
        }
        reader.close();
    }

    // Generates and writes summary and detailed reports to the writer
    public void writeOutput(BufferedWriter writer) throws IOException {
        // Academic Members
        writer.write("----------------------------------------\n");
        writer.write("            Academic Members\n");
        writer.write("----------------------------------------\n");
        for (AcademicMember acaMem : academicMembers.values()) {
            writer.write("Faculty ID: " + acaMem.getId() + "\n");
            writer.write("Name: " + acaMem.getName() + "\n");
            writer.write("Email: " + acaMem.getEmail() + "\n");
            writer.write("Department: " + acaMem.getDepartment() + "\n\n");
        }
        writer.write("----------------------------------------\n\n");

        // Students
        writer.write("----------------------------------------\n");
        writer.write("                STUDENTS\n");
        writer.write("----------------------------------------\n");
        for (Student student : students.values()) {
            writer.write(student.generateReport());
        }
        writer.write("----------------------------------------\n\n");

        // Departments
        writer.write("---------------------------------------\n");
        writer.write("              DEPARTMENTS\n");
        writer.write("---------------------------------------\n");
        for (Department dept : departments.values()) {
            writer.write(dept.generateReport());
        }
        writer.write("----------------------------------------\n\n");

        // Programs
        writer.write("--------------------------------------\n");
        writer.write("                PROGRAMS\n");
        writer.write("---------------------------------------\n");
        List<Program> programList = new ArrayList<>(programs.values());
        programList.sort(Comparator.comparing(Program::getCode));
        for (Program prog : programList) {
            writer.write(prog.generateReport());
        }
        writer.write("----------------------------------------\n\n");

        // Courses
        writer.write("---------------------------------------\n");
        writer.write("                COURSES\n");
        writer.write("---------------------------------------\n");
        List<Course> courseList = new ArrayList<>(courses.values());
        courseList.sort(Comparator.comparing(Course::getCode));
        for (Course course : courseList) {
            writer.write("Course Code: " + course.getCode() + "\n");
            writer.write("Name: " + course.getName() + "\n");
            writer.write("Department: " + course.getDepartment() + "\n");
            writer.write("Credits: " + course.getCredits() + "\n");
            writer.write("Semester: " + course.getSemester() + "\n\n");
        }
        writer.write("----------------------------------------\n\n");

        // Course Reports
        writer.write("----------------------------------------\n");
        writer.write("             COURSE REPORTS\n");
        writer.write("----------------------------------------\n");
        List<Course> sortedCourseList = new ArrayList<>(courses.values());
        sortedCourseList.sort(Comparator.comparing(Course::getCode));
        for (int i = 0; i < sortedCourseList.size(); i++) {
            Course c = sortedCourseList.get(i);
            writer.write(c.generateReport());
            writer.write(i == sortedCourseList.size() - 1
                    ? "\n\n----------------------------------------"
                    : "\n----------------------------------------\n\n");
        }

        // Student Reports
        writer.write("\n\n----------------------------------------\n");
        writer.write("            STUDENT REPORTS\n");
        writer.write("----------------------------------------\n");
        List<Student> allStudents = new ArrayList<>(students.values());
        for (int i = 0; i < allStudents.size(); i++) {
            Student s = allStudents.get(i);
            writer.write(s.generateDetailedReport());
            writer.write(i == allStudents.size() - 1
                    ? "\n\n----------------------------------------"
                    : "\n----------------------------------------\n\n");
        }
    }
}