[rithanisk] iP

src/main/java/Deadline.java

@@ -0,0 +1,25 @@
+public class Deadline extends Task {
+    /**
+     * Constructs a Deadline task with the specified description and deadline
+     *
+     * @param description The description of the task provided by the user
+     * @param deadline The deadline of the task provided by the user
+     */
+    private String deadline;
+    public Deadline(String description, String deadline) {
+        super(description);
+        this.deadline = deadline;
+    }
+
+    /**
+     * Returns a string representation of the Deadline object.
+     * The string includes a "[D]" prefix to indicate that this is a Deadline task,
+     * followed by the string representation provided by the Task superclass.
+     *
+     * @return A string in the format: "[D] <super.toString()>"
+     */
+    @Override
+    public String toString() {
+        return "[D] " + super.toString() + "(by: " + this.deadline + ")";
+    }
+}

src/main/java/Event.java

@@ -0,0 +1,29 @@
+public class Event extends Task {
+    private String start;
+    private String end;
+
+    /**
+     * Constructs an Event task with the specified description, start time, and end time
+     *
+     * @param description The description of the task provided by the user
+     * @param start The start time of the task provided by the user
+     * @param end The end time of the task provided by the user
+     */
+    public Event(String description, String start, String end) {
+        super(description);
+        this.start = start;
+        this.end = end;
+    }
+
+    /**
+     * Returns a string representation of the Event object.
+     * The string includes a "[E]" prefix to indicate that this is an Event task,
+     * followed by the string representation provided by the Task superclass.
+     *
+     * @return A string in the format: "[E] <super.toString()>"
+     */
+    @Override
+    public String toString() {
+        return "[E] " + super.toString() + " (from: " + start + " to: " + end + ")";
+    }
+}

src/main/java/Nebula.java

@@ -0,0 +1,189 @@
+import java.util.Scanner;
+
+public class Nebula {
+    /**
+     * Entry point of the application. Initializes the UI, task list, and parser,
+     * then processes user commands in a loop until "bye" is entered
+     *
+     * @param args command-line arguments (not used)
+     */
+    public static void main(String[] args) {
+        Ui ui = new Ui();
+        TaskList taskList = new TaskList();
+        Parser parser = new Parser();
+
+        System.out.println(ui.greeting());
+
+        Scanner sc = new Scanner(System.in);
+        while(sc.hasNext()) {
+            String command = sc.nextLine();
+
+            if(command.equals("bye")) {
+                System.out.println(ui.goodbye());
+                break;
+            }
+
+            else if(command.equals("list")) {
+                System.out.println(ui.displayList());
+            }
+
+            else if(command.startsWith("mark")) {
+                try {
+                    validateCommand(command, taskList);
+                } catch (NebulaException e) {
+                    System.out.println(e.getMessage());
+                    continue;
+                }
+                int taskNum = parser.splitCommandAndTaskNumber(command);
+                System.out.println(taskList.markTask(taskNum));
+            }
+
+            else if(command.startsWith("unmark")) {
+                try {
+                    validateCommand(command, taskList);
+                } catch (NebulaException e) {
+                    System.out.println(e.getMessage());
+                    continue;
+                }
+                int taskNum = parser.splitCommandAndTaskNumber(command);
+                System.out.println(taskList.unmarkTask(taskNum));
+            }
+
+            else if(command.startsWith("delete")) {
+                try {
+                    validateCommand(command, taskList);
+                } catch (NebulaException e) {
+                    System.out.println(e.getMessage());
+                    continue;
+                }
+                int taskNum = parser.splitCommandAndTaskNumber(command);
+                System.out.println(taskList.deleteTask(taskNum));
+            }
+
+            else {
+                try {
+                    validateCommand(command, taskList);
+                } catch (NebulaException e) {
+                    System.out.println(e.getMessage());
+                    continue;
+                }
+
+                TaskType taskType = parseTaskType(command);
+
+                switch (taskType) {
+                    case TODO:
+                        String taskDescription = parser.splitCommandAndTaskDescription(command);
+                        Task newTodo = new Todo(taskDescription);
+                        String addedTodo = taskList.addTask(newTodo);
+                        System.out.println(addedTodo);
+                        break;
+
+                    case DEADLINE:
+                        String taskInformation = parser.splitCommandAndTaskDescription(command);
+                        String taskDescriptionDeadline = parser.splitDeadlineCommand(taskInformation)[0];
+                        String taskDeadline = parser.splitDeadlineCommand(taskInformation)[1];
+                        Task newDeadline = new Deadline(taskDescriptionDeadline, taskDeadline);
+                        String addedDeadline = taskList.addTask(newDeadline);
+                        System.out.println(addedDeadline);
+                        break;
+
+                    case EVENT:
+                        String taskInfo = parser.splitCommandAndTaskDescription(command);
+                        String taskDescriptionEvent = parser.splitEventCommand(taskInfo)[0];
+                        String startInfo = parser.splitEventCommand(taskInfo)[1];
+                        String endInfo = parser.splitEventCommand(taskInfo)[2];
+
+                        String taskStart = parser.splitCommandAndTaskDescription(startInfo);
+                        String taskEnd = parser.splitCommandAndTaskDescription(endInfo);
+
+                        Task newEvent = new Event(taskDescriptionEvent, taskStart, taskEnd);
+                        String addedEvent = taskList.addTask(newEvent);
+                        System.out.println(addedEvent);
+                        break;
+
+                    case UNKNOWN:
+                        System.out.println("Unknown command type.");
+                        break;
+                }
+
+            }
+
+        }
+
+
+    }
+
+    /**
+     * Validates the user's input for the correct format and content
+     *
+     * @param command  the user input command
+     * @param taskList the current list of tasks
+     * @throws NebulaException if the command is invalid or improperly formatted
+     */
+    public static void validateCommand(String command, TaskList taskList) throws NebulaException {
+        Parser parser = new Parser();
+        Ui ui = new Ui();
+
+        if (command.isEmpty()) {
+            throw new NebulaException("Please enter a command!");
+        } else if (!(command.startsWith("todo") || command.startsWith("deadline")
+                || command.startsWith("event") || command.startsWith("mark")
+                || command.startsWith("unmark") || command.startsWith("delete")
+                || command.startsWith("list") || command.startsWith("bye"))) {
+            throw new NebulaException(ui.displayUnknownCommandException());
+        } else if (command.startsWith("mark") || command.startsWith("unmark") || command.startsWith("delete")) {
+            String[] parts = command.split(" ", 2);
+            if (parts.length < 2 || parts[1].trim().isEmpty()) {
+                throw new NebulaException(ui.displayUnknownTaskNumberException());
+            }
+            try {
+                int taskIndex = Integer.parseInt(parts[1].trim()) - 1; // Convert to 0-based index
+                if (taskIndex < 0 || taskIndex >= TaskList.getTaskListLength()) {
+                    throw new NebulaException(ui.displayNonexistentTaskNumberException());
+                }
+            } catch (NumberFormatException e) {
+                throw new NebulaException(ui.displayUnknownTaskNumberException());
+            }
+        } else {
+            String[] parts = command.split(" ", 2);
+            if (parts.length < 2 || parts[1].trim().isEmpty()) {
+                throw new NebulaException(ui.displayUnknownMessageException());
+            }
+
+            String description = parts[1].trim();
+
+            if (command.startsWith("deadline")) {
+                if (!description.contains("/by")) {
+                    throw new NebulaException(ui.displayUnknownDeadlineException());
+                }
+            } else if (command.startsWith("event")) {
+                if (!description.contains("/from") || !description.contains("/to")) {
+                    throw new NebulaException(ui.displayUnknownEventTimingException());
+                }
+            }
+        }
+    }
+
+    /**
+     * Determines the TaskType based on the command prefix
+     *
+     * @param command the input command string
+     * @return the corresponding TaskType, or unknown TaskType if unrecognized
+     */
+    public static TaskType parseTaskType(String command) {
+        if (command.startsWith("todo")) {
+            return TaskType.TODO;
+        } else if (command.startsWith("deadline")) {
+            return TaskType.DEADLINE;
+        } else if (command.startsWith("event")) {
+            return TaskType.EVENT;
+        } else {
+            return TaskType.UNKNOWN;
+        }
+    }
+
+
+
+
+
+}

src/main/java/NebulaException.java

@@ -0,0 +1,10 @@
+public class NebulaException extends Exception {
+    /**
+     * Constructs a NebulaException with the specified error message
+     *
+     * @param error The String description of the error message
+     */
+    public NebulaException(String error) {
+        super(error);
+    }
+}

src/main/java/Parser.java

@@ -0,0 +1,43 @@
+public class Parser {
+    /**
+     * Splits the command string to extract the task number
+     *
+     * @param command The command string containing the command and task number
+     * @return The task number as an integer
+     */
+    public int splitCommandAndTaskNumber(String command) {
+        String taskNum = command.split(" ", 2)[1];
+        return Integer.parseInt(taskNum);
+    }
+
+    /**
+     *
+     * @param command The command string containing the command and task description
+     * @return The task description as a String
+     */
+    public String splitCommandAndTaskDescription(String command) {
+
+        return command.split(" ", 2)[1];
+    }
+
+    /**
+     *
+     * @param command The command string containing the command, task description, and deadline
+     * @return The task deadline as a String
+     */
+    public String[] splitDeadlineCommand(String command) {
+
+        return command.split("/by ", 2);
+    }
+
+    /**
+     *
+     * @param command The command string containing the command, task description,
+     *                event start time, and event end time
+     * @return The event start and end time as a String
+     */
+    public String[] splitEventCommand(String command) {
+
+        return command.split(" /", 3);
+    }
+}

src/main/java/Task.java

@@ -0,0 +1,62 @@
+public class Task {
+    private final String description;
+    private boolean isDone;
+
+    /**
+     * Constructs a Task with the specified description
+     * The task is initialized with the given description and is marked as not done
+     *
+     * @param description The description of the task provided by the user
+     */
+    public Task (String description) {
+        this.description = description;
+        this.isDone = false;
+    }
+
+    /**
+     * Returns the description of this task
+     *
+     * @return The description of the task
+     */
+    public String getDescription() {
+        return this.description;
+    }
+
+    /**
+     * Checks if the task has been completed
+     *
+     * @return true if the task is completed, false otherwise
+     */
+    public boolean isDone() {
+        return this.isDone;
+    }
+
+    /**
+     * Sets the completion status of the task
+     *
+     * @param isDone true to mark the task as completed, false to mark it as not completed
+     */
+    public void setDone(boolean isDone) {
+        this.isDone = isDone;
+    }
+
+    /**
+     * Returns the status icon representing the completion state of the task
+     * Returns "X" if the task is completed, otherwise returns " "
+     *
+     * @return A string representing the status icon of the task
+     */
+    public String getStatusIcon() {
+        return isDone ? "X" : " ";
+    }
+
+    /**
+     * Returns a string representation of the object which includes the
+     * status icon and the description of the object
+     *
+     * @return A string in the format: "[<statusIcon>] <description>"
+     */
+    public String toString() {
+        return "[" + getStatusIcon() + "] " + getDescription();
+    }
+}