[Aakansha Narain] iP

src/main/java/Duke.java

@@ -1,10 +1,64 @@
+//Solution below slightly adapted from https://github.com/Wincenttjoi/CS2103T-duke-chatbot/blob/master/src/main/java/duke/Duke.java
+
+import duke.*;
+
 public class Duke {
+
+    private Ui ui;
+    private TaskList taskList;
+    private boolean exit;
+
+    public Duke () {
+        this.ui = new Ui();
+        this.taskList = new TaskList();
+        exit = false;
+    }
+
+    public enum InputCommands {
+        bye, list, done, delete, todo, deadline, event
+    }
+
+    public void start () {
+        System.out.println(ui.greet());
+        while (!exit) {
+            try {
+                String userCommand = ui.echoCommand();
+
+                if (userCommand.equals("bye")) {
+                    System.out.println(ui.exit());
+                    exit = true;
+                } else if (userCommand.equals("list")) {
+                    System.out.println(ui.retrieveList());
+                } else if (userCommand.startsWith("done")) {
+                    InputHandler doneInputHandler = new DoneInput(ui, taskList);
+                    System.out.println(doneInputHandler.handle(userCommand));
+                } else if (userCommand.startsWith("delete")) {
+                    InputHandler deleteInputHandler = new DeleteInput(ui, taskList);
+                    System.out.println(deleteInputHandler.handle(userCommand));
+                } else if (userCommand.startsWith("todo")) {
+                    InputHandler todoInputHandler = new TodoInput(ui, taskList);
+                    System.out.println(todoInputHandler.handle(userCommand));
+                } else if (userCommand.startsWith("deadline")) {
+                    InputHandler deadlineInputHandler = new DeadlineInput(ui, taskList);
+                    System.out.println(deadlineInputHandler.handle(userCommand));
+                } else if (userCommand.startsWith("event")) {
+                    InputHandler eventInputHandler = new EventInput(ui, taskList);
+                    System.out.println(eventInputHandler.handle(userCommand));
+                } else if (userCommand.equals("listInputs")) {
+                    for (InputCommands inputs : InputCommands.values()) {
+                        System.out.println(inputs);
+                    }
+                }
+                else {
+                    throw new UnknownInputException("error");
+                }
+            } catch (DukeException e) {
+                ui.getError(e.getMessage());
+            }
+        }
+    }
+
     public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+        new Duke().start();
     }
 }

src/main/java/duke/Deadline.java

@@ -0,0 +1,16 @@
+package duke;
+
+public class Deadline extends Task {
+
+    protected String by;
+
+    public Deadline(String description, String by) {
+        super(description);
+        this.by = by;
+    }
+
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + " (by: " + by + ")";
+    }
+}

src/main/java/duke/DeadlineInput.java

@@ -0,0 +1,24 @@
+package duke;
+
+import duke.Deadline;
+
+public class DeadlineInput extends InputHandler {
+
+    public DeadlineInput(Ui ui, TaskList taskList) throws DukeException {
+        super(ui, taskList);
+    }
+
+    @Override
+    public String handle(String input) throws EmptyDescriptionException {
+        if (input.length() == 8) {
+            throw new EmptyDescriptionException("error" );
+        }
+        int charIndex = input.indexOf("/" );
+        int byIndex = charIndex + 4;
+        String by = input.substring(byIndex);
+        String task = input.substring(9, charIndex - 1);
+        Task deadlineTask = new Deadline(task, by);
+        taskList.add(deadlineTask);
+        return ui.addedTask(deadlineTask);
+    }
+}

src/main/java/duke/DeleteInput.java

@@ -0,0 +1,23 @@
+package duke;
+
+public class DeleteInput extends InputHandler {
+
+    public DeleteInput(Ui ui, TaskList taskList) {
+        super(ui, taskList);
+    }
+
+    @Override
+    public String handle(String input) throws EmptyDescriptionException {
+        if (input.length() == 6) {
+            throw new EmptyDescriptionException("error");
+        }
+
+        char taskIndex = input.charAt(7);
+        int index = Integer.parseInt(String.valueOf(taskIndex));
+
+        Task taskAtIndex = taskList.getTask(index);
+
+        taskList.removeTask(index);
+        return ui.deletedTask(taskAtIndex);
+    }
+}

src/main/java/duke/DoneInput.java

@@ -0,0 +1,24 @@
+package duke;
+
+public class DoneInput extends InputHandler {
+
+    public DoneInput(Ui ui, TaskList taskList) throws DukeException {
+        super(ui, taskList);
+    }
+
+    @Override
+    public String handle (String input) throws EmptyDescriptionException {
+        if (input.length() == 4) {
+            throw new EmptyDescriptionException("error");
+        }
+
+        char taskIndex = input.charAt(5);
+        int index = Integer.parseInt(String.valueOf(taskIndex));
+
+        Task taskAtIndex = taskList.getTask(index);
+        taskAtIndex.markAsDone();
+
+        return ui.doneTask(taskAtIndex);
+    }
+
+}

src/main/java/duke/DukeException.java

@@ -0,0 +1,9 @@
+package duke;
+
+public class DukeException extends Exception{
+
+    public DukeException (String e) {
+        super(e);
+    }
+
+}

src/main/java/duke/EmptyDescriptionException.java

@@ -0,0 +1,8 @@
+package duke;
+
+public class EmptyDescriptionException extends DukeException{
+
+    public EmptyDescriptionException(String e) {
+        super("Error: The description of that command cannot be empty. Please enter a description.");
+    }
+}

src/main/java/duke/Event.java

@@ -0,0 +1,17 @@
+package duke;
+
+public class Event extends Task {
+
+    private String at;
+
+
+    public Event(String description, String at) {
+        super(description);
+        this.at = at;
+    }
+
+    @Override
+    public String toString() {
+        return "[E]" + super.toString() + " (at: " + at + ")";
+    }
+}

src/main/java/duke/EventInput.java

@@ -0,0 +1,27 @@
+package duke;
+
+import duke.Event;
+
+public class EventInput extends InputHandler {
+
+
+    public EventInput(Ui ui, TaskList taskList) throws DukeException {
+        super(ui, taskList);
+    }
+
+    public String handle(String input) throws EmptyDescriptionException {
+        if (input.length() == 5) {
+            throw new EmptyDescriptionException("error" );
+        }
+        int charIndex = input.indexOf("/" );
+        int atIndex = charIndex + 4;
+
+        String at = input.substring(atIndex);
+        String task = input.substring(6, charIndex - 1);
+
+        Task eventTask = new Event(task, at);
+        taskList.add(eventTask);
+
+        return ui.addedTask(eventTask);
+    }
+}

src/main/java/duke/InputHandler.java

@@ -0,0 +1,14 @@
+package duke;
+
+public abstract class InputHandler {
+    protected Ui ui;
+    protected TaskList taskList;
+
+    public InputHandler(Ui ui, TaskList taskList) {
+        this.taskList = taskList;
+        this.ui = ui;
+    }
+
+    public abstract String handle(String input) throws EmptyDescriptionException;
+
+}

src/main/java/duke/Task.java

@@ -0,0 +1,25 @@
+package duke;
+
+public class Task {
+    protected String description;
+    protected boolean isDone;
+
+    public Task(String description) {
+        this.description = description;
+        this.isDone = false;
+    }
+
+    public String getStatusIcon() {
+        return (isDone ? "X" : " "); // mark done task with X
+    }
+
+    public void markAsDone () {
+        this.isDone = true;
+    }
+
+    @Override
+    public String toString () {
+        return "[" + getStatusIcon() + "] " + this.description;
+    }
+
+}

src/main/java/duke/TaskList.java

@@ -0,0 +1,28 @@
+package duke;
+
+import java.util.ArrayList;
+
+public class TaskList {
+    private static ArrayList<Task> todoList;
+
+    public TaskList() {
+        todoList = new ArrayList<>();
+    }
+
+    public static ArrayList<Task> getTodoList () {
+        return todoList;
+    }
+
+    public void add (Task task) {
+        todoList.add(task);
+    }
+
+    public Task getTask (int index) {
+        return todoList.get(index - 1);
+    }
+
+    public void removeTask (int index) {
+        todoList.remove(index - 1);
+    }
+
+}

src/main/java/duke/Todo.java

@@ -0,0 +1,13 @@
+package duke;
+
+public class Todo extends Task {
+
+    public Todo(String description) {
+        super(description);
+    }
+
+    @Override
+    public String toString() {
+        return "[T]" + super.toString();
+    }
+}

src/main/java/duke/TodoInput.java

@@ -0,0 +1,20 @@
+package duke;
+
+public class TodoInput extends InputHandler {
+
+    public TodoInput(Ui ui, TaskList taskList) throws DukeException {
+        super(ui, taskList);
+    }
+
+    public String handle(String input) throws EmptyDescriptionException {
+        if (input.length() == 4) {
+            throw new EmptyDescriptionException("error");
+        }
+
+        String task = input.substring(5);
+        Task toDoTask = new Todo(task);
+
+        taskList.add(toDoTask);
+        return ui.addedTask(toDoTask);
+    }
+}

src/main/java/duke/Ui.java

@@ -0,0 +1,61 @@
+package duke;
+
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Ui {
+
+    private static final String GREET = "Hi there! My name's Duke, how can I help you today?";
+    private static final String EXIT = "Bye! See you next time!";
+
+    private Scanner sc;
+
+    public Ui() {
+        this.sc = new Scanner(System.in);
+    }
+
+    public String greet () {
+        return GREET;
+    }
+
+    public String exit () {
+        return EXIT;
+    }
+
+    public String echoCommand () {
+        return sc.nextLine();
+    }
+
+    public String retrieveList() {
+        ArrayList<Task> list = TaskList.getTodoList();
+        if (list.size() == 0) {
+            return "You currently have no tasks!";
+        } else {
+            String userList = "";
+            for (Task task : list) {
+                userList =  userList + (list.indexOf(task) + 1) + ". " + task.toString() + "\n";
+            }
+            return "Here are the tasks in your list:\n" + userList;
+        }
+    }
+
+    public String addedTask(Task task) {
+        return String.format("Got it. I've added this task:\n %s\nNow you have %d tasks in the list.",
+                task.toString(), TaskList.getTodoList().size());
+    }
+
+    public String doneTask (Task task) {
+        return String.format("Nice! I've marked this task as done:\n %s", task.toString());
+    }
+
+    public String deletedTask(Task task) {
+        return String.format("Noted. I've removed this task:\n %s\nNow you have %d tasks in the list.",
+                task.toString(), TaskList.getTodoList().size());
+    }
+
+    public void getError(String e) {
+        System.out.println(e);
+    }
+
+
+}