Amaliy loyiha - vazifalar daftari

enum class Muhimlik(val belgi: String, val vazn: Int) {
    PAST("-", 1),
    ORTA("=", 2),
    YUQORI("!", 3);

    override fun toString() = name.lowercase()
}

data class Vazifa(
    val id: Int,
    val matn: String,
    val muhimlik: Muhimlik = Muhimlik.ORTA,
    val bajarildi: Boolean = false
) {
    val korinishi: String
        get() {
            val belgi = if (bajarildi) "x" else " "
            return "[$belgi] ${muhimlik.belgi} #$id $matn"
        }
}

fun main() {
    val a = Vazifa(1, "Kotlin o'rganish", Muhimlik.YUQORI)
    val b = Vazifa(2, "Non olish")

    println(a.korinishi)
    println(b.korinishi)
    println(a)

    val bajarilgan = a.copy(bajarildi = true)
    println(bajarilgan.korinishi)
    println(a.bajarildi)
}

class Daftar {
    private val vazifalar = mutableListOf<Vazifa>()
    private var keyingiId = 1

    val soni: Int get() = vazifalar.size

    fun qosh(matn: String, muhimlik: Muhimlik = Muhimlik.ORTA): Vazifa {
        require(matn.isNotBlank()) { "Vazifa matni bo'sh bo'lmasligi kerak" }
        val yangi = Vazifa(keyingiId++, matn.trim(), muhimlik)
        vazifalar.add(yangi)
        return yangi
    }

    fun bajar(id: Int): Boolean {
        val i = vazifalar.indexOfFirst { it.id == id }
        if (i == -1) return false
        vazifalar[i] = vazifalar[i].copy(bajarildi = true)
        return true
    }

    fun ochir(id: Int): Boolean = vazifalar.removeIf { it.id == id }

    fun hammasi(): List<Vazifa> = vazifalar.toList()

    fun kutilayotgan(): List<Vazifa> =
        vazifalar.filter { !it.bajarildi }
                 .sortedWith(compareByDescending<Vazifa> { it.muhimlik.vazn }
                     .thenBy { it.id })

    fun topish(soz: String): List<Vazifa> =
        vazifalar.filter { it.matn.contains(soz, ignoreCase = true) }
}

fun main() {
    val d = Daftar()

    d.qosh("Kotlin o'rganish", Muhimlik.YUQORI)
    d.qosh("Non olish", Muhimlik.PAST)
    d.qosh("Hisobot yozish", Muhimlik.YUQORI)
    d.qosh("Kitob o'qish")

    println("Jami: ${d.soni}")

    d.bajar(2)

    println("-- Kutilayotganlar --")
    d.kutilayotgan().forEach { println(it.korinishi) }

    println("-- Qidiruv: 'o' --")
    d.topish("o").forEach { println(it.korinishi) }

    println(d.bajar(99))
}

fun hisobot(d: Daftar): String {
    val hammasi = d.hammasi()
    if (hammasi.isEmpty()) return "Daftar bo'sh"

    val bajarilgan = hammasi.count { it.bajarildi }
    val foiz = bajarilgan * 100.0 / hammasi.size

    val quruvchi = StringBuilder()
    quruvchi.appendLine("MUHIMLIK    JAMI  BAJARILDI")
    quruvchi.appendLine("-".repeat(28))

    Muhimlik.entries.sortedByDescending { it.vazn }.forEach { m ->
        val guruh = hammasi.filter { it.muhimlik == m }
        if (guruh.isNotEmpty()) {
            quruvchi.appendLine(
                m.name.padEnd(12) +
                guruh.size.toString().padStart(4) +
                guruh.count { it.bajarildi }.toString().padStart(11)
            )
        }
    }

    quruvchi.appendLine("-".repeat(28))
    val f = "%.0f".format(foiz)
    quruvchi.append("Bajarilgan: $bajarilgan/${hammasi.size} ($f%)")
    return quruvchi.toString()
}

fun main() {
    val d = Daftar()
    d.qosh("Kotlin o'rganish", Muhimlik.YUQORI)
    d.qosh("Non olish", Muhimlik.PAST)
    d.qosh("Hisobot yozish", Muhimlik.YUQORI)
    d.qosh("Kitob o'qish")
    d.qosh("Sport", Muhimlik.PAST)

    d.bajar(2)
    d.bajar(3)

    println(hisobot(d))
    println()
    println(hisobot(Daftar()))
}

import java.io.File

fun Vazifa.qatorga(): String =
    listOf(id, matn, muhimlik.name, bajarildi).joinToString("|")

fun qatordan(qator: String): Vazifa? {
    val q = qator.split("|")
    if (q.size != 4) return null
    val id = q[0].toIntOrNull() ?: return null
    val muhimlik = runCatching { Muhimlik.valueOf(q[2]) }.getOrNull()
        ?: return null
    return Vazifa(id, q[1], muhimlik, q[3].toBoolean())
}

fun saqla(d: Daftar, fayl: File) {
    fayl.writeText(d.hammasi().joinToString("\n") { it.qatorga() })
}

fun yukla(fayl: File): List<Vazifa> {
    if (!fayl.exists()) return emptyList()
    return fayl.readLines()
        .filter { it.isNotBlank() }
        .mapNotNull { qatordan(it) }
}

fun main() {
    val fayl = File("vazifalar.txt")

    val d = Daftar()
    d.qosh("Kotlin o'rganish", Muhimlik.YUQORI)
    d.qosh("Non olish", Muhimlik.PAST)
    d.bajar(2)

    saqla(d, fayl)
    println("Saqlandi:")
    println(fayl.readText())

    println("-- Yuklandi --")
    yukla(fayl).forEach { println(it.korinishi) }

    fayl.writeText("bu|buzuq\nyana|buzuq|qator|va|ortiqcha")
    println("Buzuq fayldan: ${yukla(fayl).size} ta")

    println("Yo'q fayldan: ${yukla(File("yoq.txt")).size} ta")

    fayl.delete()
}

sealed interface Javob {
    data class Muvaffaqiyat(val xabar: String) : Javob
    data class Xato(val sabab: String) : Javob
    data object Chiqish : Javob
}

fun buyruq(d: Daftar, satr: String): Javob {
    val qismlar = satr.trim().split(" ", limit = 2)
    val amal = qismlar.firstOrNull()?.lowercase()
        ?: return Javob.Xato("bo'sh")
    val arg = qismlar.getOrNull(1)?.trim()

    return when (amal) {
        "qosh" -> {
            if (arg.isNullOrBlank()) return Javob.Xato("matn kerak")
            val v = d.qosh(arg)
            Javob.Muvaffaqiyat("Qo'shildi: #${v.id}")
        }
        "bajar" -> {
            val id = arg?.toIntOrNull() ?: return Javob.Xato("id kerak")
            if (d.bajar(id)) Javob.Muvaffaqiyat("Bajarildi: #$id")
            else Javob.Xato("#$id topilmadi")
        }
        "ochir" -> {
            val id = arg?.toIntOrNull() ?: return Javob.Xato("id kerak")
            if (d.ochir(id)) Javob.Muvaffaqiyat("O'chirildi: #$id")
            else Javob.Xato("#$id topilmadi")
        }
        "chiqish" -> Javob.Chiqish
        else -> Javob.Xato("noma'lum buyruq: $amal")
    }
}

fun main() {
    val d = Daftar()

    val buyruqlar = listOf(
        "qosh Kotlin o'rganish",
        "qosh Non olish",
        "bajar 1",
        "bajar 99",
        "ochir abc",
        "qosh",
        "sakrash",
        "chiqish"
    )

    for (b in buyruqlar) {
        val javob = buyruq(d, b)
        val belgi = when (javob) {
            is Javob.Muvaffaqiyat -> "OK   ${javob.xabar}"
            is Javob.Xato -> "XATO ${javob.sabab}"
            Javob.Chiqish -> "-- chiqildi --"
        }
        println("$belgi")
        if (javob is Javob.Chiqish) break
    }

    println("Qolgan: ${d.soni} ta")
}

import java.io.File

fun main() {
    val fayl = File("vazifalar.txt")
    val d = Daftar()
    yukla(fayl).forEach { d.qosh(it.matn, it.muhimlik) }

    println("Buyruqlar: qosh <matn> | bajar <id> | ochir <id>")
    println("           royxat | chiqish")

    while (true) {
        print("> ")
        val satr = readlnOrNull() ?: break

        if (satr.trim().lowercase() == "royxat") {
            d.kutilayotgan().forEach { println(it.korinishi) }
            continue
        }

        when (val javob = buyruq(d, satr)) {
            is Javob.Muvaffaqiyat -> println(javob.xabar)
            is Javob.Xato -> println("Xato: ${javob.sabab}")
            Javob.Chiqish -> {
                saqla(d, fayl)
                println("Saqlandi. Xayr!")
                return
            }
        }
    }
}