[thezerohour] iP

.gitignore

@@ -15,3 +15,6 @@ bin/
 
 /text-ui-test/ACTUAL.TXT
 text-ui-test/EXPECTED-UNIX.TXT
+
+#testing data
+/data/

docs/README.md

@@ -1,30 +1,89 @@
-# Duke User Guide
+# Pixy User Guide
 
-// Update the title above to match the actual product name
+```
+Hello! I'm Pixy
+What can I do for you?
+```
+
+Pixy allows you to manage your tasks with ease, while having an anti-border tendency.
+
+## Adding ToDos
+
+`todo {taskName}`
+
+Adds a todo task with the specified task name.
+
+```
+todo added: [T][ ] add new task
+```
+
+## Adding Deadlines
+
+`deadline {taskName} /by {deadline}`
+
+Adds a deadline task with the specified task name and deadline.
+
+```
+deadline added: [D][ ] add new deadline (by: yesterday)
+```
+
+## Adding Events
 
-// Product screenshot goes here
+`event {eventName} /from {eventStart} /to {eventEnd}` 
 
-// Product intro goes here
+Adds an event task with the specified event name, start time and end time.
 
-## Adding deadlines
+```
+event added: [E][ ] erase all borders (from: 25 Dec 1995, to: 31 Dec 1995)
+```
+
+## Listing Tasks
+
+`list`
 
-// Describe the action and its outcome.
+Lists all tasks in the task list.
 
-// Give examples of usage
+```
+Here are the tasks in your list:
+[T][ ] add new task
+[D][ ] add new deadline (by: yesterday)
+[E][ ] erase all borders (from: 25 Dec 1995, to: 31 Dec 1995)
+```
 
-Example: `keyword (optional arguments)`
+## Marking Task as done
 
-// A description of the expected outcome goes here
+`mark {taskNumber}`
 
+Marks the task with the specified task number as done.
 ```
-expected output
+Nice! I've marked this task as done:
+[T][X] add new task
 ```
 
-## Feature ABC
+## Marking Task as undone
+
+`unmark {taskNumber}`
+
+Marks the task with the specified task number as undone.
 
-// Feature details
+## Deleting Tasks
 
+`delete {taskNumber}`
 
-## Feature XYZ
+Deletes the task with the specified task number.
 
-// Feature details
+```
+OK, I've marked this task as not done yet:
+[T][ ] add new task
+```
+
+## Searching Tasks
+
+`find {keyword}`
+
+Searches for tasks with the specified keyword.
+
+```
+Here are the matching tasks in your list:
+[E][ ] erase all borders (from: 25 Dec 1995, to: 31 Dec 1995)
+```

src/main/java/META-INF/MANIFEST.MF

@@ -0,0 +1,3 @@
+Manifest-Version: 1.0
+Main-Class: pixy.ui.Pixy
+

src/main/java/pixy/parser/Parser.java

@@ -0,0 +1,136 @@
+package pixy.parser;
+
+import pixy.ui.PixyException;
+import pixy.task.Deadline;
+import pixy.task.Event;
+import pixy.task.TaskList;
+import pixy.task.Todo;
+
+/**
+ * The Parser class is responsible for parsing user commands and executing corresponding actions on the TaskList.
+ */
+public class Parser {
+    private static final String MESSAGE_INVALID_TIME = "invalid time >:(";
+    private static final String MESSAGE_EMPTY_DESCRIPTION = "empty description >:(";
+
+    /**
+     * Parses the user input and executes the corresponding command.
+     *
+     * @param input the user input to be parsed
+     * @param taskList the task list to be modified
+     * @throws PixyException if an error occurs during parsing or execution of the command
+     */
+    public static void parseCommand(String input, TaskList taskList) throws PixyException {
+        String command = input.trim().split(" ")[0];
+        switch (command) {
+        case "list" -> taskList.printTasks();
+        case "unmark" -> unmarkTask(input, taskList);
+        case "mark" -> markTask(input, taskList);
+        case "delete" -> deleteTask(input, taskList);
+        case "todo" -> addTodo(input, taskList);
+        case "deadline" -> addDeadline(input, taskList);
+        case "event" -> addEvent(input, taskList);
+        case "find" -> findTasks(input, taskList);
+        default -> invalidCommand();
+        }
+    }
+
+    /**
+     * Deletes a task from the task list based on the given input.
+     *
+     * @param input the input string containing the task index to be deleted
+     * @param taskList the task list from which the task will be deleted
+     */
+    private static void deleteTask(String input, TaskList taskList) {
+        int taskIndex = Integer.parseInt(input.substring(7)) - 1;
+        System.out.println("Noted. I've removed this task:");
+        System.out.println(taskList.deleteTask(taskIndex));
+    }
+
+    private static void invalidCommand() {
+        System.out.println("not a command!");
+    }
+
+    /**
+     * Adds an event task to the task list.
+     *
+     * @param input the input string containing the event task details
+     * @param taskList the task list to add the event task to
+     * @throws PixyException if the input string does not contain "/from" or "/to"
+     */
+    private static void addEvent(String input, TaskList taskList) throws PixyException {
+        if (!input.contains(" /from ") || !input.contains(" /to ")) {
+            throw new PixyException(MESSAGE_INVALID_TIME);
+        }
+        String[] eventTask = input.substring(6).split(" /from ", 2);
+        String[] eventTime = eventTask[1].split(" /to ", 2);
+        taskList.addTask(new Event(eventTask[0], eventTime[0], eventTime[1]));
+    }
+
+    /**
+     * Adds a deadline task to the task list.
+     *
+     * @param input the input string containing the task details and deadline
+     * @param taskList the task list to add the deadline task to
+     * @throws PixyException if the input string does not contain the "/by" delimiter
+     */
+    private static void addDeadline(String input, TaskList taskList) throws PixyException {
+        if (!input.contains(" /by ")) {
+            throw new PixyException(MESSAGE_INVALID_TIME);
+        }
+        String[] deadlineTask = input.substring(9).split(" /by ", 2);
+        taskList.addTask(new Deadline(deadlineTask[0], deadlineTask[1]));
+    }
+
+    /**
+     * Adds a new Todo task to the task list.
+     *
+     * @param input the input string containing the description of the task
+     * @param taskList the task list to add the task to
+     * @throws PixyException if the description is empty
+     */
+    private static void addTodo(String input, TaskList taskList) throws PixyException {
+        String description = input.substring(input.indexOf(" ") + 1);
+        if (description.isBlank()) {
+            throw new PixyException(MESSAGE_EMPTY_DESCRIPTION);
+        }
+        taskList.addTask(new Todo(description));
+    }
+
+    /**
+     * Marks a task as done in the task list.
+     *
+     * @param input the input string containing the task index
+     * @param taskList the task list to mark the task in
+     */
+    private static void markTask(String input, TaskList taskList) {
+        int taskIndex = Integer.parseInt(input.substring(5)) - 1;
+        taskList.markTask(taskIndex, true);
+        System.out.println("Nice! I've marked this task as done:");
+        System.out.println(taskList.getTask(taskIndex));
+    }
+
+    /**
+     * Unmarks a task as not done yet.
+     *
+     * @param input the input string containing the task index
+     * @param taskList the task list to modify
+     */
+    private static void unmarkTask(String input, TaskList taskList) {
+        int taskIndex = Integer.parseInt(input.substring(7)) - 1;
+        taskList.markTask(taskIndex, false);
+        System.out.println("OK, I've marked this task as not done yet:");
+        System.out.println(taskList.getTask(taskIndex));
+    }
+
+    /**
+     * Finds tasks in the given input and searches for them in the task list.
+     *
+     * @param input The input string containing the keyword to search for tasks.
+     * @param taskList The task list to search for tasks in.
+     */
+    private static void findTasks(String input, TaskList taskList) {
+        String keyword = input.substring(5).trim();
+        taskList.searchTasks(keyword);
+    }
+}

src/main/java/pixy/storage/Storage.java

@@ -0,0 +1,82 @@
+package pixy.storage;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.List;
+import pixy.task.Task;
+import pixy.task.Todo;
+import pixy.task.Deadline;
+import pixy.task.Event;
+
+/**
+ * The `Storage` class is responsible for saving and loading tasks to/from a file.
+ * It provides methods to save a list of tasks to a specified file path and load tasks from an existing file.
+ */
+public class Storage {
+    private final String filePath;
+
+    public Storage(String filePath) {
+        this.filePath = filePath;
+    }
+
+    /**
+     * Saves the given list of tasks to a file.
+     *
+     * @param tasks The list of tasks to be saved.
+     */
+    public void saveTasksToFile(List<Task> tasks) {
+        try {
+            File file = new File(filePath);
+            file.getParentFile().mkdirs(); // Create directories if they do not exist
+            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
+                for (Task task : tasks) {
+                    writer.write(task.toFileFormat());
+                    writer.newLine();
+                }
+            }
+        } catch (IOException e) {
+            System.out.println("An error occurred while saving tasks: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Loads tasks from a file and adds them to the provided list of tasks.
+     *
+     * @param tasks The list of tasks to add the loaded tasks to.
+     */
+    public void loadTasksFromFile(List<Task> tasks) {
+        try {
+            File file = new File(filePath);
+            if (!file.exists()) {
+                return; // If the file does not exist, there's nothing to load
+            }
+            try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
+                String line;
+                while ((line = reader.readLine()) != null) {
+                    String[] parts = line.split(" \\| ");
+                    String type = parts[0];
+                    boolean isDone = parts[1].equals("1");
+                    String description = parts[2];
+                    switch (type) {
+                    case "T" -> tasks.add(new Todo(description, isDone));
+                    case "D" -> {
+                        String by = parts[3];
+                        tasks.add(new Deadline(description, by, isDone));
+                    }
+                    case "E" -> {
+                        String from = parts[3];
+                        String to = parts[4];
+                        tasks.add(new Event(description, from, to, isDone));
+                    }
+                    }
+                }
+            }
+        } catch (IOException e) {
+            System.out.println("An error occurred while loading tasks: " + e.getMessage());
+        }
+    }
+}

src/main/java/pixy/task/Deadline.java

@@ -0,0 +1,48 @@
+package pixy.task;
+
+/**
+ * Represents a task with a deadline.
+ * Inherits from the Task class.
+ */
+public class Deadline extends Task {
+    protected String by;
+
+    /**
+     * Creates a new Deadline task with the given description and deadline.
+     *
+     * @param description The description of the Deadline task.
+     * @param by The deadline of the task.
+     */
+    public Deadline(String description, String by) {
+        super(description);
+        this.by = by;
+        System.out.println("deadline added: " + this);
+    }
+
+    /**
+     * Constructs a new Deadline object with the given description, due date, and completion status.
+     *
+     * @param description the description of the deadline
+     * @param by the due date of the deadline
+     * @param isDone the completion status of the deadline
+     */
+    public Deadline(String description, String by, boolean isDone) {
+        super(description, isDone);
+        this.by = by;
+    }
+
+    @Override
+    protected String getTaskType() {
+        return "D";
+    }
+
+    @Override
+    public String toFileFormat() {
+        return String.format("%s | %d | %s | %s", getTaskType(), isDone ? 1 : 0, description, by);
+    }
+
+    @Override
+    public String toString() {
+        return "[D]" + super.toString() + " (by: " + by + ")";
+    }
+}