Commit

src/main/kotlin/Main.kt

@@ -1,3 +1,17 @@
-fun main(args: Array<String>) {
-    println("Hello World!")
+import menu.MenuNavigator
+import models.Archive
+import screens.ArchiveSelectionScreen
+
+fun main() {
+    println("Добро пожаловать в приложение Заметки!")
+    println("Версия 1.0")
+
+
+    val archives = mutableListOf<Archive>()
+
+
+    val archiveSelectionScreen = ArchiveSelectionScreen(archives)
+
+
+    MenuNavigator.startWith(archiveSelectionScreen)
 }

src/main/kotlin/menu/Menu.kt

@@ -0,0 +1,50 @@
+package menu
+
+import java.util.Scanner
+
+abstract class Menu {
+    protected val scanner = Scanner(System.`in`)
+    protected val menuItems = mutableListOf<MenuItem>()
+
+    protected fun addMenuItem(item: MenuItem) {
+        menuItems.add(item)
+    }
+
+    protected fun displayMenu(header: String) {
+        println("\n${"=".repeat(50)}")
+        println(header)
+        println("${"=".repeat(50)}")
+
+        menuItems.sortedBy { it.index }.forEach { item ->
+            println("${item.index}. ${item.title}")
+        }
+
+        println("${"=".repeat(50)}")
+        print("Выберите пункт меню: ")
+    }
+
+    open fun show() {
+        while (true) {
+            displayMenu(getMenuHeader())
+
+            try {
+                val choice = scanner.nextLine().toInt()
+                val menuItem = menuItems.find { it.index == choice }
+
+                if (menuItem != null) {
+                    menuItem.action()
+                    if (shouldExitAfterAction(choice)) {
+                        break
+                    }
+                } else {
+                    println("Ошибка: выбран неверный пункт меню. Попробуйте снова.")
+                }
+            } catch (e: NumberFormatException) {
+                println("Ошибка: введите номер пункта меню.")
+            }
+        }
+    }
+
+    protected abstract fun getMenuHeader(): String
+    protected abstract fun shouldExitAfterAction(choice: Int): Boolean
+}

src/main/kotlin/menu/MenuItem.kt

@@ -0,0 +1,7 @@
+package menu
+
+data class MenuItem(
+    val index: Int,
+    val title: String,
+    val action: () -> Unit
+)

src/main/kotlin/menu/MenuNavigator.kt

@@ -0,0 +1,37 @@
+package menu
+
+object MenuNavigator {
+    private val screenStack = mutableListOf<Menu>()
+
+    fun pushScreen(screen: Menu) {
+        screenStack.add(screen)
+    }
+
+    fun popScreen() {
+        if (screenStack.isNotEmpty()) {
+            screenStack.removeLast()
+        }
+    }
+
+    fun startWith(screen: Menu) {
+        screenStack.clear()
+        pushScreen(screen)
+        showCurrentScreen()
+    }
+
+    fun navigateTo(screen: Menu) {
+        pushScreen(screen)
+        showCurrentScreen()
+    }
+
+    fun back() {
+        popScreen()
+        if (screenStack.isNotEmpty()) {
+            showCurrentScreen()
+        }
+    }
+
+    private fun showCurrentScreen() {
+        screenStack.lastOrNull()?.show()
+    }
+}

src/main/kotlin/models/Archive.kt

@@ -0,0 +1,15 @@
+package models
+
+class Archive(val name: String) {
+    private val noteStorage = mutableListOf<Note>()
+
+    fun addNote(note: Note) {
+        noteStorage.add(note)
+    }
+
+
+    fun getNotes(): List<Note> = noteStorage.toList()
+
+
+    fun getNotesCount(): Int = noteStorage.size
+}

src/main/kotlin/models/Note.kt

@@ -0,0 +1,7 @@
+package models
+
+data class Note(
+    val title: String,
+    val content: String,
+    val createdAt: Long = System.currentTimeMillis()
+)

src/main/kotlin/screens/ArchiveCreationScreen.kt

@@ -0,0 +1,52 @@
+package screens
+
+import models.Archive
+import menu.Menu
+import menu.MenuNavigator
+import java.util.Scanner
+
+class ArchiveCreationScreen(private val archives: MutableList<Archive>) : Menu() {
+
+    init {
+
+        menuItems.add(menu.MenuItem(1, "Вернуться назад") {})
+    }
+
+    override fun show() {
+        println("\n${"=".repeat(50)}")
+        println("СОЗДАНИЕ АРХИВА")
+        println("${"=".repeat(50)}")
+
+        var archiveName: String
+        val scanner = Scanner(System.`in`)
+
+        while (true) {
+            print("Введите название архива: ")
+            archiveName = scanner.nextLine().trim()
+
+            if (archiveName.isEmpty()) {
+                println("Ошибка: название архива не может быть пустым.")
+                continue
+            }
+
+            if (archives.any { it.name == archiveName }) {
+                println("Ошибка: архив с таким названием уже существует.")
+                continue
+            }
+
+            break
+        }
+
+        val archive = Archive(archiveName)
+        archives.add(archive)
+        println("Архив '$archiveName' успешно создан!")
+
+
+        Thread.sleep(1000)
+        MenuNavigator.back()
+    }
+
+    override fun getMenuHeader(): String = "Создание архива"
+
+    override fun shouldExitAfterAction(choice: Int): Boolean = true
+}

src/main/kotlin/screens/ArchiveSelectionScreen.kt

@@ -0,0 +1,48 @@
+package screens
+
+import models.Archive
+import menu.Menu
+import menu.MenuItem
+import menu.MenuNavigator
+
+class ArchiveSelectionScreen(private val archives: MutableList<Archive>) : Menu() {
+
+    override fun show() {
+        menuItems.clear()
+        initializeMenu()
+        super.show()
+    }
+
+    private fun initializeMenu() {
+        // Пункт для создания нового архива
+        addMenuItem(MenuItem(0, "Создать архив") {
+            MenuNavigator.navigateTo(ArchiveCreationScreen(archives))
+        })
+
+        // Пункты для существующих архивов
+        archives.forEachIndexed { index, archive ->
+            addMenuItem(MenuItem(index + 1, archive.name) {
+                MenuNavigator.navigateTo(NoteSelectionScreen(archive))
+            })
+        }
+
+        // Пункт для выхода
+        val exitIndex = archives.size + 1
+        addMenuItem(MenuItem(exitIndex, "Выход") {
+            println("До свидания!")
+            System.exit(0)
+        })
+    }
+
+    override fun getMenuHeader(): String {
+        return if (archives.isEmpty()) {
+            "Список архивов (пока пуст)"
+        } else {
+            "Список архивов:"
+        }
+    }
+
+    override fun shouldExitAfterAction(choice: Int): Boolean {
+        return false
+    }
+}

src/main/kotlin/screens/NoteCreationScreen.kt

@@ -0,0 +1,71 @@
+package screens
+
+import models.Note
+import models.Archive
+import menu.Menu
+import menu.MenuItem
+import menu.MenuNavigator
+import java.util.Scanner
+
+class NoteCreationScreen(private val archive: Archive) : Menu() {
+
+    init {
+        menuItems.add(MenuItem(1, "Вернуться назад") {})
+    }
+
+    override fun show() {
+        println("\n${"=".repeat(50)}")
+        println("СОЗДАНИЕ ЗАМЕТКИ")
+        println("Архив: ${archive.name}")
+        println("${"=".repeat(50)}")
+
+        val scanner = Scanner(System.`in`)
+
+        // Ввод названия заметки
+        var title: String
+        while (true) {
+            print("Введите название заметки: ")
+            title = scanner.nextLine().trim()
+
+            if (title.isEmpty()) {
+                println("Ошибка: название заметки не может быть пустым.")
+                continue
+            }
+
+            break
+        }
+
+
+        println("Введите текст заметки (введите пустую строку для завершения):")
+        val lines = mutableListOf<String>()
+
+        while (true) {
+            print("> ")
+            val line = scanner.nextLine()
+            if (line.trim().isEmpty() && lines.isNotEmpty()) {
+                break
+            }
+            if (line.trim().isNotEmpty()) {
+                lines.add(line)
+            }
+        }
+
+        val content = lines.joinToString("\n")
+
+        if (content.trim().isEmpty()) {
+            println("Ошибка: текст заметки не может быть пустым.")
+        } else {
+            val note = Note(title, content)
+            archive.addNote(note)
+            println("Заметка '$title' успешно создана!")
+        }
+
+
+        Thread.sleep(1000)
+        MenuNavigator.back()
+    }
+
+    override fun getMenuHeader(): String = "Создание заметки"
+
+    override fun shouldExitAfterAction(choice: Int): Boolean = true
+}