bla

package de.teamzhang.controller;

import com.mongodb.*;
import com.mongodb.util.JSON;
import de.teamzhang.model.*;
import de.teamzhang.repository.UserRepository;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.view.RedirectView;

import javax.servlet.http.HttpServletRequest;
import java.io.*;
import java.util.ArrayList;
import java.util.Base64;
import java.util.Collections;
import java.util.List;

@Controller
public class AdminController {

    @Autowired
    private UserRepository userRepository;

    @Autowired
    private MongoTemplate mongoTemplate;

    @Autowired
    private PasswordEncoder passwordEncoder;


    @GetMapping(value="/me")
    public @ResponseBody User getMe()
    {
        Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
        SecUserDetails userDetails = (SecUserDetails) authentication.getPrincipal();

        User user = userDetails.getUser();
        user.setPassword("");
        user.setId(null);

        return user;
    }

    @GetMapping(value = "/user/{mail}")
    public @ResponseBody User getUser(@PathVariable String mail)  {

        String sMail =  "";

        try
        {
            byte[] bMail = Base64.getDecoder().decode(mail);
            sMail = new String(bMail, "UTF-8");
        }
        catch(UnsupportedEncodingException uee)
        {
            uee.printStackTrace();
        }

        User user = userRepository.findByMail(sMail);

        if(user == null)
            return new User();


        user.setPassword("");
        user.setId(null);
        return user;
    }

    @GetMapping(value = "/users")
    public @ResponseBody List<User> getUsers() {

        List<User> usersList = userRepository.findAll();

        if(usersList.isEmpty())
            return new ArrayList<>();


        for(User user : usersList) {
            user.setPassword("");
            user.setId(null);
        }

        return usersList;
    }

    @PostMapping(value = "/createUser")
    public ResponseEntity<String> createUser(@RequestBody String body) {

        JSONParser parser = new JSONParser();
        JSONObject json = new JSONObject();

        try
        {
            json = (JSONObject) parser.parse(body);
        }
        catch (ParseException e)
        {
            e.printStackTrace();
        }

        String firstName = (String) json.get("firstName");
        String lastName = (String) json.get("lastName");
        int role = Integer.valueOf((String) json.get("role"));
        String mail = (String) json.get("mail");
        String password = (String) json.get("password");

        User user = new User();
        user.setUsername(mail);
        user.setFirstName(firstName);
        user.setLastName(lastName);
        user.setRole(role);
        user.setMail(mail);
        user.setPassword(passwordEncoder.encode(password));

        if(userRepository.findByMail(user.getMail()) != null)
        {
            return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
        }
        else
        {
            mongoTemplate.insert(user, "user");

            // check if user was inserted
            if(userRepository.findByMail(user.getMail()) != null)
                return new ResponseEntity<String>(HttpStatus.OK);
            else
                return new ResponseEntity<String>(HttpStatus.CONFLICT);         // TODO corect code ?
        }
    }


    @DeleteMapping(value = "/users/{mail}")
    public ResponseEntity<String> deleteUser(@PathVariable String mail) {

        String sMail =  "";

        try
        {
            byte[] bMail = Base64.getDecoder().decode(mail);
            sMail = new String(bMail, "UTF-8");
        }
        catch(UnsupportedEncodingException uee)
        {
            uee.printStackTrace();
        }

        if(userRepository.findByMail(sMail) == null)
        {
            return new ResponseEntity<String>(HttpStatus.NO_CONTENT);
        }
        else
        {
            BasicDBObject query = new BasicDBObject();
            query.put("mail", sMail);
            mongoTemplate.getCollection("user").remove(query);


            if(userRepository.findByMail(sMail) == null)
                return new ResponseEntity<String>(HttpStatus.OK);
            else
                return new ResponseEntity<String>(HttpStatus.CONFLICT);
        }
    }

    @GetMapping(value = "/courses")
    public @ResponseBody List<JSONObject> getCourses()
    {
        List<JSONObject> courseDescriptions = new ArrayList<>();

        DBCursor cursor = mongoTemplate.getCollection("coursesDescription").find();

        while(cursor.hasNext())
        {
            DBObject course = cursor.next();

            String courseDescription = (String) course.get("kurzname");

            JSONObject jsonCourse = new JSONObject();
            jsonCourse.put("kurzname", courseDescription);

            courseDescriptions.add(jsonCourse);
        }

        return courseDescriptions;
    }

    @PostMapping(value = "/users/courses/{mail}")
    public ResponseEntity<String> setUserCourses(@RequestBody String body, @PathVariable String mail)
    {
        JSONParser parser = new JSONParser();
        JSONArray jsonArray = new JSONArray();
        String sMail =  "";

        try
        {
            byte[] bMail = Base64.getDecoder().decode(mail);
            sMail = new String(bMail, "UTF-8");

            jsonArray = (JSONArray) parser.parse(body); // TODO als liste ???
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

        User user = userRepository.findByMail(sMail);

        if(user != null) {
            try {
                DBCollection teachersDB = mongoTemplate.getCollection("teachers");
                DBCollection coursesDB = mongoTemplate.getCollection("coursesDescription");

                if (teachersDB != null && coursesDB != null)
                {
                    List<DBObject> courses = new ArrayList<>();

                    // find courses via 'kurzname' and add to list
                    for(int i = 0; i < jsonArray.size(); ++i)
                    {
                        JSONObject course = (JSONObject) jsonArray.get(i);

                        BasicDBObject courseQuery = new BasicDBObject();
                        courseQuery.put("kurzname",  course.get("kurzname"));

                        DBObject tmpCourse = coursesDB.find(courseQuery).next();
                        courses.add(tmpCourse);
                    }

                    // search for teacher and update courses
                    BasicDBObject query = new BasicDBObject();
                    query.put("firstName", user.getFirstName());
                    query.put("lastName", user.getLastName());

                    BasicDBObject update = new BasicDBObject();
                    update.put("courses", courses);

                    teachersDB.update(query, update);
                }
                else
                {
                    return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
                }
            }
            catch(Exception e){
                e.printStackTrace();
            }
        }
        else
            return new ResponseEntity<>(HttpStatus.BAD_REQUEST);


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

    @GetMapping(value = "/users/courses/{mail}")
    public @ResponseBody List<JSONObject> getUserCourses(@PathVariable String mail) {

        List<JSONObject> courseList = new ArrayList<>();
        String sMail =  "";

        try
        {
            byte[] bMail = Base64.getDecoder().decode(mail);
            sMail = new String(bMail, "UTF-8");
        }
        catch(UnsupportedEncodingException uee)
        {
            uee.printStackTrace();
        }

        User user = userRepository.findByMail(sMail);

        if(user != null)
        {
            try {
                DBCollection teachersDB = mongoTemplate.getCollection("teachers");

                if (teachersDB != null)
                {
                    BasicDBObject query = new BasicDBObject();
                    query.put("firstName", user.getFirstName());
                    query.put("lastName", user.getLastName());

                    DBObject teacher = teachersDB.find(query).next();

                    List<DBObject> tmpCourses = (List<DBObject>) teacher.get("courses");

                    for(DBObject tmpCourse : tmpCourses)
                    {
                        JSONObject course = new JSONObject();
                        course.put("kurzname", tmpCourse.get("name"));

                        courseList.add(course);
                    }
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }

        return courseList;
    }

    @PostMapping(value = "/timetables/{withPrio}")
    public @ResponseBody List<CalculatedSchedule> setSchedule(HttpServletRequest request, @PathVariable boolean withPrio) {

        Algorithm algo = new Algorithm();
        algo.resetData();

        try {
            if (!mongoTemplate.collectionExists("schedules")) {
                mongoTemplate.createCollection("schedules");
            }
            if(!mongoTemplate.collectionExists("settings")) {
                mongoTemplate.createCollection("settings");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

        // set student prios
        List<StudentSettings> s = new ArrayList<>();
        DBCollection settingsDB = mongoTemplate.getCollection("settings");
       // settingsDB.save(settings1);

        // set teacher prios
        // Erstelle teacher obj und fülle mit daten aus DB
        List<Teacher> t = new ArrayList<>();
        DBCollection teachersDB = mongoTemplate.getCollection("teachers");
        DBCursor cursor = teachersDB.find();
        while (cursor.hasNext()) {
            DBObject obj = cursor.next();
            Teacher teacherobj = mongoTemplate.getConverter().read(Teacher.class, obj);

            t.add(teacherobj);

        }

        cursor = settingsDB.find();
        while (cursor.hasNext()) {
            DBObject obj = cursor.next();
            s.add(mongoTemplate.getConverter().read(StudentSettings.class, obj));
        }


        System.out.println("all tachers: "+t.size());
        algo.setTeachers(t);
        algo.setRooms(getRooms(request));

        if(withPrio)
            algo.setStudentPrios(s);

        List<CalculatedSchedule> cs = algo.generateCalendar();

        mongoTemplate.insert(cs, "schedules");

        /*
        List<String[][]> bla = new ArrayList<>();
        for(CalculatedSchedule xxx : cs)
            bla.add(xxx.getSchedule());
*/

        return cs;
    }

    @GetMapping(value = "/users/priorities/{mail}")
    public @ResponseBody List<JSONObject> getUserPriorities(@PathVariable String mail)
    {
        List<JSONObject> prioList = new ArrayList<>();
        String sMail =  "";

        try
        {
            byte[] bMail = Base64.getDecoder().decode(mail);
            sMail = new String(bMail, "UTF-8");
        }
        catch(UnsupportedEncodingException uee)
        {
            uee.printStackTrace();
        }

        User user = userRepository.findByMail(sMail);

        if(user != null)
        {
            try {
                DBCollection teachersDB = mongoTemplate.getCollection("teachers");

                if (teachersDB != null)
                {
                    BasicDBObject query = new BasicDBObject();
                    query.put("firstName", user.getFirstName());
                    query.put("lastName", user.getLastName());

                    DBObject teacher = teachersDB.find(query).next();
                    List<DBObject> prios = (List<DBObject>) teacher.get("prios");

                    //for(Prio prio : (List<Prio>) teacher.get("prios"))
                    for(DBObject prio : prios)
                    {
                        String classPath = (String) prio.get("_class");
                        String[] sClassPath = classPath.split("\\.");

                        String type = sClassPath[sClassPath.length-1];

                        JSONObject newPrio = new JSONObject();
                        newPrio.put("type", type);
                        newPrio.put("kurzname", prio.get("name"));
                        newPrio.put("value", prio.get("text"));

                        prioList.add(newPrio);
                    }
                }
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        }

        return prioList;
    }

    @PatchMapping(value = "/users/priorities/{mail}")
    public ResponseEntity<String> setUserPriorities(@RequestBody String body, @PathVariable String mail) {

        JSONParser parser = new JSONParser();
        JSONArray jsonArray = new JSONArray();
        String sMail =  "";

        try
        {
            byte[] bMail = Base64.getDecoder().decode(mail);
            sMail = new String(bMail, "UTF-8");

            jsonArray = (JSONArray) parser.parse(body); // TODO als liste ???
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

        List<JSONObject> prios = new ArrayList<>();

        for(int i = 0; i < jsonArray.size(); ++i)
        {
            JSONObject newPrio = null;

            JSONObject jPrio = (JSONObject) jsonArray.get(i);
            String type = (String) jPrio.get("type");

            if(type.matches("SimplePrio"))
            {
                /*
                 {"_id":null,
                "name":"Wöchentliche Veranstaltungen",
                "course":189,
                "isValidForAllCourses":true,
                "text":"Ich ziehe es vor die vierzehntägigen 4SWS meines Unterrichts in zwei wöchentliche Einzelveranstaltungen mit je 2SWS aufzuteilen.",
                "courses":[],
                "_class":"de.teamzhang.model.SimplePrio"}
                 */

                newPrio.put("_id", null);
                newPrio.put("name", jPrio.get("kurzname"));
                newPrio.put("course", 0);
                newPrio.put("isValidForAllCourses", true);
                newPrio.put("text", jPrio.get("value"));
                newPrio.put("courses", new String[]{});
                newPrio.put("_class", "de.teamzhang.model.SimplePrio");
            }
            else if(type.matches("SingleChoicePrio"))
            {
            /*
            {"_id":null,
            "option":0,
            "name":"Anzahl Veranstaltungen pro Tag",
            "course":0,
            "isValidForAllCourses":true,
            "text":"Ich bevorzuge \u0009.\u0009",
            "courses":[],
            "_class":"de.teamzhang.model.SingleChoicePrio"}
             */

                newPrio.put("_id", null);
                newPrio.put("option", 0);
                newPrio.put("name", jPrio.get("kurzname"));
                newPrio.put("course", 0);
                newPrio.put("isValidForAllCourses", true);
                newPrio.put("text", true);
                newPrio.put("courses", new String[]{});
                newPrio.put("_class", "de.teamzhang.model.SimplePrio");
            }
            else if(type.matches("FreeTextInputPrio"))
            {
                newPrio.put("_id", null);
                newPrio.put("name", jPrio.get("kurzname"));
                newPrio.put("value", jPrio.get("value"));
                newPrio.put("_class", "de.teamzhang.model.FreeTextInputPrio");
            }
            else if(type.matches("ExcludeDayCombinationPrio"))
            {
            /*
            {"_id":null,
            "dayOne":0,
            "dayTwo":0,
            "timeOne":0,
            "timeTwo":0,
            "hasTime":false,
            "isExcluding":false,
            "name":"Tage ausschließen",
            "course":0,
            "isValidForAllCourses":true,
            "text":"Wenn ich am \u0009 unterrichte, möchte ich nicht am \u0009 unterrichten.\u0009",
            "courses":[],
            "_class":"de.teamzhang.model.ExcludeDayCombinationPrio"},
            */
                newPrio.put("_id", null);
                newPrio.put("dayOne", 0);
                newPrio.put("dayTwo", 0);
                newPrio.put("timeOne", 0);
                newPrio.put("timeTwo", 0);
                newPrio.put("hasTime", false);
                newPrio.put("isExcluding", false);
                newPrio.put("name", jPrio.get("kurzname"));
                newPrio.put("course", 0);
                newPrio.put("isValidForAllCourses", true);
                newPrio.put("text", jPrio.get("value"));
                newPrio.put("courses", new String[]{});
                newPrio.put("_class", "de.teamzhang.model.ExcludeDayCombinationPrio");

            }
            else
                System.out.println("no known type!");

            prios.add(newPrio);
        }

        User user = userRepository.findByMail(sMail);

        if(user != null) {
            try {
                DBCollection teachersDB = mongoTemplate.getCollection("teachers");

                if (teachersDB != null) {
                    BasicDBObject query = new BasicDBObject();
                    query.put("firstName", user.getFirstName());
                    query.put("lastName", user.getLastName());

                    BasicDBObject update = new BasicDBObject();
                    update.put("prios", prios);
                }
                else
                    return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
            }
            catch(Exception e)
            {
                e.printStackTrace();
            }
        }

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

    @PostMapping(value = "/programs/{courseName}")
    public ResponseEntity<String> updatePriorities(@RequestBody String body, @PathVariable String courseName)
    {
        JSONParser parser = new JSONParser();
        JSONArray jsonArray = new JSONArray();
        String course = "";

        try
        {
            if (!mongoTemplate.collectionExists("priorities"))
            {
                mongoTemplate.createCollection("priorities");
            }

            jsonArray = (JSONArray) parser.parse(body);

            byte[] bMail = Base64.getDecoder().decode(courseName);
            course = new String(bMail, "UTF-8");
        }
        catch (Exception e) {
            e.printStackTrace();
        }

        /* retrieve all prios from JSON
        List<BasicDBObject> prios = new ArrayList<>();
        for(int i = 0; i < jsonArray.size(); ++i)
        {
            JSONObject prio = (JSONObject) jsonArray.get(i);
            // prios.add(prio);
        }
        String prio = (String) jsonArray.si
           */

        DBCollection priosDB = mongoTemplate.getCollection("priorities");

        try {
            if (priosDB != null)
            {
                BasicDBObject query = new BasicDBObject();
                query.put("courseName", course);

                DBObject entry = new BasicDBObject();
                entry.put("courseName", course);
                entry.put("prios", jsonArray);

                // check if entity exists
                DBCursor cursor = priosDB.find(query);

                if(cursor.hasNext())
                {
                    priosDB.remove(query);
                    priosDB.insert(entry);
                }
                else
                {
                    priosDB.insert(entry);
                }
            }
            else
            {
                return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
            }
        }
        catch (Exception e) {
            e.printStackTrace();
        }

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

    private List<Room> getRooms(HttpServletRequest request)
    {
        List<Room> rooms = new ArrayList<>();
        BufferedReader br = null;
        String row = "";
        String separator = ",";

        try {

            br = new BufferedReader(new InputStreamReader(
                    request.getSession().getServletContext().getResourceAsStream("/resources/data/rooms.csv")));
            while ((row = br.readLine()) != null) {

                String[] room = row.replace("Informatik,", "Informatik").split(separator);

                Room r = new Room();
                r.setName(room[0]);
                r.setType(room[3]);
                try {
                    r.setSeat(Integer.parseInt(room[1]));
                } catch (NumberFormatException e) {
                    r.setSeat(20);
                }

                //System.out.println("room: "+r.getName());
                rooms.add(r);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        return rooms;
    }
}