[Nguyen D.Q. Minh] iP

data/data.txt

@@ -0,0 +1 @@
+0

src/main/java/Deadline.java

@@ -0,0 +1,18 @@
+public class Deadline extends Task {
+    protected String by;
+
+    public Deadline(String description, String by) {
+        super(description);
+        this.by = by;
+    }
+
+    public Deadline(String description, boolean isDone, String by) {
+        super(description, isDone);
+        this.by = by;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[D]%s (by: %s)", super.toString(), this.by);
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,87 @@
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
 public class Duke {
-    public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+    private TaskList tasks;
+    private Storage storage;
+    private UI ui;
+
+    public Duke() {
+        ui = new UI();
+        tasks = new TaskList();
+        String directory = System.getProperty("user.dir");
+        Path filePath = Paths.get(directory, "data", "data.txt");
+        storage = new Storage(filePath);
+        try {
+            tasks = new TaskList(storage.loadData());
+        } catch (Exception e) {
+            ui.displayError(e);
+        }
+    }
+
+    public void execute() throws Exception {
+        ui.greetings();
+        boolean isHalted = false;
+        while (!isHalted) {
+            String command = ui.readCommand();
+            Parser parser = new Parser(command);
+            String commandType = parser.getCommandType();
+            switch (commandType) {
+                case "bye": {
+                    isHalted = true;
+                    break;
+                }
+                case "list": {
+                    ui.displayMessage("Here are the tasks in your list:");
+                    for (int i = 0; i < tasks.size(); ++i) {
+                        ui.displayFormat("%d. %s\n", i + 1, tasks.get(i));
+                    }
+                    break;
+                }
+                case "done": {
+                    int index = parser.getIndex();
+                    if (index >= tasks.size()) {
+                        throw new DukeException(":( OOPS!!! Task index not found.");
+                    }
+                    tasks.get(index).markAsDone();
+                    ui.displayMessage("Nice! I've marked this task as done:");
+                    ui.displayMessage(tasks.get(index).toString());
+                    break;
+                }
+                case "delete": {
+                    int index = parser.getIndex();
+                    if (index >= tasks.size()) {
+                        throw new DukeException(":( OOPS!!! Task index not found.");
+                    }
+                    ui.displayMessage("Noted. I've removed this task:");
+                    ui.displayMessage(tasks.get(index).toString());
+                    tasks.removeTask(index);
+                    ui.displayFormat("Now you have %d tasks in the list.\n", tasks.size());
+                    break;
+                }
+                case "add": {
+                    Task newTask = parser.getTask();
+                    tasks.addTask(newTask);
+                    ui.displayMessage("Got it. I've added this task:");
+                    ui.displayMessage(newTask.toString());
+                    ui.displayFormat("Now you have %d tasks in the list\n", tasks.size());
+                    break;
+                }
+                default: {
+                    throw new Exception("Unexpected error");
+                }
+            }
+        }
+
+        try {
+            storage.saveData(tasks.getTasks());
+        } catch(Exception e) {
+            ui.displayError(e);
+        }
+        ui.bye();
+    }
+
+    public static void main(String[] args) throws Exception {
+        new Duke().execute();
     }
 }

src/main/java/DukeException.java

@@ -0,0 +1,5 @@
+public class DukeException extends Exception {
+    public DukeException(String message) {
+        super(message);
+    }
+}

src/main/java/Event.java

@@ -0,0 +1,18 @@
+public class Event extends Task {
+    protected String at;
+
+    public Event(String description, String at) {
+        super(description);
+        this.at = at;
+    }
+
+    public Event(String description, boolean isDone, String at) {
+        super(description, isDone);
+        this.at = at;
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[E]%s (at: %s)", super.toString(), this.at);
+    }
+}

src/main/java/Parser.java

@@ -0,0 +1,81 @@
+public class Parser {
+    private Task task;
+    private String commandType;
+    private int index;
+
+    public Parser(String command) {
+        this.commandType = "undefined";
+        try {
+            if (command.equals("bye")) {
+                this.commandType = "bye";
+            } else if (command.equals("list")) {
+                this.commandType = "list";
+            } else if (command.startsWith("done")) {
+                if (command.length() < 5) {
+                    throw new DukeException(":( OOPS!!! Task index not found.");
+                }
+                this.commandType = "done";
+                this.index = Integer.parseInt(command.substring(5)) - 1;
+            } else if (command.startsWith("delete")) {
+                if (command.length() < 7) {
+                    throw new DukeException(":( OOPS!!! Task index not found.");
+                }
+                this.commandType = "delete";
+                this.index = Integer.parseInt(command.substring(7)) - 1;
+            } else {
+                Task newTask = null;
+                if (command.startsWith("todo")) {
+                    if (command.length() < 5) {
+                        throw new DukeException(":( OOPS!!! The description of a todo cannot be empty.");
+                    }
+                    String description = command.substring(5);
+                    newTask = new Todo(description);
+                } else if (command.startsWith("deadline")) {
+                    if (command.length() < 9) {
+                        throw new DukeException(":( OOPS!!! The description of a deadline cannot be empty.");
+                    }
+                    String rest = command.substring(9);
+                    int by_position = rest.indexOf("/by ");
+                    if (by_position == -1) {
+                        throw new DukeException(":( OOPS!!! Deadline time specification not found.");
+                    }
+                    String description = rest.substring(0, by_position - 1);
+                    String by = rest.substring(by_position + 4);
+                    newTask = new Deadline(description, by);
+                } else if (command.startsWith("event")) {
+                    if (command.length() < 6) {
+                        throw new DukeException(":( OOPS!!! The description of an event cannot be empty.");
+                    }
+                    String rest = command.substring(6);
+                    int at_position = rest.indexOf("/at ");
+                    if (at_position == -1) {
+                        throw new DukeException(":( OOPS!!! Event time specification not found.");
+                    }
+                    String description = rest.substring(0, at_position - 1);
+                    String at = rest.substring(at_position + 4);
+                    newTask = new Event(description, at);
+                }
+
+                if (newTask == null) {
+                    throw new DukeException(":( OOPS!!! I'm sorry, but I don't know what that means :-(");
+                }
+                this.commandType = "add";
+                this.task = newTask;
+            }
+        } catch(DukeException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    public int getIndex() {
+        return this.index;
+    }
+
+    public Task getTask() {
+        return this.task;
+    }
+
+    public String getCommandType() {
+        return this.commandType;
+    }
+}

src/main/java/Storage.java

@@ -0,0 +1,45 @@
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+
+public class Storage {
+    private final Path filePath;
+
+    private void openFile() throws Exception {
+        if (!Files.exists(this.filePath)) {
+            Files.createDirectories(this.filePath.getParent());
+            Files.createFile(this.filePath);
+        }
+    }
+
+    public Storage(Path filePath) {
+        this.filePath = filePath;
+    }
+
+    public ArrayList<Task> loadData() throws Exception {
+        ArrayList<Task> tasks = new ArrayList<Task>();
+
+        openFile();
+        BufferedReader reader = Files.newBufferedReader(this.filePath);
+        int taskCount = Integer.parseInt(reader.readLine());
+        for(int i = 0; i < taskCount; ++i) {
+            tasks.add(TaskParser.parseTask(reader));
+        }
+        reader.close();
+        return tasks;
+    }
+
+    public void saveData(ArrayList<Task> tasks) throws Exception {
+        openFile();
+        BufferedWriter writer = Files.newBufferedWriter(this.filePath);
+        writer.write(String.valueOf(tasks.size()));
+        writer.newLine();
+        for(Task task : tasks) {
+            writer.write(task.toString());
+            writer.newLine();
+        }
+        writer.close();
+    }
+}

src/main/java/Task.java

@@ -0,0 +1,33 @@
+public class Task {
+    protected String description;
+    private boolean isDone;
+
+    public Task(String description) {
+        this.description = description;
+        this.isDone = false;
+    }
+
+    public Task(String description, boolean isDone) {
+        this.description = description;
+        this.isDone = isDone;
+    }
+
+    private String getStatusIcon() {
+        return isDone ? "O" : "X";
+    }
+
+    public boolean markAsDone() {
+        if (this.isDone) {
+            return false;
+        }
+        else {
+            this.isDone = true;
+            return true;
+        }
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[%s] %s", this.getStatusIcon(), this.description);
+    }
+}

src/main/java/TaskList.java

@@ -0,0 +1,33 @@
+import java.util.ArrayList;
+
+public class TaskList {
+    private ArrayList<Task> tasks;
+
+    public TaskList() {
+        this.tasks = new ArrayList<Task>();
+    }
+
+    public TaskList(ArrayList<Task> tasks) {
+        this.tasks = tasks;
+    }
+
+    public void addTask(Task newTask) {
+        tasks.add(newTask);
+    }
+
+    public void removeTask(int position) {
+        tasks.remove(position);
+    }
+
+    public ArrayList<Task> getTasks() {
+        return this.tasks;
+    }
+
+    public int size() {
+        return this.tasks.size();
+    }
+
+    public Task get(int position) {
+        return this.tasks.get(position);
+    }
+}

src/main/java/TaskParser.java

@@ -0,0 +1,38 @@
+import java.io.BufferedReader;
+
+public class TaskParser {
+    public static Task parseTask(BufferedReader sc) throws Exception {
+        String input = sc.readLine();
+        String taskType = input.substring(0, 3);
+        String status = input.substring(3, 6);
+        String rest = input.substring(7);
+        boolean isDone = (status.equals("[O]"));
+        Task result;
+
+        switch (taskType) {
+            case "[T]": {
+                result = new Todo(rest, isDone);
+                break;
+            }
+            case "[D]": {
+                int position = rest.indexOf("(by: ");
+                String description = rest.substring(0, position - 1);
+                String by = rest.substring(position + 4, rest.length() - 1);
+                result = new Deadline(description, isDone, by);
+                break;
+            }
+            case "[E]": {
+                int position = rest.indexOf("(at: ");
+                String description = rest.substring(0, position - 1);
+                String at = rest.substring(position + 4, rest.length() - 1);
+                result = new Deadline(description, isDone, at);
+                break;
+            }
+            default: {
+                throw new DukeException("Error while loading data.");
+            }
+        }
+
+        return result;
+    }
+}

src/main/java/Todo.java

@@ -0,0 +1,14 @@
+public class Todo extends Task {
+    public Todo(String description) {
+        super(description);
+    }
+
+    public Todo(String description, boolean isDone) {
+        super(description, isDone);
+    }
+
+    @Override
+    public String toString() {
+        return String.format("[T]%s", super.toString());
+    }
+}