[NP] Payroll System

import java.io.*;
import java.util.*;
import java.util.stream.Collectors;
import java.util.ArrayList;
import java.util.List;
import java.util.Comparator;
class FreelanceEmployee extends Employee {
    List<Integer> tickets;
    EMPLOYEE_TYPE employeeType;
    double ratePerTicket;
    public FreelanceEmployee(String id, String level, List<Integer> tickets, EMPLOYEE_TYPE employeeType) {
        super(id, level);
        this.tickets = tickets;
        this.employeeType = employeeType;
        this.ratePerTicket=0;
    }

    public int getTicketPoints() {
        return tickets.stream().mapToInt(i -> i).sum();
    }

    public void setRate(double ratePerTicket){
        this.ratePerTicket= ratePerTicket;
    }


    public EMPLOYEE_TYPE getEmployeeType() {
        return employeeType;
    }

    @Override
    public double getSalary() {
        return ratePerTicket*getTicketPoints();
    }

    @Override
    public String toString() {
        return String.format("Employee ID: %s Level: %s Salary: %.2f Tickets count: %d Tickets points: %d",
                id,
                level,
                getSalary(),
                tickets.size(),
                getTicketPoints());
    }

    @Override
    public int compareTo(Employee o) {
        return Comparator.comparing(Employee::getSalary).reversed().compare(this,o);
    }
}
enum EMPLOYEE_TYPE {
    HOURLY,
    FREELANCE
}

 class HourlyEmployee extends Employee{
    double hours;
    EMPLOYEE_TYPE employeeType;
    double hourlyRate;
    public static int WEEK_HOURS=40;
    public static double OVERTIME_RATE=1.5;
    public HourlyEmployee(String id, String level, double hours,EMPLOYEE_TYPE employeeType) {
        super(id,level);
        this.hours= hours;
        this.employeeType= employeeType;
        this.hourlyRate=0;
    }

    public void setRate(double hourlyRate){
        this.hourlyRate= hourlyRate;
    }

    public EMPLOYEE_TYPE getEmployeeType() {
        return employeeType;
    }

    @Override
    public double getSalary() {
        return Math.min(WEEK_HOURS,hours)*hourlyRate+OVERTIME_RATE*Math.max(0,hours-WEEK_HOURS)*hourlyRate;
    }

    @Override
    public String toString() {
        return String.format("Employee ID: %s Level: %s Salary: %.2f Regular hours: %.2f Overtime hours: %.2f",
                id,
                level,
                getSalary(),
                Math.min(WEEK_HOURS,hours),
                Math.max(0,hours-WEEK_HOURS));
    }

    @Override
    public int compareTo(Employee o) {
        return Comparator.comparing(Employee::getSalary).reversed().compare(this,o);
    }
}
 abstract class Employee implements Comparable<Employee> {
    String id;
    String level;

    public Employee(String id, String level) {
        this.id = id;
        this.level = level;
    }

    public abstract void setRate(double rate);

    public String getId() {
        return id;
    }

    public String getLevel() {
        return level;
    }

    public abstract double getSalary();

    public static Employee create(String line) {
        String[] parts= line.split(";");
        String type= parts[0];
        String id = parts[1];
        String level = parts[2];
        double hourlySalary;
        List<Integer> tickets= new ArrayList<>();
        if(type.equals("H")){
            hourlySalary= Double.parseDouble(parts[3]);
            return new HourlyEmployee(id,level,hourlySalary,EMPLOYEE_TYPE.HOURLY);
        }
        else{
            for(int i=3;i<parts.length;i++){
                tickets.add(Integer.parseInt(parts[i]));
            }
            return new FreelanceEmployee(id,level,tickets,EMPLOYEE_TYPE.FREELANCE);
        }
    }

    public abstract EMPLOYEE_TYPE getEmployeeType();

}
class PayrollSystem {

    List<Employee> employees;
    Map<String,Double> hourlyRateByLevel;
    Map<String,Double> timeRateByLevel;
    PayrollSystem(Map<String,Double> hourlyRateByLevel, Map<String,Double> ticketRateByLevel){
        this.hourlyRateByLevel= hourlyRateByLevel;
        this.timeRateByLevel= ticketRateByLevel;
        this.employees= new ArrayList<>();

    }
    public void readEmployees(InputStream in) {
        BufferedReader bufferedReader= new BufferedReader(new InputStreamReader(in));

//        employees= bufferedReader.lines().map(Employee::create).collect(Collectors.toMap(
//                entry->entry.id,
//                entry->entry
//        ));
        employees= bufferedReader.lines().map(Employee::create).collect(Collectors.toList());
        for(Employee e: employees){
            if(e.getEmployeeType().equals(EMPLOYEE_TYPE.HOURLY)){
                double hourlyRate= hourlyRateByLevel.get(e.getLevel());
                e.setRate(hourlyRate);
            }
            else{
                double ratePerTicket= timeRateByLevel.get(e.getLevel());
                e.setRate(ratePerTicket);
            }

        }

    }

    public Map<String, Set<Employee>> printEmployeesByLevels(PrintStream out, Set<String> levels) {
        PrintWriter printWriter = new PrintWriter(out);
        Map<String, Set<Employee>> employeesByLevels = employees.stream()
                .filter(i -> levels.contains(i.getLevel()))
                .collect(Collectors.groupingBy(
                        Employee::getLevel,
                        TreeMap::new, // map sorted by key
                        Collectors.toCollection(TreeSet::new) // values sorted too
                ));
        printWriter.flush();
        return employeesByLevels;
    }
}

public class PayrollSystemTest {

    public static void main(String[] args) {

        Map<String, Double> hourlyRateByLevel = new LinkedHashMap<>();
        Map<String, Double> ticketRateByLevel = new LinkedHashMap<>();
        for (int i = 1; i <= 10; i++) {
            hourlyRateByLevel.put("level" + i, 10 + i * 2.2);
            ticketRateByLevel.put("level" + i, 5 + i * 2.5);
        }

        PayrollSystem payrollSystem = new PayrollSystem(hourlyRateByLevel, ticketRateByLevel);

        System.out.println("READING OF THE EMPLOYEES DATA");
        payrollSystem.readEmployees(System.in);

        System.out.println("PRINTING EMPLOYEES BY LEVEL");
        Set<String> levels = new LinkedHashSet<>();
        for (int i=5;i<=10;i++) {
            levels.add("level"+i);
        }
        Map<String, Set<Employee>> result = payrollSystem.printEmployeesByLevels(System.out, levels);
        result.forEach((level, employees) -> {
            System.out.println("LEVEL: "+ level);
            System.out.println("Employees: ");
            employees.forEach(System.out::println);
            System.out.println("------------");
        });


    }
}