MULTI JAVA

@Stateless
public class SchoolServiceBean implements SchoolServiceLocal {

    @PersistenceContext(unitName = "MyPU")
    private EntityManager em;

    // ================= STUDENTS =================
    @Override
    public Students createStudent(Students student) {
        List<Courses> courses = resolveCourses(student);
        student.setCourses(courses);
        courses.forEach(c -> c.getStudents().add(student));

        em.persist(student);
        return student;
    }

    @Override
    public Students updateStudent(Students student) {
        Students existing = em.find(Students.class, student.getStudentId());
        if (existing == null) return null;

        existing.setStudentName(student.getStudentName());
        existing.setEmail(student.getEmail());

        // Clear old relation
        existing.getCourses().forEach(c -> c.getStudents().remove(existing));
        existing.getCourses().clear();

        // Add new relation
        List<Courses> updatedCourses = resolveCourses(student);
        existing.getCourses().addAll(updatedCourses);
        updatedCourses.forEach(c -> c.getStudents().add(existing));

        return existing;
    }

    @Override
    public void deleteStudent(Integer id) {
        Students st = em.find(Students.class, id);
        if (st != null) {
            st.getCourses().forEach(c -> c.getStudents().remove(st));
            st.getCourses().clear();
            em.remove(st);
        }
    }

    @Override
    public Students findStudentById(Integer id) {
        return em.find(Students.class, id);
    }

    @Override
    public List<Students> findAllStudents() {
        return em.createQuery("FROM Students", Students.class).getResultList();
    }


    // ================= COURSES =================
    @Override
    public Courses createCourse(Courses course) {
        List<Students> students = resolveStudents(course);
        course.setStudents(students);
        students.forEach(s -> s.getCourses().add(course));

        em.persist(course);
        return course;
    }

    @Override
    public Courses updateCourse(Courses course) {
        Courses existing = em.find(Courses.class, course.getCourseId());
        if (existing == null) return null;

        existing.setCourseName(course.getCourseName());
        existing.setCredits(course.getCredits());

        existing.getStudents().forEach(s -> s.getCourses().remove(existing));
        existing.getStudents().clear();

        List<Students> updatedStudents = resolveStudents(course);
        existing.getStudents().addAll(updatedStudents);
        updatedStudents.forEach(s -> s.getCourses().add(existing));

        return existing;
    }

    @Override
    public void deleteCourse(Integer id) {
        Courses c = em.find(Courses.class, id);
        if (c != null) {
            c.getStudents().forEach(s -> s.getCourses().remove(c));
            c.getStudents().clear();
            em.remove(c);
        }
    }

    @Override
    public Courses findCourseById(Integer id) {
        return em.find(Courses.class, id);
    }

    @Override
    public List<Courses> findAllCourses() {
        return em.createQuery("FROM Courses", Courses.class).getResultList();
    }


    // ===== Helper: Resolve collections =====
    private List<Courses> resolveCourses(Students student) {
        return student.getCourses().stream()
                .map(c -> em.find(Courses.class, c.getCourseId()))
                .toList();
    }

    private List<Students> resolveStudents(Courses course) {
        return course.getStudents().stream()
                .map(s -> em.find(Students.class, s.getStudentId()))
                .toList();
    }
}