[Qin Nanxin] iP

src/main/java/Deadline.java

@@ -0,0 +1,22 @@
+public class Deadline extends Task {
+    private String deadline;
+
+    public Deadline(String Task, String deadline) throws DukeException{
+        super(Task);
+        this.deadline = deadline;
+
+        // if (task.isBlank() || task.isEmpty()) {
+        //     throw new DukeException("The description of a Deadline task cannot be empty.");
+        // }
+
+        // if (deadline.isBlank() || deadline.isEmpty()) {
+        //     throw new DukeException("The deadline of a Deadline task cannot be empty.");
+        // }
+    }
+
+    @Override
+    public String getStatus(){
+        String time = "(by: " + deadline + ")";
+        return "[Deadline]" + super.getStatus() + " " + time;
+    }
+}

src/main/java/Duke.java

@@ -1,10 +1,94 @@
+import java.util.*;
+
 public class Duke {
+    public static String partition = "------------------------------------------------------------";
+    public static ArrayList<Task> taskList = new ArrayList<Task>();
     public static void main(String[] args) {
-        String logo = " ____        _        \n"
-                + "|  _ \\ _   _| | _____ \n"
-                + "| | | | | | | |/ / _ \\\n"
-                + "| |_| | |_| |   <  __/\n"
-                + "|____/ \\__,_|_|\\_\\___|\n";
-        System.out.println("Hello from\n" + logo);
+        Scanner sc = new Scanner(System.in);
+
+        System.out.println(partition);
+        System.out.println("Hello! I'm Edna-Duke.");
+        System.out.println("What can I do for you?");
+        System.out.println(partition);
+
+        String input = sc.next();
+        while(!input.equals("bye")) {
+            try {
+                switch(input){
+                    case "list":
+                        print();
+                        break;
+                    case "mark":
+                        int markItem = sc.nextInt();
+                        taskList.get(markItem - 1).markDone();
+                        break;
+                    case "unmark":
+                        int unmarkItem = sc.nextInt();
+                        taskList.get(unmarkItem - 1).markUndone();
+                        break;
+                    case "delete":
+                         int deleteItem = sc.nextInt();
+                        delete(deleteItem);
+                        break;
+                    case "todo":
+                        add(new ToDo(sc.nextLine()));
+                        break;
+                    case "event":
+                        String eventCommand = sc.nextLine();
+                        String[] event = new String[3];
+                        event[0] = eventCommand.substring(1, eventCommand.indexOf(" /"));
+                        event[1] = eventCommand.substring(eventCommand.indexOf("/from") + 6, 
+                        eventCommand.indexOf(" /to"));
+                        event[2] = eventCommand.substring(eventCommand.indexOf("/to") + 4);
+                        add(new Event(event[0], event[1], event[2]));
+                        break;
+                    case "deadline":
+                        String ddlCommand = sc.nextLine();
+                        String[] ddl = ddlCommand.split(" /by ");
+                        add(new Deadline(ddl[0].substring(1), ddl[1]));
+                        break;
+                    default:
+                        add(new Task(input));
+                }
+            } 
+
+            catch (DukeException e) {
+                System.out.println(e.getMessage());
+            }
+
+            finally {
+                System.out.println(partition);
+                input = sc.next();
+            }
+        }
+
+        exit();
+    }
+
+    public static void add(Task input) {
+        taskList.add(input);
+        System.out.println("Got it! This task has been added: ");
+        System.out.println(input.getStatus());
+        System.out.println("Current # of task: " + taskList.size());
+    }
+
+    public static void delete(int num) {
+        System.out.println("I've removed this task:");
+        taskList.get(num-1).getStatus();
+        taskList.remove(num - 1);
+        System.out.println("Now you have " + taskList.size() + " tasks in the list.");
+    }
+
+    public static void print() {
+        int index = 1;
+        for (Task task: taskList) {
+            System.out.println(index + ". " + task.getStatus());
+            index ++;
+        }
+    }
+
+    public static void exit() {
+        System.out.println("Bye. Hope to see you again soon!");
+        System.out.println(partition);
     }
 }

src/main/java/DukeException.java

@@ -0,0 +1,10 @@
+public class DukeException extends Exception {
+    public DukeException(String message) {
+        super(message);
+    }
+
+    @Override
+    public String getMessage() {
+        return ":( Oh no! " + super.getMessage();
+    }
+}

src/main/java/Event.java

@@ -0,0 +1,24 @@
+public class Event extends Task {
+    private String from;
+    private String to;
+
+    public Event(String task, String from, String to) throws DukeException {
+        super(task);
+        this.from = from;
+        this.to = to;
+
+        // if (task.isBlank() || task.isEmpty()) {
+        //     throw new DukeException("The description of a Event task cannot be empty.");
+        // }
+
+        // if (from.isBlank() || from.isEmpty() || to.isBlank() || to.isEmpty()) {
+        //     throw new DukeException("The time of an Event task cannot be empty.");
+        // }
+    }
+
+    @Override
+    public String getStatus(){
+        String time = "(from: " + from + " to: " + to + ")";
+        return "[Event]" + super.getStatus() + " " + time;
+    }
+}

src/main/java/Task.java

@@ -0,0 +1,36 @@
+public class Task {
+    String task;
+    boolean isDone;
+
+    public Task(String task) throws DukeException {
+        //when the command didn't go through any of the given cases
+        if (task == null){
+            throw new DukeException("I'm sorry, but I don't know what that means.");
+        }
+        this.task = task;
+        this.isDone = false;
+    }
+
+    public String getTask() {
+        return this.task;
+    }
+
+    public String getStatus() {
+        String status = "[" + (isDone ? "✓" : "✗") + "]";
+        return status + " " + this.getTask();
+    }
+
+    public void markDone() {
+        this.isDone = true;
+        System.out.println("Nice! I've marked this task as done:");
+        System.out.println(this.getStatus());
+        System.out.println("Here's a lollipop. 🍭");
+    }
+
+    public void markUndone() {
+        this.isDone = false;
+        System.out.println("OK, I've marked this task as not done yet:");
+        System.out.println(this.getStatus());
+        System.out.println("Undone complete.");
+    }
+}

src/main/java/ToDo.java

@@ -0,0 +1,13 @@
+public class ToDo extends Task {
+    public ToDo(String task)throws DukeException {
+        super(task);
+        if (task.isBlank() || task.isEmpty()) {
+            throw new DukeException("The description of a To-Do task cannot be empty.");
+        }
+    }
+
+    @Override
+    public String getStatus() {
+        return "[To-Do]" + super.getStatus();
+    }
+}