Sprint 6 solution

src/Main.java

@@ -1,6 +1,25 @@
-public class Main {
+import tasktracker.manager.InMemoryTaskManager;
+import tasktracker.manager.TaskManager;
+import tasktracker.model.Epic;
+import tasktracker.model.Subtask;
+import tasktracker.model.Task;
+import tasktracker.model.TaskStatus;
 
+public class Main {
     public static void main(String[] args) {
-        System.out.println("Поехали!");
+        TaskManager manager = new InMemoryTaskManager();
+
+        Task task = new Task("Task 1", "Description 1", manager.generateId(), TaskStatus.NEW);
+        manager.createTask(task);
+
+        Epic epic = new Epic("Epic 1", "Epic Description", manager.generateId(), TaskStatus.NEW);
+        manager.createEpic(epic);
+
+        Subtask subtask = new Subtask("Subtask 1", "Description 1", manager.generateId(), TaskStatus.NEW, epic.getId());
+        manager.createSubtask(subtask);
+
+        System.out.println("Tasks: " + manager.getAllTasks());
+        System.out.println("Epics: " + manager.getAllEpics());
+        System.out.println("Subtasks: " + manager.getAllSubtasks());
     }
 }

src/tasktracker/manager/HistoryManager.java

@@ -0,0 +1,13 @@
+package tasktracker.manager;
+
+import tasktracker.model.Task;
+
+import java.util.List;
+
+public interface HistoryManager {
+    void add(Task task);
+
+    List<Task> getHistory();
+
+    void remove(int id);
+}

src/tasktracker/manager/InMemoryHistoryManager.java

@@ -0,0 +1,102 @@
+package tasktracker.manager;
+
+import tasktracker.model.Task;
+
+import java.util.*;
+
+public class InMemoryHistoryManager implements HistoryManager {
+
+    private static final int HISTORY_LIMIT = 10;
+
+    // Двусвязный список для хранения истории
+    private final CustomLinkedList history = new CustomLinkedList();
+
+    // Хранение ссылок на узлы двусвязного списка по id задачи
+    private final Map<Integer, Node<Task>> historyMap = new HashMap<>();
+
+    // Вспомогательный класс для узлов двусвязного списка
+    private static class Node<T> {
+        T data;
+        Node<T> prev;
+        Node<T> next;
+
+        Node(T data) {
+            this.data = data;
+        }
+    }
+
+    // Кастомный двусвязный список
+    private static class CustomLinkedList {
+        Node<Task> head;
+        Node<Task> tail;
+
+        void linkLast(Task task, Node<Task> node) {
+            if (tail == null) {
+                head = tail = node;
+            } else {
+                tail.next = node;
+                node.prev = tail;
+                tail = node;
+            }
+        }
+
+        void removeNode(Node<Task> node) {
+            if (node == null) return;
+
+            if (node.prev != null) {
+                node.prev.next = node.next;
+            } else {
+                head = node.next;
+            }
+
+            if (node.next != null) {
+                node.next.prev = node.prev;
+            } else {
+                tail = node.prev;
+            }
+        }
+
+        List<Task> getTasks() {
+            List<Task> tasks = new ArrayList<>();
+            Node<Task> current = head;
+            while (current != null) {
+                tasks.add(current.data);
+                current = current.next;
+            }
+            return tasks;
+        }
+    }
+
+    @Override
+    public void add(Task task) {
+        if (task == null) return;
+
+        // Удаляем задачу, если она уже присутствует
+        if (historyMap.containsKey(task.getId())) {
+            remove(task.getId());
+        }
+
+        // Добавляем новую задачу в конец
+        Node<Task> newNode = new Node<>(task);
+        history.linkLast(task, newNode);
+        historyMap.put(task.getId(), newNode);
+
+        // Ограничиваем размер истории
+        if (historyMap.size() > HISTORY_LIMIT) {
+            remove(history.head.data.getId());
+        }
+    }
+
+    @Override
+    public List<Task> getHistory() {
+        return history.getTasks();
+    }
+
+    @Override
+    public void remove(int id) {
+        Node<Task> node = historyMap.remove(id);
+        if (node != null) {
+            history.removeNode(node);
+        }
+    }
+}

src/tasktracker/manager/InMemoryTaskManager.java

@@ -0,0 +1,141 @@
+package tasktracker.manager;
+
+import tasktracker.model.Epic;
+import tasktracker.model.Subtask;
+import tasktracker.model.Task;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class InMemoryTaskManager implements TaskManager {
+
+    private int idCounter = 1;
+    private final Map<Integer, Task> tasks = new HashMap<>();
+    private final Map<Integer, Epic> epics = new HashMap<>();
+    private final Map<Integer, Subtask> subtasks = new HashMap<>();
+    private final HistoryManager historyManager = new InMemoryHistoryManager();
+
+    @Override
+    public int generateId() {
+        return idCounter++;
+    }
+
+    @Override
+    public void createTask(Task task) {
+        tasks.put(task.getId(), task);
+    }
+
+    @Override
+    public void updateTask(Task task) {
+        if (tasks.containsKey(task.getId())) {
+            tasks.put(task.getId(), task);
+        }
+    }
+
+    @Override
+    public Task getTask(int id) {
+        Task task = tasks.get(id);
+        if (task != null) {
+            historyManager.add(task);
+        }
+        return task;
+    }
+
+    @Override
+    public void createEpic(Epic epic) {
+        epics.put(epic.getId(), epic);
+    }
+
+    @Override
+    public Epic getEpic(int id) {
+        Epic epic = epics.get(id);
+        if (epic != null) {
+            historyManager.add(epic);
+        }
+        return epic;
+    }
+
+    @Override
+    public void createSubtask(Subtask subtask) {
+        subtasks.put(subtask.getId(), subtask);
+        Epic epic = epics.get(subtask.getEpicId());
+        if (epic != null) {
+            epic.addSubtaskId(subtask.getId());
+        }
+    }
+
+    @Override
+    public Subtask getSubtask(int id) {
+        Subtask subtask = subtasks.get(id);
+        if (subtask != null) {
+            historyManager.add(subtask);
+        }
+        return subtask;
+    }
+
+    @Override
+    public List<Subtask> getSubtasksOfEpic(int epicId) {
+        List<Subtask> epicSubtasks = new ArrayList<>();
+        Epic epic = epics.get(epicId);
+        if (epic != null) {
+            for (Integer subtaskId : epic.getSubtaskIds()) {
+                if (subtasks.containsKey(subtaskId)) {
+                    epicSubtasks.add(subtasks.get(subtaskId));
+                }
+            }
+        }
+        return epicSubtasks;
+    }
+
+    @Override
+    public void deleteTaskById(int id) {
+        tasks.remove(id);
+        historyManager.remove(id);
+    }
+
+    @Override
+    public void deleteSubtaskById(int id) {
+        Subtask subtask = subtasks.remove(id);
+        if (subtask != null) {
+            Epic epic = epics.get(subtask.getEpicId());
+            if (epic != null) {
+                epic.getSubtaskIds().remove((Integer) id);
+            }
+        }
+        historyManager.remove(id);
+    }
+
+    @Override
+    public void deleteEpicById(int id) {
+        Epic epic = epics.remove(id);
+        if (epic != null) {
+            for (Integer subtaskId : epic.getSubtaskIds()) {
+                subtasks.remove(subtaskId);
+                historyManager.remove(subtaskId);
+            }
+        }
+        historyManager.remove(id);
+    }
+
+    @Override
+    public List<Task> getAllTasks() {
+        return new ArrayList<>(tasks.values());
+    }
+
+    @Override
+    public List<Epic> getAllEpics() {
+        return new ArrayList<>(epics.values());
+    }
+
+    @Override
+    public List<Subtask> getAllSubtasks() {
+        return new ArrayList<>(subtasks.values());
+    }
+
+    @Override
+    public List<Task> getHistory() {
+        return historyManager.getHistory();
+    }
+}

src/tasktracker/manager/InMemoryTaskManagerTest.java

@@ -0,0 +1,37 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import tasktracker.manager.InMemoryTaskManager;
+import tasktracker.manager.TaskManager;
+import tasktracker.model.Task;
+import tasktracker.model.TaskStatus;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+public class InMemoryTaskManagerTest {
+
+    private TaskManager taskManager;
+
+    @BeforeEach
+    public void setUp() {
+        taskManager = new InMemoryTaskManager();
+    }
+
+    @Test
+    public void getHistoryTest() {
+        Task task = new Task("Test Task", "Test Description", taskManager.generateId(), TaskStatus.NEW);
+        taskManager.createTask(task);
+
+        // Получаем задачу, чтобы добавить её в историю
+        taskManager.getTask(task.getId());
+
+        // Проверяем, что история содержит 1 задачу
+        assertEquals(1, taskManager.getHistory().size());
+        assertEquals(task, taskManager.getHistory().getFirst());
+    }
+
+    @Test
+    public void testInitialization() {
+        assertNotNull(taskManager);
+    }
+}

src/tasktracker/manager/TaskManager.java

@@ -0,0 +1,41 @@
+package tasktracker.manager;
+
+import tasktracker.model.Epic;
+import tasktracker.model.Subtask;
+import tasktracker.model.Task;
+
+import java.util.List;
+
+public interface TaskManager {
+    int generateId();
+
+    void createTask(Task task);
+
+    void createEpic(Epic epic);
+
+    void createSubtask(Subtask subtask);
+
+    Task getTask(int id);
+
+    Epic getEpic(int id);
+
+    Subtask getSubtask(int id);
+
+    void updateTask(Task task);
+
+    void deleteTaskById(int id);
+
+    void deleteEpicById(int id);
+
+    void deleteSubtaskById(int id);
+
+    List<Task> getAllTasks();
+
+    List<Epic> getAllEpics();
+
+    List<Subtask> getAllSubtasks();
+
+    List<Subtask> getSubtasksOfEpic(int epicId);
+
+    List<Task> getHistory();
+}

src/tasktracker/model/Epic.java

@@ -0,0 +1,21 @@
+package tasktracker.model;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Epic extends Task {
+
+    private final List<Integer> subtaskIds = new ArrayList<>();
+
+    public Epic(String title, String description, int id, TaskStatus status) {
+        super(title, description, id, status);
+    }
+
+    public List<Integer> getSubtaskIds() {
+        return subtaskIds;
+    }
+
+    public void addSubtaskId(int id) {
+        subtaskIds.add(id);
+    }
+}