wxwern / cs2103t-ip Goto Github PK

    private boolean completed = false;

    private void processCommand(ChatCommand chatCommand) {
        try {
            switch (chatCommand.getOperation()) {
            case MARK_COMPLETE:
            case UNMARK_COMPLETE:
            case DELETE:
                this.processCommandAssertNumericData(chatCommand);
                break;

            case ADD_TODO:
            case ADD_DEADLINE:
            case ADD_EVENT:
            case SEARCH:
                this.processCommandAssertHasData(chatCommand);
                break;

            case LIST:
            case HELP:
            case EXIT:
                this.processCommandAssertNoData(chatCommand);
                break;

            case UNKNOWN:
            default:
                throw new ChatbotCommandException("Sorry, idgi :(");
            }
        } catch (ChatbotIrrelevantOperationException e) {
            // This will only be thrown if the code path unexpectedly processes data in a format not relevant to the
            // operation in question. In other words, entering this code block is likely a programmer error.
            assert false;
            this.sendMessage(ChatMessage.SenderType.CHATBOT, "Oops! There was an internal error.");

        } catch (ChatbotCommandException e) {
            // All other errors related to command processing will be caught here, and should be shown to the user.
            this.sendMessage(ChatMessage.SenderType.CHATBOT, "Oops! " + e.getLocalizedMessage());

        } catch (Exception e) {
            // Any other exceptions are errors unrelated to the command itself. In this case, let the user know anyway.
            e.printStackTrace();
            this.sendMessage(ChatMessage.SenderType.CHATBOT, String.format(
                    "Oh no, something's wrong! [%s] %s",
                    e.getClass().getSimpleName(),
                    e.getLocalizedMessage()
            ));
        }

        try {
            this.taskManager.saveToStorage();
        } catch (IOException e) {
            this.sendMessage(
                    ChatMessage.SenderType.CHATBOT,
                    "Oops! I'm having problems saving your data to storage. Your data may not be preserved."
                            + String.format(
                            "The error was: [%s] %s",
                            e.getClass().getSimpleName(),
                            e.getLocalizedMessage()
                    )
            );
        }
    }

    private void processCommandAssertNumericData(ChatCommand chatCommand) throws ChatbotCommandException {
        switch (chatCommand.getOperation()) {
        case MARK_COMPLETE:
        case UNMARK_COMPLETE:
        case DELETE:
            break;
        default:
            throw new ChatbotIrrelevantOperationException(String.format(
                    "The command '%s' should not have numeric data only, "
                            + "but the internal code attempted to assert that it does",
                    chatCommand.getName()
            ));
        }

        int index;
        Task task;

        // Process the input
        try {
            index = Integer.parseInt(chatCommand.getData()) - 1;
        } catch (NumberFormatException | NullPointerException e) {
            throw new ChatbotInvalidCommandFormatException((String.format(
                    "The command '%s' must be followed by a number representing the task number!",
                    chatCommand.getName()
            )));
        }

        try {
            task = this.taskManager.getTask(index);
        } catch (IndexOutOfBoundsException e) {
            throw new ChatbotInvalidCommandFormatException(String.format(
                    "There is no task in the list numbered %d!",
                    index + 1
            ));
        }

        assert index >= 0 && index < this.taskManager.getTaskCount();
        assert task != null;

        // Let's see what we should do!
        if (chatCommand.getOperation() == ChatCommand.Operation.DELETE) {

            // Delete the task accordingly. We already checked the index so it should be correct.
            this.taskManager.removeTask(index);

            // Send an appropriate reply.
            this.sendMessage(ChatMessage.SenderType.CHATBOT, String.format(
                    "Alright, I've deleted this task:\n   %s\nYou're left with %d tasks now! :)",
                    task,
                    this.taskManager.getTaskCount()
            ));

        } else {

            // Mark the task as done or not accordingly
            boolean completed = chatCommand.getOperation() == ChatCommand.Operation.MARK_COMPLETE;
            if (task.isCompleted() == completed) {
                throw new ChatbotCommandException(completed
                        ? "The task was already done!"
                        : "The task was already not done!");
            }
            task.setCompleted(completed);

            // Send an appropriate reply
            if (completed) {
                this.sendMessage(
                        ChatMessage.SenderType.CHATBOT,
                        String.format("Nice! I've marked this task as done:\n   %s", task)
                );
            } else {
                this.sendMessage(
                        ChatMessage.SenderType.CHATBOT,
                        String.format("OK, I've marked this task as not done yet:\n   %s", task)
                );
            }

        }

    }

    private void processCommandAssertNoData(ChatCommand chatCommand) throws ChatbotCommandException {
        switch (chatCommand.getOperation()) {
        case LIST:
        case HELP:
        case EXIT:
            break;
        default:
            throw new ChatbotIrrelevantOperationException(String.format(
                    "The command '%s' should have included data, "
                            + "but the internal code attempted to assert that it does not.",
                    chatCommand.getName()
            ));
        }

        if (!chatCommand.getData().isBlank() || chatCommand.hasParams()) {
            throw new ChatbotInvalidCommandFormatException(String.format(
                    "Hmm, the command '%s' should not have anything following it. Is that a typo?",
                    chatCommand.getName()
            ));
        }

        StringBuilder builder;
        switch (chatCommand.getOperation()) {
        case LIST:
            builder = new StringBuilder();

            if (this.taskManager.getTaskCount() > 0) {
                builder.append("Here are your tasks, glhf! :)");
            } else {
                builder.append("Oh nice! You have no tasks! :>");
            }

            this.taskManager.getTaskIndexedStream()
                    .forEach(integerTaskPair -> {
                        builder.append("\n");
                        builder.append(integerTaskPair.getKey() + 1);
                        builder.append(". ");
                        builder.append(integerTaskPair.getValue().toString());
                    });

            this.sendMessage(ChatMessage.SenderType.CHATBOT, builder.toString());
            break;

        case HELP:
            builder = new StringBuilder();
            builder.append("No problem. Here's a summary of all possible command names and their functions!\n\n");

            for (ChatCommand.Operation op : ChatCommand.Operation.values()) {

                var aliases = op.getSupportedNameAliases();
                var quotedAliases = Arrays.stream(aliases)
                        .map(s -> '"' + s + '"')
                        .collect(Collectors.toList());

                if (quotedAliases.size() == 0) {
                    continue;
                }

                String commandTitle = String.join(", ", quotedAliases);
                String commandDescription = op.getDescription();
                String commandSyntax = String.format(op.getSyntaxDescriptionAsFormatString(), aliases[0]);

                builder.append(String.format("    %s\n", commandTitle));
                builder.append(String.format("        %s\n", commandDescription));
                builder.append(String.format("        Format: \"%s\"\n", commandSyntax));
                builder.append('\n');
            }

            builder.append("Commands listed with multiple names above are synonyms and can be used interchangeably.\n");
            builder.append("Hope this helps! :)");

            this.sendMessage(ChatMessage.SenderType.CHATBOT, builder.toString());
            break;

        case EXIT:
            this.closeConversation();
            break;

        default:
            break;
        }
    }

    /**
     * Method to send a message to the chatbot from the user.
     *
     * @param message The message string to send.
     * @return The resulting message sent.
     * @throws ChatbotRuntimeException if the conversation is closed.
     */

    /**
     * Internal method to send a message.
     *
     * @param message The message to send.
     * @return The resulting message sent.
     */

    /**
     * Internal method to process newly received messages.
     *
     * @param message The message to process.
     */

    /**
     * Whether the task is marked as completed.
     *
     * @return true if completed, false otherwise.
     */