diff --git a/README.md b/README.md
index 90aa7f092..831573b25 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-# Duke project template
+# Quinn project template
This is a project template for a greenfield Java project. It's named after the Java mascot _Duke_. Given below are instructions on how to use it.
@@ -13,12 +13,15 @@ Prerequisites: JDK 17, update Intellij to the most recent version.
1. If there are any further prompts, accept the defaults.
1. Configure the project to use **JDK 17** (not other versions) as explained in [here](https://www.jetbrains.com/help/idea/sdk.html#set-up-jdk).` /by ` /from /to ` `
+Example: `mark 1`
+
+### Unmarking Tasks
+Command: `unmark `
+Example: `unmark 2`
+
+### Deleting Tasks
+Command: `delete `
+Example: `delete 3`
+
+### Finding Tasks
+Command: `find `
+Example: `find meeting`
+
+### Exiting the Application
+Command: `bye`
+
+
+## Command Reference
+Here is a quick reference for all available commands:
+
+• todo [description]: Add a ToDo task
+
+
+• Deadline: A task with a specific due date and time.
+
+Displayed as: [D][ ] (by: Date Time)
+
+
+• Event: A task with a start and end date/time.
+
+Displayed as: [E][ ] (from: Start Date Time to: End Date Time)
+
+The square brackets next to the task type indicator (T/D/E) show the task's completion status: tasks;
+ private List filteredTasks;
+ private CommandType filterCommandType;
+ private String filterInfo;
+
+ /**
+ * Constructs an empty TaskList.
+ * Initializes the main task list and the filtered task list.
+ */
+ public TaskList() {
+ this.tasks = new ArrayList();
+ filteredTasks = new ArrayList<>();
+ filterCommandType = null;
+ filterInfo = null;
+ }
+
+ /**
+ * Returns the total number of tasks in the list.
+ *
+ * @return the number of tasks in the main task list.
+ */
+ public int getNumOfTasks() {
+ return tasks.size();
+ }
+
+ /**
+ * Returns the number of tasks in the filtered list.
+ *
+ * @return the number of tasks in the filtered task list
+ */
+ public int getNumOfFilteredTasks() {
+ return filteredTasks.size();
+ }
+
+ /**
+ * Retrieves a task from the main task list by its index.
+ *
+ * @param index the index of the task to retrieve (0-based)
+ * @return the Task at the specified index
+ * @throws IndexOutOfBoundsException if the index is out of range
+ */
+ public Task getTask(int index) {
+ return tasks.get(index);
+ }
+
+ /**
+ * Retrieves a task from the filtered task list by its index.
+ *
+ * @param index the index of the task to retrieve from the filtered list (0-based)
+ * @return the Task at the specified index in the filtered list
+ * @throws IndexOutOfBoundsException if the index is out of range
+ */
+ public Task getFilteredTask(int index) {
+ return filteredTasks.get(index);
+ }
+
+ /**
+ * Checks if there is an active filter applied to the task list.
+ *
+ * @return true if there are tasks in the filtered list, false otherwise
+ */
+ public boolean hasFilter() {
+ return !filteredTasks.isEmpty();
+ }
+
+ /**
+ * Retrieves the type of command that was used to apply the current filter.
+ *
+ * @return the CommandType of the current filter, or null if no filter is applied
+ */
+ public CommandType getFilterCommandType() {
+ return filterCommandType;
+ }
+
+ /**
+ * Retrieves the information used for the current filter.
+ *
+ * @return the filter information (e.g., keyword for search), or null if no filter is applied
+ */
+ public String getFilterInfo() {
+ return filterInfo;
+ }
+
+ /**
+ * Resets the filtered task list and clears filter information.
+ * This method is typically called when a new operation that affects all tasks is performed.
+ * This method is called in the following scenarios:
+ * When a new task is added
+ * When the list command is executed
+ * When the exit command is executed
+ * When a delete command is executed and the filtered list becomes empty
+ */
+ public void resetFilteredTasks() {
+ filteredTasks = new ArrayList<>();
+ filterCommandType = null;
+ filterInfo = null;
+ }
+
+ /**
+ * Filters the tasks based on a given keyword and updates the filtered task list.
+ *
+ * @param keyword the keyword to search for in task descriptions
+ */
+ public void setFilteredTasksByKeyword(String keyword) {
+ filteredTasks = new ArrayList<>();
+
+ // Iterate through each task and filter those that contain the keyword
+ for (Task task : tasks) {
+ if (task.hasKeyword(keyword)) {
+ filteredTasks.add(task);
+ }
+ }
+
+ filterCommandType = CommandType.FIND;
+ filterInfo = keyword;
+ }
+
+ /**
+ * Adds a new ToDo task to the task list.
+ * also resets any active filter.
+ * @param description the description of the ToDo task
+ * @return the newly created ToDo task
+ */
+ public Task addToDoTask(String description) {
+ Task toDoTask = new ToDo(description);
+ addTask(toDoTask);
+ return toDoTask;
+ }
+
+ /**
+ * Adds a new Deadline task to the task list.
+ * also resets any filter
+ * @param description the description of the Deadline task
+ * @param dueDateTime the due date and time of the Deadline task. This should be in the format "yyyy-MM-dd HHmm".
+ * @return the newly created Deadline task
+ */
+ public Task addDeadlineTask(String description, String dueDateTime) {
+ Task deadlineTask = new Deadline(description, dueDateTime);
+ addTask(deadlineTask);
+ return deadlineTask;
+ }
+
+ /**
+ * Adds a new Event task to the task list.
+ * also resets any filter
+ * @param description the description of the Event task
+ * @param startDateTime the start date and time of the Event task. This should be in the format "yyyy-MM-dd HHmm".
+ * @param endDateTime the end date and time of the Event task. This should be in the format "yyyy-MM-dd HHmm".
+ * @return the newly created Event task
+ */
+ public Task addEventTask(String description, String startDateTime, String endDateTime) {
+ Task eventTask = new Event(description, startDateTime,endDateTime);
+ addTask(eventTask);
+ return eventTask;
+ }
+
+ /**
+ * Adds a task to the main task list.
+ *
+ * @param task the task to be added
+ */
+ public void addTask(Task task) {
+ tasks.add(task);
+ }
+
+
+ /**
+ * Marks a task as done.
+ *
+ * @param taskNum the number of the task to be marked as done (1-based index)
+ * @return the task that was marked as done
+ * @throws IndexOutOfBoundsException if the task number is out of range
+ */
+ public Task markDone(int taskNum) {
+ Task task = !hasFilter() ? getTask(taskNum - 1) : getFilteredTask(taskNum - 1);
+ task.setDone();
+ return task;
+ }
+
+ /**
+ * Marks a task as not done.
+ *
+ * @param taskNum the number of the task to be marked as not done (1-based index)
+ * @return the task that was marked as not done
+ * @throws IndexOutOfBoundsException if the task number is out of range
+ */
+ public Task markNotDone(int taskNum) {
+ Task task = !hasFilter() ? getTask(taskNum - 1) : getFilteredTask(taskNum - 1);
+ task.setNotDone();
+ return task;
+ }
+
+ /**
+ * Deletes a task from the task list.
+ *
+ * @param taskNum the number of the task to be deleted (1-based index)
+ * @return the task that was deleted
+ * @throws IndexOutOfBoundsException if the task number is out of range
+ */
+ public Task deleteTask(int taskNum) {
+ Task task = !hasFilter() ? getTask(taskNum - 1) : getFilteredTask(taskNum - 1);
+ tasks.remove(task);
+
+ if (hasFilter()) {
+ filteredTasks.remove(task);
+ }
+
+ return task;
+ }
+
+ /**
+ * Generates a string representation of all tasks in the main task list.
+ *
+ * @return a formatted string containing all tasks, each on a new line
+ */
+ public String listOfTasksString() {
+ StringBuilder listBuilder = new StringBuilder();
+
+ for (int i = 0; i < getNumOfTasks(); i++) {
+ String listItem = (i + 1) + "." + "\t" + getTask(i);
+
+ if (i != 0) {
+ listBuilder.append(System.lineSeparator());
+ }
+
+ listBuilder.append("\t").append(listItem);
+ }
+
+ return listBuilder.toString();
+ }
+
+ /**
+ * Generates a string representation of all tasks in the filtered task list.
+ *
+ * @return a formatted string containing all filtered tasks, each on a new line
+ */
+ public String listOfFilteredTasksString() {
+ StringBuilder listBuilder = new StringBuilder();
+
+ for (int i = 0; i < getNumOfFilteredTasks(); i++) {
+ String listItem = (i + 1) + "." + "\t" + getFilteredTask(i);
+
+ if (i != 0) {
+ listBuilder.append(System.lineSeparator());
+ }
+
+ listBuilder.append("\t").append(listItem);
+ }
+
+ return listBuilder.toString();
+ }
+
+ /**
+ * Returns a string representation of the task list.
+ *
+ * @return a string representing all tasks or filtered tasks if a filter is applied
+ */
+ @Override
+ public String toString() {
+ return !hasFilter() ? listOfTasksString() : listOfFilteredTasksString();
+ }
+}
diff --git a/src/main/java/quinn/task/TaskType.java b/src/main/java/quinn/task/TaskType.java
new file mode 100644
index 000000000..1f290345a
--- /dev/null
+++ b/src/main/java/quinn/task/TaskType.java
@@ -0,0 +1,45 @@
+package quinn.task;
+
+/**
+ * Enumerates the types of tasks available in the Quinn task management application.
+ * This enum defines the different categories of tasks that can be created and managed within the system.
+ *
+ */
+public enum TaskType {
+ /**
+ * Represents a ToDo task.
+ * A ToDo task is a simple task without any specific date or time constraints.
+ */
+ TODO("T"),
+
+ /**
+ * A Deadline task is associated with a specific due date and time.
+ */
+ DEADLINE("D"),
+
+ /**
+ * An Event task is associated with both a start and end date and time.
+ */
+ EVENT("E");
+
+ /** The single-character abbreviation used to represent the task type. */
+ private final String abbreviation;
+
+ /**
+ * Constructs a TaskType with the specified abbreviation.
+ *
+ * @param abbreviation the single-character string used to represent this task type
+ */
+ TaskType(String abbreviation) {
+ this.abbreviation = abbreviation;
+ }
+
+ /**
+ * Retrieves the abbreviation associated with this task type.
+ *
+ * @return the single-character string abbreviation of this task type
+ */
+ public String getAbbreviation() {
+ return abbreviation;
+ }
+}
diff --git a/src/main/java/quinn/task/ToDo.java b/src/main/java/quinn/task/ToDo.java
new file mode 100644
index 000000000..41cec904f
--- /dev/null
+++ b/src/main/java/quinn/task/ToDo.java
@@ -0,0 +1,31 @@
+package quinn.task;
+
+/**
+ * Represents a ToDo task in the Quinn task management application.
+ * A ToDo task is the simplest form of task, consisting of a description without any specific date or time constraints.
+ *
+ * This class extends the abstract {@link Task} class and inherits its basic properties and methods.
+ * It does not add any additional fields or methods beyond those provided by the parent class.
+ */
+public class ToDo extends Task {
+ /**
+ * Constructs a new ToDo task with the given description.
+ * The task is initially marked as not done.
+ *
+ * @param description the description of the ToDo task
+ */
+ public ToDo(String description) {
+ super(TaskType.TODO, description);
+ }
+
+ /**
+ * Constructs a new ToDo task with the given description and completion status.
+ * This constructor is primarily used when loading tasks from storage.
+ *
+ * @param description the description of the ToDo task
+ * @param isDone the initial completion status of the task
+ */
+ public ToDo(String description, boolean isDone) {
+ super(TaskType.TODO, description, isDone);
+ }
+}
diff --git a/src/main/java/quinn/ui/Ui.java b/src/main/java/quinn/ui/Ui.java
new file mode 100644
index 000000000..07cbf3891
--- /dev/null
+++ b/src/main/java/quinn/ui/Ui.java
@@ -0,0 +1,203 @@
+package quinn.ui;
+
+import quinn.task.Task;
+import quinn.task.TaskList;
+
+import java.util.Scanner;
+
+/**
+ * The Ui (User Interface) class handles all interactions between the Quinn task management application
+ * and the user. It is responsible for displaying information to the user and reading user input.
+ * This class provides methods for reading commands, displaying various messages and task information,
+ * and formatting the output for better readability.
+ */
+public class Ui {
+
+ /**
+ * Constructs a new Ui object.
+ * This constructor doesn't initialize any fields as the Ui class currently has no instance variables.
+ */
+ public Ui() {
+ }
+
+ /**
+ * Reads a command from the user via the console.
+ *
+ * @return the user's input command as a trimmed string
+ */
+ public String readCommand() {
+ Scanner sc = new Scanner(System.in);
+ System.out.println("Enter Command:");
+ System.out.print("\t");
+ return sc.nextLine().trim();
+ }
+
+ /**
+ * Displays a welcome message and the Quinn logo when the application starts.
+ * This method prints the welcome message and logo to the console.
+ */
+ public void displayWelcome() {
+ String logo = "\t" + " QQQ U U III N N N N " + System.lineSeparator()
+ + "\t" + " Q Q U U I NN N NN N " + System.lineSeparator()
+ + "\t" + " Q Q U U I N N N N N N " + System.lineSeparator()
+ + "\t" + " Q Q U U I N NN N NN " + System.lineSeparator()
+ + "\t" + " QQQ UUU III N N N N " + System.lineSeparator()
+ + "\t" + " Q " + System.lineSeparator()
+ + "\t" + " QQ " + System.lineSeparator();
+
+ String welcomeMessage = "\t" + "Hello! I'm Quinn, your Personal Assistant ChatBot."
+ + System.lineSeparator()
+ + System.lineSeparator()
+ + logo
+ + System.lineSeparator()
+ + "\t" + "How can I help you?";
+
+ displayResponse(welcomeMessage);
+ displayLine();
+ }
+
+ /**
+ * Displays an exit message when the user chooses to exit the application.
+ * This method prints the farewell message to the console.
+ */
+ public void displayExit() {
+ String exitMessage = "\t" + "Farewell. Hope to see you again soon!";
+ displayResponse(exitMessage);
+ }
+
+
+ /**
+ * Displays a given message to the user, prefixed with a horizontal line for better readability.
+ *
+ * @param message the message to be displayed
+ */
+ public void displayResponse(String message) {
+ displayLine();
+ System.out.println(message);
+ }
+
+
+ /**
+ * Displays an error message to the user
+ *
+ * @param message the error message to be displayed
+ */
+ public void displayError(String message) {
+ displayLine();
+ System.out.println("Error Message:");
+ System.out.println("\t" + "('-')? " + message);
+ }
+
+ /**
+ * Displays a list of filtered tasks to the user.
+ *
+ * @param message the message containing the filtered task information
+ */
+ public void displayFilteredTasks(String message) {
+ displayLine();
+ System.out.println("[FILTERED TASKS]" + System.lineSeparator());
+ System.out.println(message);
+ }
+
+ /**
+ * Displays a horizontal line for separating different sections of output.
+ */
+ public void displayLine() {
+ String horizontalLine = "____________________________________________________________";
+ System.out.println(horizontalLine);
+ }
+
+
+ /**
+ * Generates a message indicating that a task has been added to the list.
+ *
+ * @param task the Task that was added
+ * @return a formatted string confirming the addition of the task
+ */
+ public String taskAddedMessage(Task task) {
+ return "\t" + "Got it. I've added this task:"
+ + System.lineSeparator() + "\t\t" + task;
+ }
+
+ /**
+ * Generates a message indicating that a task has been marked as done.
+ *
+ * @param task the Task that was marked as done
+ * @return a formatted string confirming the task has been marked as done
+ */
+ public String taskDoneMessage(Task task) {
+ return "\t" + "Roger! I've marked this task as done:"
+ + System.lineSeparator() + "\t\t" + task;
+ }
+
+ /**
+ * Generates a message indicating that a task has been marked as not done.
+ *
+ * @param task the Task that was marked as not done
+ * @return a formatted string confirming the task has been marked as not done
+ */
+ public String taskNotDoneMessage(Task task) {
+ return "\t" + "OK, I've marked this task as not done yet:"
+ + System.lineSeparator() + "\t\t" + task;
+ }
+
+ /**
+ * Generates a message indicating that a task has been deleted from the list.
+ *
+ * @param task the Task that was deleted
+ * @return a formatted string confirming the deletion of the task
+ */
+ public String taskDeletedMessage(Task task) {
+ return "\t" + "Roger. I've removed this task:"
+ + System.lineSeparator() + "\t\t" + task;
+ }
+
+ /**
+ * Generates a message indicating the current number of tasks in the list.
+ *
+ * @param taskList the TaskList containing the tasks
+ * @return a formatted string stating the number of tasks in the list
+ */
+ public String numOfTasksInListMessage(TaskList taskList) {
+ return "\t" + "Now you have " + taskList.getNumOfTasks()
+ + (taskList.getNumOfTasks() > 1 ? " tasks" : " task")
+ + " in the list.";
+ }
+
+ /**
+ * Generates a message listing all tasks currently in the task list.
+ *
+ * @param taskList the TaskList containing the tasks to be listed
+ * @return a formatted string containing all tasks in the list
+ */
+ public String tasksInListMessage(TaskList taskList) {
+ return "\t" + "Here"
+ + (taskList.getNumOfTasks() > 1 ? " are the tasks " : " is the task ")
+ + "in your list:"
+ + System.lineSeparator()
+ + "\t" + "[Legend: T = todo, D = deadline, E = event]"
+ + System.lineSeparator()
+ + System.lineSeparator()
+ + taskList;
+ }
+
+ /**
+ * Generates a message listing all tasks that match a given keyword.
+ *
+ * @param taskList the TaskList containing the filtered tasks
+ * @param keyword the keyword used for filtering the tasks
+ * @return a formatted string containing all tasks that match the keyword
+ */
+ public String tasksWithKeywordMessage(TaskList taskList, String keyword) {
+ return "\t" + "Here"
+ + (taskList.getNumOfFilteredTasks() > 1 ? " are the matching tasks " : " is the matching task ")
+ + "in your list:"
+ + System.lineSeparator()
+ + "\t" + "[Keyword Search: " + keyword + "]"
+ + System.lineSeparator()
+ + "\t" + "[Legend: T = todo, D = deadline, E = event]"
+ + System.lineSeparator()
+ + System.lineSeparator()
+ + taskList;
+ }
+}
diff --git a/text-ui-test/runtest.bat b/text-ui-test/runtest.bat
index 087374464..a71f37185 100644
--- a/text-ui-test/runtest.bat
+++ b/text-ui-test/runtest.bat
@@ -15,7 +15,7 @@ IF ERRORLEVEL 1 (
REM no error here, errorlevel == 0
REM run the program, feed commands from input.txt file and redirect the output to the ACTUAL.TXT
-java -classpath ..\bin Duke < input.txt > ACTUAL.TXT
+java -classpath ..\bin quinn.Quinn < input.txt > ACTUAL.TXT
REM compare the output to the expected output
FC ACTUAL.TXT EXPECTED.TXT