private Boolean status;

    /**
     * You should have your own function to generate a response to user input.
     * Replace this stub with your completed method.
     */

    public String getResponse(String userInput) {
        String response = "";
        try {
            // use parser to process the userInput
            // the parser object contains all the current user input line information
            Parser parser = new Parser();
            parser.parse(userInput);

            // check for end the session
            if (parser.getCurrentKey().equals(KeyEnum.EXITKEY)) {
                response = ui.onExit();
            }

            // continue for the functionality
            switch (parser.getCurrentKey()) {
            case DEADLINE:
            case TODO:
            case EVENT:
                Task task = tasks.addTask(parser.getInputDetail(),
                    parser.getFrom(), parser.getTo(), parser.getCurrentKey());
                storage.writeTasksToFile(tasks);
                response = ui.onAddSuccess(task, tasks.getNumOfTasks());
                break;
            case LIST:
                response = ui.showList(tasks);
                break;
            case MARK:
                Task markedTask = tasks.markTaskById(parser.getIndex(), true);
                storage.writeTasksToFile(tasks);
                response = ui.onMarkDone(markedTask);
                break;
            case UNMARK:
                Task unMarkedTask = tasks.markTaskById(parser.getIndex(), false);
                storage.writeTasksToFile(tasks);
                response = ui.onUnmarkDone(unMarkedTask);
                break;
            case DELETE:
                Task deletedTask = tasks.deleteTaskById(parser.getIndex());
                storage.writeTasksToFile(tasks);
                response = ui.onDelete(deletedTask, tasks);
                break;
            case FIND:
                TaskList matchedTasks = tasks.findTasks(parser.getInputDetail());
                response = ui.showMatchedList(matchedTasks);
                break;
            default:
                break;
            }
        } catch (BaseException e) {
            response = ui.showErrorMsg(e.getMessage());
        } catch (IOException e) {
            response = ui.showLoadingError();
        }
        return response;
    }

    public TaskList findNextDueTasks(int numOfTasks) {
        ArrayList<Task> nextTasks = new ArrayList<>(tasks);
        nextTasks.removeIf(Task::getIsDone); // remove completed tasks
        nextTasks.sort(new Comparator<Task>() {
            @Override
            public int compare(Task o1, Task o2) {
                if (o1 instanceof Todo) {
                    return 1;
                }
                if (o2 instanceof Todo) {
                    return -1;
                }

                if (o1 instanceof Deadline) {
                    if (o2 instanceof Deadline) {
                        return ((Deadline) o1).getBy().compareTo(((Deadline) o2).getBy());
                    } else if (o2 instanceof Event) {
                        return ((Deadline) o1).getBy().compareTo(((Event) o2).getBy());
                    }
                } else if (o1 instanceof Event) {
                    if (o2 instanceof Deadline) {
                        return ((Event) o1).getBy().compareTo(((Deadline) o2).getBy());
                    } else if (o2 instanceof Event) {
                        return ((Event) o1).getBy().compareTo(((Event) o2).getBy());
                    }
                }
                return 0;
            }
        });

        if (nextTasks.size() <= numOfTasks) {
            return new TaskList(nextTasks);
        }

        ArrayList<Task> tempTasks = new ArrayList<>();
        int counter = numOfTasks;
        for (Task task: nextTasks) {
            if (counter <= 0) {
                break;
            }
            tempTasks.add(task);
            counter--;
        }
        return new TaskList(tempTasks);
    }

    public void parse(String userInput) throws InvalidKeyException, EmptyBodyException,
            WrongFormatException, InvalidNumberException, DateTimeParseException, InvalidDateTimeException {
        String[] userInputSplit = userInput.split(" ");
        // verify that the user input is valid
        String checkInputMsg = checkSpecialCharacter(userInputSplit);
        if (!checkInputMsg.equals("valid")) {
            throw new WrongFormatException(checkInputMsg);
        }
        this.determineCurrentKey(userInputSplit[0]);
        switch (this.currentKey) {
        case DEADLINE:
            if (userInput.length() <= 9) {
                throw new EmptyBodyException();
            }
            try {
                inputDetail = userInput.substring(9, userInput.indexOf("/by"));
                to = formatDate(userInput.substring(userInput.indexOf("/by") + 4));
            } catch (Exception e) {
                throw new WrongFormatException("\"deadline content /by yyyy-mm-dd\"");
            }
            break;
        case TODO:
        case FIND:
            if (userInput.length() <= 5) {
                throw new EmptyBodyException();
            }
            inputDetail = userInput.substring(5);
            break;
        case EVENT:
            if (userInput.length() <= 6) {
                throw new EmptyBodyException();
            }
            try {
                inputDetail = userInput.substring(6, userInput.indexOf("/from"));
                from = formatDate(userInput.substring(userInput.indexOf("/from") + 6, userInput.indexOf("/to") - 1));
                to = formatDate(userInput.substring(userInput.indexOf("/to") + 4));
                if (from.isAfter(to)) {
                    throw new InvalidDateTimeException("The start date should be before the end date");
                }
            } catch (InvalidDateTimeException e) {
                throw e;
            } catch (Exception e) {
                throw new WrongFormatException("\"event content /from yyyy-mm-dd /to yyyy-mm-dd\"");
            }
            break;
        case MARK:
        case UNMARK:
        case DELETE:
            try {
                this.index = new Integer(userInputSplit[1]) - 1;
                this.inputDetail = this.index.toString();
            } catch (Exception e) {
                throw new InvalidNumberException();
            }
            break;
        default:
            break;
        }

        // check if the user input contains only empty spaces.
        if (!(currentKey.equals(KeyEnum.LIST) || currentKey.equals(KeyEnum.EXITKEY)) && inputDetail.trim().isEmpty()) {
            throw new EmptyBodyException();
        }
    }