[NP] Task Builder

import java.io.*;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.time.LocalDateTime;
class InvalidDeadlineException extends Exception {
    public InvalidDeadlineException(LocalDateTime dueDate) {
        super(String.format("The deadline %s has already passed",dueDate));
    }
}

class Task {
    private final String category;
    private final String name;
    private final String description;
    private final LocalDateTime dueDate;
    private final Integer priority;

    private Task(Builder builder) {
        this.category = builder.category;
        this.name = builder.name;
        this.description = builder.description;
        this.dueDate = builder.dueDate;
        this.priority = builder.priority;
    }

    public static class Builder {
        private final String category;
        private final String name;
        private final String description;
        private LocalDateTime dueDate;
        private Integer priority;

        public Builder(String category, String name, String description) {
            this.category = category;
            this.name = name;
            this.description = description;
        }

        public Builder dueDate(LocalDateTime dueDate) throws InvalidDeadlineException {
            if (dueDate != null && dueDate.isBefore(LocalDateTime.of(2020, 6, 2, 0, 0))) {
                throw new InvalidDeadlineException(dueDate);
            }
            this.dueDate = dueDate;
            return this;
        }

        public Builder priority(Integer priority) {
            this.priority = priority;
            return this;
        }

        public Task build() {
            return new Task(this);
        }
    }


public static Task create(String line) throws InvalidDeadlineException {
    String[] parts = line.split(",");
    String category = parts[0];
    String name = parts[1];
    String description = parts[2];
    Builder builder = new Task.Builder(category, name, description);

    if (parts.length == 5) {
        LocalDateTime dueDate = LocalDateTime.parse(parts[3]);
        Integer priority = Integer.parseInt(parts[4]);
        return builder.dueDate(dueDate).priority(priority).build();
    } else if (parts.length == 4) {
        if (parts[3].contains("-")) {
            LocalDateTime dueDate = LocalDateTime.parse(parts[3]);
            return builder.dueDate(dueDate).build();
        } else {
            Integer priority = Integer.parseInt(parts[3]);
            return builder.priority(priority).build();
        }
    } else {
        return builder.build();
    }
}

    public String getCategory() {
        return category;
    }

    public String getName() {
        return name;
    }

    public Integer getPriority() {
        return priority;
    }

    public String getDescription() {
        return description;
    }

    public LocalDateTime getDueDate() {
        return dueDate;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder= new StringBuilder();
        //Task{name='NP', description='lab 1 po NP', deadline=2020-06-23T23:59:59, priority=1}
        stringBuilder.append(String.format("Task{name='%s', description='%s'",getName(),getDescription()));
        if(getDueDate()!=null)
            stringBuilder.append(String.format(", deadline=%s",getDueDate()));

        if (getPriority() != null)
            stringBuilder.append(String.format(", priority=%d", getPriority()));

        return stringBuilder.append("}").toString();
    }
}

class TaskMenager {
    List<Task> tasks;

    public TaskMenager() {
        this.tasks= new ArrayList<>();
    }

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

        tasks= bufferedReader.lines().map(line -> {
            try {
                return Task.create(line);
            } catch (InvalidDeadlineException e) {
                System.out.println(e.getMessage());
                return null;
            }
        })
        .filter(Objects::nonNull)
        .collect(Collectors.toList());
    }

    public void printTasks(PrintStream out, boolean includePriority, boolean includeCategory) {
        PrintWriter printWriter= new PrintWriter(out);
        Comparator<Task> comparatorWithPriority =
                Comparator.comparing(Task::getPriority, Comparator.nullsLast(Comparator.naturalOrder()))
                        .thenComparing(Task::getDueDate, Comparator.nullsLast(Comparator.naturalOrder()));
        Comparator<Task> comparatorWithoutPriority =
                Comparator.comparing(Task::getDueDate, Comparator.nullsLast(Comparator.naturalOrder()));

        if(!includeCategory)
            if(!includePriority)
                tasks.stream().sorted(comparatorWithoutPriority).forEach(i->printWriter.println(i));
            else
                tasks.stream().sorted(comparatorWithPriority).forEach(i->printWriter.println(i));
        else
            if(!includePriority){
                for(String category : tasks.stream().map(i->i.getCategory()).distinct().collect(Collectors.toList())){
                    printWriter.println(category.toUpperCase());
                    tasks.stream().sorted(comparatorWithoutPriority)
                            .filter(i->i.getCategory().equals(category))
                            .forEach(i->printWriter.println(i));
                }
            }
            else{
                for(String category : tasks.stream().map(i->i.getCategory()).distinct().collect(Collectors.toList())){
                    printWriter.println(category.toUpperCase());
                    tasks.stream().sorted(comparatorWithPriority)
                            .filter(i->i.getCategory().equals(category))
                            .forEach(i->printWriter.println(i));
                }
            }
        printWriter.flush();
    }
}

public class TasksManagerTest {

    public static void main(String[] args) {

        TaskMenager manager = new TaskMenager();

        System.out.println("Tasks reading");
        manager.readTasks(System.in);
        System.out.println("By categories with priority");
        manager.printTasks(System.out, true, true);
        System.out.println("-------------------------");
        System.out.println("By categories without priority");
        manager.printTasks(System.out, false, true);
        System.out.println("-------------------------");
        System.out.println("All tasks without priority");
        manager.printTasks(System.out, false, false);
        System.out.println("-------------------------");
        System.out.println("All tasks with priority");
        manager.printTasks(System.out, true, false);
        System.out.println("-------------------------");

    }
}