[NP] Payroll System v2

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

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

    public void setRate(double hourlyRate){
        this.hourlyRate= hourlyRate;
    }
    public double getOvertimeSalary(){
        return Math.max(0,hours-WEEK_HOURS)*OVERTIME_RATE;
    }
    @Override
    public double getBonus() {
        if(bonusType.equals(BONUS_TYPE.FIXED))
            return bonus;
        else if(bonusType.equals(BONUS_TYPE.PROCENTUAL))
            return getSalary()*bonus/100.00;
        else
            return 0;
    }

    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  Bonus: %.2f",
                id,
                level,
                getSalary(),
                Math.min(WEEK_HOURS,hours),
                Math.max(0,hours-WEEK_HOURS),
                getBonus());
    }

    @Override
    public int compareTo(Employee o) {
        return Comparator.comparing(Employee::getSalary).reversed().compare(this,o);
    }
}
class FreelanceEmployee extends Employee {
    List<Integer> tickets;
    EMPLOYEE_TYPE employeeType;
    double ratePerTicket;
    int bonus;
    BONUS_TYPE bonusType;
    public FreelanceEmployee(String id, String level, List<Integer> tickets, EMPLOYEE_TYPE employeeType, int bonus, BONUS_TYPE bonusType) {
        super(id, level);
        this.tickets = tickets;
        this.employeeType = employeeType;
        this.ratePerTicket=0;
        this.bonus= bonus;
        this.bonusType= bonusType;
    }

    public int getNumberOfTickets(){
        return tickets.size();
    }

    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 double getBonus() {
        if(bonusType.equals(BONUS_TYPE.FIXED))
            return bonus;
        else if(bonusType.equals(BONUS_TYPE.PROCENTUAL))
            return getSalary()*bonus/100.00;
        else
            return 0;
    }

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

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


enum BONUS_TYPE {

    FIXED,
    NONE, PROCENTUAL
}

class BonusNotAllowedException extends  Exception{

    public BonusNotAllowedException(String message) {
        super(message);
    }
}

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 getBonus();

    public abstract double getSalary();

    public abstract EMPLOYEE_TYPE getEmployeeType();

}
enum EMPLOYEE_TYPE {
    HOURLY,
    FREELANCE
}

class PayrollSystem {

    Map<String, 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 HashMap<>();
        this.employees.put("F", new ArrayList<>());
        this.employees.put("H", new ArrayList<>());
    }

    public Employee createEmployee(String line) throws BonusNotAllowedException {
        String[] partsAndBonus = line.split("\\s+");
        String bonus = "";
        if (partsAndBonus.length > 1) {
            bonus = partsAndBonus[1];
        }
        String[] parts = partsAndBonus[0].split(";");
        String type = parts[0];
        String id = parts[1];
        String level = parts[2];
        double hourlySalary;
        List<Integer> tickets = new ArrayList<>();
        if (!bonus.equals("")) {
            if (bonus.contains("%") && Double.parseDouble(bonus.substring(0, bonus.length()-1)) > 20)
                throw new BonusNotAllowedException("E TOE");
            if (!bonus.contains("%") && Double.parseDouble(bonus) > 1000)
                throw new BonusNotAllowedException("E TOE");
        }
        if (type.equals("H")) {
            hourlySalary = Double.parseDouble(parts[3]);
            if (bonus.equals("")) {
                employees.get("H").add(new HourlyEmployee(id, level, hourlySalary, EMPLOYEE_TYPE.HOURLY, 0, BONUS_TYPE.NONE));
            } else {
                if (bonus.contains("%")) {
                    employees.get("H").add(new HourlyEmployee(id, level, hourlySalary, EMPLOYEE_TYPE.HOURLY,
                            Double.parseDouble(bonus.substring(0, bonus.length() - 1)), BONUS_TYPE.PROCENTUAL));
                } else {
                    employees.get("H").add(new HourlyEmployee(id, level, hourlySalary, EMPLOYEE_TYPE.HOURLY,
                            Double.parseDouble(bonus), BONUS_TYPE.FIXED));
                }
            }
            return employees.get("H").get(employees.size() - 1);
        } else {
            for (int i = 3; i < parts.length; i++) {
                tickets.add(Integer.parseInt(parts[i]));
            }
            if (bonus.equals("")) {
                employees.get("F").add(new FreelanceEmployee(id, level, tickets, EMPLOYEE_TYPE.HOURLY, 0, BONUS_TYPE.NONE));
            } else {
                if (bonus.contains("%")) {
                    employees.get("F").add(new FreelanceEmployee(id, level, tickets, EMPLOYEE_TYPE.HOURLY,
                            Double.parseDouble(bonus.substring(0, bonus.length() - 1)), BONUS_TYPE.PROCENTUAL));

                } else {
                    employees.get("F").add(new FreelanceEmployee(id, level, tickets, EMPLOYEE_TYPE.HOURLY,
                            Double.parseDouble(bonus), BONUS_TYPE.FIXED));
                }
            }
            return employees.get("F").get(employees.size() - 1);

        }
    }


    public void setRates() {

        for (Employee e : employees.get("H")) {
            double hourlyRate = hourlyRateByLevel.get(e.getLevel());
            e.setRate(hourlyRate);
        }
        for (Employee e : employees.get("F")) {
            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;
//    }


    Map<String, Double> getOvertimeSalaryForLevels() {
        return employees.get("H").stream()
                .map(e -> (HourlyEmployee) e)
                .collect(Collectors.groupingBy(
                Employee::getLevel,
                Collectors.summingDouble(HourlyEmployee::getOvertimeSalary)
        ));
    }

    void printStatisticsForOvertimeSalary() {
        DoubleSummaryStatistics doubleSummaryStatistics= employees.values().stream().flatMap(list -> list.stream()).mapToDouble(i->i.getBonus()).summaryStatistics();
        System.out.println(String.format("Min: %.2f Max: %.2f Sum: %.2f Average: %.2f",doubleSummaryStatistics.getMin(),
                doubleSummaryStatistics.getMax(),
                doubleSummaryStatistics.getSum(),
                doubleSummaryStatistics.getAverage()));
    }

    Map<String, Integer> ticketsDoneByLevel() {
        return employees.get("F").stream()
        .map(e -> (FreelanceEmployee) e)
        .collect(Collectors.groupingBy(
                Employee::getLevel,
                Collectors.summingInt(FreelanceEmployee::getNumberOfTickets)
        ));

    }

    Collection<Employee> getFirstNEmployeesByBonus(int n) {
        return employees.values().stream().flatMap(list -> list.stream())
                .sorted(Comparator.comparing(Employee::getBonus).reversed())
                .limit(n).collect(Collectors.toList());
    }
}
public class PayrollSystemTest2 {

    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, 11 + i * 2.2);
            ticketRateByLevel.put("level" + i, 5.5 + i * 2.5);
        }

        Scanner sc = new Scanner(System.in);

        int employeesCount = Integer.parseInt(sc.nextLine());

        PayrollSystem ps = new PayrollSystem(hourlyRateByLevel, ticketRateByLevel);
        Employee emp = null;
        for (int i = 0; i < employeesCount; i++) {
            try {
                emp = ps.createEmployee(sc.nextLine());
            } catch (BonusNotAllowedException e) {
                System.out.println(e.getMessage());
            }
        }
        ps.setRates();
        int testCase = Integer.parseInt(sc.nextLine());

        switch (testCase) {
            case 1: //Testing createEmployee
                if (emp != null)
                    System.out.println(emp);
                break;
            case 2: //Testing getOvertimeSalaryForLevels()
                ps.getOvertimeSalaryForLevels().forEach((level, overtimeSalary) -> {
                    System.out.printf("Level: %s Overtime salary: %.2f\n", level, overtimeSalary);
                });
                break;
            case 3: //Testing printStatisticsForOvertimeSalary()
                ps.printStatisticsForOvertimeSalary();
                break;
            case 4: //Testing ticketsDoneByLevel
                ps.ticketsDoneByLevel().forEach((level, overtimeSalary) -> {
                    System.out.printf("Level: %s Tickets by level: %d\n", level, overtimeSalary);
              });
               break;
            case 5: //Testing getFirstNEmployeesByBonus (int n)
                ps.getFirstNEmployeesByBonus(Integer.parseInt(sc.nextLine())).forEach(System.out::println);
                break;
        }

    }
}