Clyde/backend/src/main/java/ovh/herisson/Clyde/EndPoints/CourseController.java

package ovh.herisson.Clyde.EndPoints;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import ovh.herisson.Clyde.Repositories.CurriculumCourseRepository;
import ovh.herisson.Clyde.Responses.UnauthorizedResponse;
import ovh.herisson.Clyde.Services.*;
import ovh.herisson.Clyde.Tables.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
@CrossOrigin(originPatterns = "*", allowCredentials = "true")
public class CourseController {

    private final CourseService courseServ;

    private final TeacherCourseService teacherCourseServ;

    private final AuthenticatorService authServ;

    private final UserService userService;

    private final CurriculumService curriculumService;

    private final UserCurriculumService userCurriculumService;

    private final CurriculumCourseRepository curriculumCourseRepository;
    private final CurriculumCourseService curriculumCourseService;
    public CourseController(CourseService courseServ, TeacherCourseService teacherCourseServ, AuthenticatorService authServ, UserService userService, CurriculumService curriculumService, UserCurriculumService userCurriculumService, CurriculumCourseRepository curriculumCourseRepository, CurriculumCourseService curriculumCourseService) {
        this.courseServ = courseServ;
        this.teacherCourseServ = teacherCourseServ;
        this.authServ = authServ;
        this.userService = userService;
        this.curriculumService = curriculumService;
        this.userCurriculumService = userCurriculumService;
        this.curriculumCourseRepository = curriculumCourseRepository;
        this.curriculumCourseService = curriculumCourseService;
    }

    @GetMapping("/course/{id}")
    public ResponseEntity<HashMap<String,Object>> getCourse(@RequestHeader("Authorization") String token, @PathVariable long id){
        if (authServ.getUserFromToken(token) == null)
            return new UnauthorizedResponse<>(null);

        Course foundCourse = courseServ.findById(id);

        if (foundCourse == null)
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);

        return new ResponseEntity<>(ProtectionService.courseWithoutPassword(foundCourse), HttpStatus.OK);
    }

    @GetMapping("/courses")
    public ResponseEntity<Iterable<HashMap<String,Object>>> getAllCourses(@RequestHeader("Authorization") String token){
        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary},token))
            return new UnauthorizedResponse<>(null);

        return new ResponseEntity<>(ProtectionService.coursesWithoutPasswords(courseServ.findAll()),HttpStatus.OK);
    }

    @GetMapping("/courses/owned")
    public ResponseEntity<Iterable<HashMap<String ,Object>>> getOwnedCourses(@RequestHeader("Authorization") String token){
        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher},token))
            return new UnauthorizedResponse<>(null);

        return new ResponseEntity<>(ProtectionService.coursesWithoutPasswords(courseServ.findOwnedCourses(authServ.getUserFromToken(token))),HttpStatus.OK);
    }

    @GetMapping("/course/{id}/assistants")
    public ResponseEntity<Iterable<HashMap<String,Object>>> getCourseAssistants(@RequestHeader("Authorization")String token, @PathVariable long id){
        if (authServ.getUserFromToken(token) == null)
            return new UnauthorizedResponse<>(null);

        Iterable<User> assistants = teacherCourseServ.findCourseAssistants(courseServ.findById(id));

        return new ResponseEntity<>(ProtectionService.usersWithoutPasswords(assistants),HttpStatus.OK);
    }


    @PostMapping("/course/curriculum/{id}")
    public ResponseEntity<Map<String ,Object>> postCourse(@RequestHeader("Authorization") String token,
                                             @RequestBody Course course,@PathVariable long id)
    {
        if (authServ.isNotIn(new Role[]{Role.Secretary,Role.Admin},token))
            return new UnauthorizedResponse<>(null);
        Course createdCourse = courseServ.save(course);
        Curriculum curriculum = curriculumService.findById(id);
        if (createdCourse == null || curriculum == null)
            return new ResponseEntity<>(null,HttpStatus.BAD_REQUEST);
        CurriculumCourse curriculumCourse = new CurriculumCourse(curriculum,course);
        curriculumCourseService.save(curriculumCourse);
        return new ResponseEntity<>(ProtectionService.courseWithoutPassword(createdCourse), HttpStatus.CREATED);
    }


    @PatchMapping("/course/{id}")
    public ResponseEntity<Course> patchCourse(@RequestHeader("Authorization") String token,
                                              @RequestBody Map<String,Object> updates,
                                              @PathVariable long id)
    {

        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Teacher,Role.Secretary}, token))
            return new UnauthorizedResponse<>(null);



        if (!courseServ.modifyData(id, updates, authServ.getUserFromToken(token).getRole()))
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);

        return new ResponseEntity<>(HttpStatus.OK);
    }

    @PostMapping("/course/{id}")
    public ResponseEntity<String> postTeachers(@RequestHeader("Authorization") String token,
                                               @RequestBody Iterable<Long> teacherIds,
                                               @PathVariable Long id)
    {

        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary}, token))
            return new UnauthorizedResponse<>(null);


        if (!teacherCourseServ.saveAll(teacherIds,courseServ.findById(id)))
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);

        return new ResponseEntity<>(HttpStatus.OK);
    }


    @DeleteMapping("course/{id}")
    public ResponseEntity<String> deleteUser(@RequestHeader("Authorization") String token, @PathVariable Long id){
        if (authServ.isNotIn(new Role[]{Role.Admin,Role.Secretary}, token))
            return new UnauthorizedResponse<>(null);

        Course toDelete = courseServ.findById(id);

        if (toDelete == null)
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);


        courseServ.delete(courseServ.findById(id));
        return new ResponseEntity<>(HttpStatus.OK);
    }


    //Get all the courses followed by an user
    @GetMapping("/usercourses")
    public ResponseEntity<List<Course>> getAllUserCourses(@RequestHeader("Authorization") String token){
        User u = authServ.getUserFromToken(token);

        //We get all the actual curriculums of the user
        List<UserCurriculum> userCurricula = userCurriculumService.findByStudentAndActual(u, true);
        List<Course> toReturn = new ArrayList<>();

        //We iterate through all the curriculums and we extract the courses
        for (int i = 0; i < userCurricula.size(); i++){
            curriculumCourseRepository.findCoursesByCurriculum(userCurricula.get(i).getCurriculum()).forEach((item) -> {
                //We need this to eliminate clones because a course can belong to several curriculums
                if(!toReturn.contains(item)){
                    toReturn.add(item);
                }
            });
        }

        return new ResponseEntity<>(toReturn, HttpStatus.OK);
    }


}