npse

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;

public class EnrollmentSystemTest {

    public static void main(String[] args) {
        EnrollmentSystem enrollmentApplication = new EnrollmentSystem();

        System.out.println("--- READING FROM INPUT STREAM ---");
        enrollmentApplication.readData(System.in);

        System.out.println();
        System.out.println("--- PRINTING TO OUTPUT STREAM (ASCENDING) ---");
        enrollmentApplication.printData(System.out, true);

        System.out.println();
        System.out.println("--- PRINTING TO OUTPUT STREAM (DESCENDING) ---");
        enrollmentApplication.printData(System.out, false);

        System.out.println();
        System.out.println("--- PRINTING BY CITY ---");
        enrollmentApplication.printByCity(System.out);

        System.out.println();
        System.out.println("--- PRINTING ENROLLED STUDENTS ---");
        enrollmentApplication.enrolledStudents(System.out);
    }
}

class InvalidProgramException extends Exception {

    @Override
    public String getMessage() {
        return super.getMessage();
    }

    @Override
    public String getLocalizedMessage() {
        return super.getLocalizedMessage();
    }

    @Override
    public synchronized Throwable getCause() {
        return super.getCause();
    }

    @Override
    public synchronized Throwable initCause(Throwable cause) {
        return super.initCause(cause);
    }

    @Override
    public String toString() {
        return super.toString();
    }

    public InvalidProgramException() {
    }

    public InvalidProgramException(String message) {
        super("INVALID PROGRAM EXCEPTION");
    }

    public InvalidProgramException(String message, Throwable cause) {
        super(message, cause);
    }
}

enum Program {

    A,
    B,
    C
}

class Student implements Comparable<Student> {

    // id name surname g1 g2 g3 g4 m1 m2 m3 city program
    private Long id;
    private String name;
    private String surname;
    private List<Float> gradesHS;
    private List<Integer> gradesM;
    private String city;
    private Program program;
    private double points;

    public Long getIdLong(){
        return id;
    }

    public Student() {
        this.gradesHS = new ArrayList<>();
        this.gradesM = new ArrayList<>();
    }

    public Student(long id, String name, String surname, List<Float> gradesHS, List<Integer> gradesM, String city, Program program) {
        this.id = id;
        this.name = name;
        this.surname = surname;
        this.gradesHS = gradesHS;
        this.gradesM = gradesM;
        this.city = city;
        this.program = program;
        this.points = calculatePoints(gradesHS, gradesM, program);
    }

    public double getPoints() {
        return points;
    }

    private double calculatePoints(List<Float> gradesHS, List<Integer> gradesM, Program program) {
        double points = 0;
        if (program.toString().equals("A")) {
            points = (gradesHS.stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.4
                    + (gradesHS.stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.6;   // todo check this
        } else if (program.toString().equals("B")) {
            points = (gradesHS.stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.6
                    + (gradesHS.stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.4;   // todo check this
        } else if (program.toString().equals("C")) {
            points = (gradesHS.stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.5
                    + (gradesHS.stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.5;   // todo check this
        }
        return points;
    }


  /*  public String printStudent() {
        return String.format("%d %s %s %s %s %f", id, name, surname, city,
                program, points);
    }*/

    @Override
    public String toString() {
        return String.format("%d %s %s %s %s %.2f", id, name, surname, city,
                program, points);
    }


    public int compareTo(Student s) {
        if (points == s.getPoints())
            return id.compareTo(s.getId());
        if (points > s.getPoints())
            return 1;
        return -1;
    }


    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSurname() {
        return surname;
    }

    public void setSurname(String surname) {
        this.surname = surname;
    }

    public List<Float> getGradesHS() {
        return gradesHS;
    }

    public void setGradesHS(List<Float> gradesHS) {
        this.gradesHS = gradesHS;
    }


    public List<Integer> getGradesM() {
        return gradesM;
    }

    public void setGradesM(List<Integer> gradesM) {
        this.gradesM = gradesM;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public Program getProgram() {
        return program;
    }

    public void setProgram(Program program) {
        this.program = program;
    }
}

class Points {

    private double points;
    private Student student;

    public double getPoints() {
        return points;
    }


    @Override
    public String toString() {
        return String.format("%d %s %s %s %s %f", student.getId(), student.getName(), student.getSurname(), student.getCity(),
                student.getProgram(), points);

    }

    public void setPoints(float points) {
        this.points = points;
    }

    public Student getStudent() {
        return student;
    }

    public Points(double points, Student student) {
        this.points = points;
        this.student = student;
    }


    public void setStudent(Student student) {
        this.student = student;
    }

}

class EnrollmentSystem {

    // kolekcija na prijaviOdStudenti
    // HashMap<Program, List<Student>> prijavi;
    List<Student> prijavi;

    public EnrollmentSystem() {
        this.prijavi = new ArrayList<>();

    }

    public void readData(InputStream is) {

        BufferedReader reader;
        try {
            reader = new BufferedReader(new InputStreamReader(is));


            reader.lines()
                    .forEach(line -> {
                        String pom[] = line.split(" ");
                        try {
                            if (!(pom[11].equals("A") || pom[11].equals("C") || pom[11].equals("B")))
                                throw new InvalidProgramException();

                            Long id = Long.parseLong(pom[0]);
                            String name = pom[1];
                            String surname = pom[2];
                            float g1 = Float.parseFloat(pom[3]);
                            float g2 = Float.parseFloat(pom[4]);
                            float g3 = Float.parseFloat(pom[5]);
                            float g4 = Float.parseFloat(pom[6]);
                            List<Float> gradesH = new ArrayList<>();
                            gradesH.add(g1);
                            gradesH.add(g2);
                            gradesH.add(g3);
                            gradesH.add(g4);

                            int m1 = Integer.parseInt(pom[7]);
                            int m2 = Integer.parseInt(pom[8]);
                            int m3 = Integer.parseInt(pom[9]);

                            String city = pom[10];

                            List<Integer> gradesM = new ArrayList<>();
                            gradesM.add(m1);
                            gradesM.add(m2);
                            gradesM.add(m3);

                            Program program = Program.valueOf(pom[11]);
                            // public Student(long id, String name, String surname, List<Float> gradesHS, List<Integer> gradesM, String city, Program program) {

                            Student student = new Student(id, name, surname, gradesH, gradesM, city, program);

                            prijavi.add(student);


                        } catch (InvalidProgramException e) {
                            System.out.println(e.getMessage());
                        }


                    });
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }


    }

    private double calculatePoints(Student s) {
        double points = 0;
        if (s.getProgram().toString().equals("A")) {
            points = (s.getGradesHS().stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.4
                    + (s.getGradesM().stream().reduce(0, (prev, curr) -> prev += curr)) * 0.6;   // todo check this
        } else if (s.getProgram().toString().equals("B")) {
            points = (s.getGradesHS().stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.6
                    + (s.getGradesM().stream().reduce(0, (prev, curr) -> prev += curr)) * 0.4;   // todo check this
        } else if (s.getProgram().toString().equals("C")) {
            points = (s.getGradesHS().stream().reduce((float) 0, (prev, curr) -> prev += curr)) * 0.5
                    + (s.getGradesM().stream().reduce(0, (prev, curr) -> prev += curr)) * 0.5;   // todo check this
        }
        return points;
    }


    // not done
    public void printData(OutputStream os, boolean ascending) {

        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));

        List<Student> lista =
                prijavi.stream()
                        .sorted(Student::compareTo)
                        .collect(Collectors.toList());


        if (ascending) {
            lista.stream()
                    .sorted(Comparator.reverseOrder())
                    .forEach(student -> {
                        try {
                            writer.write(student.toString());
                            writer.flush();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }

                    });
        } else {
            lista.stream()
                    .forEach(student -> {
                        try {
                            writer.write(student.toString());
                            writer.flush();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        });
        }
    }





    public void printByCity(OutputStream os) {

        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));


        prijavi
                .stream()
                .sorted((s1,s2) -> {
                    if(s1.getCity().equals(s2.getCity()))
                        return s1.compareTo(s2);
                    return s1.getCity().compareTo(s2.getCity());
                })
                .forEach( student -> {

                    try {
                        writer.write(student.toString());
                        writer.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                });

    }

    public void enrolledStudents(OutputStream os){

        BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(os));

        prijavi
                .stream()
                .filter(s -> s.getPoints() > 12)
                .sorted((s1,s2)->{
                    if(s1.getPoints()==s2.getPoints())
                        return s1.getIdLong().compareTo(s2.getIdLong());
                    if(s1.getPoints() > s2.getPoints())
                        return 1;
                    return -1;

                })
                .forEach( s -> {
                    try {
                        writer.write(s.toString());
                        writer.flush();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }

                });
    }


}