data class Student(val name: String, val score: Int) : Comparable<Student> {
    override fun compareTo(other: Student): Int {
        return this.score.compareTo(other.score)  // 점수 오름차순
    }
}

val students = listOf(
    Student("Alice", 90),
    Student("Bob", 75),
    Student("Charlie", 85)
)

println(students.sorted())
// [Student(name=Bob, score=75), Student(name=Charlie, score=85), Student(name=Alice, score=90)]

println(students.min())  // Student(name=Bob, score=75)
println(students.max())  // Student(name=Alice, score=90)

override fun compareTo(other: T): Int {
    // 음수 → this가 other보다 작음 (앞에 위치)
    // 0    → 같음
    // 양수 → this가 other보다 큼 (뒤에 위치)
}

data class Employee(
    val department: String,
    val name: String,
    val salary: Int
) : Comparable<Employee> {
    override fun compareTo(other: Employee): Int =
        compareValuesBy(this, other,
            { it.department },  // 1차: 부서 이름 오름차순
            { it.salary },      // 2차: 급여 오름차순
            { it.name }         // 3차: 이름 오름차순
        )
}

data class Product(val name: String, val price: Int, val rating: Double)

val products = listOf(
    Product("노트북", 1200000, 4.5),
    Product("마우스", 35000, 4.8),
    Product("키보드", 85000, 4.2),
    Product("모니터", 450000, 4.7)
)

// 가격 오름차순
val byPrice = Comparator<Product> { a, b -> a.price.compareTo(b.price) }
println(products.sortedWith(byPrice).map { it.name })
// [마우스, 키보드, 모니터, 노트북]

// 평점 내림차순
val byRatingDesc = Comparator<Product> { a, b -> b.rating.compareTo(a.rating) }
println(products.sortedWith(byRatingDesc).map { "${it.name}(${it.rating})" })
// [마우스(4.8), 모니터(4.7), 노트북(4.5), 키보드(4.2)]

// 단일 기준
val byPrice = compareBy<Product> { it.price }
val byPriceDesc = compareByDescending<Product> { it.price }

// 다중 기준 (1차, 2차, 3차...)
val multiSort = compareBy<Product>(
    { it.rating * -1 },  // 평점 내림차순 (음수 처리)
    { it.price }         // 가격 오름차순
)

println(products.sortedWith(multiSort).map { it.name })

val sorted = products.sortedWith(
    compareByDescending<Product> { it.rating }
        .thenBy { it.price }       // 평점 같으면 가격 오름차순
        .thenBy { it.name }        // 가격도 같으면 이름 오름차순
)

sorted.forEach { println("${it.name}: 평점=${it.rating}, 가격=${it.price}") }

// 단일 기준
val byName = products.sortedBy { it.name }
val byPriceDesc = products.sortedByDescending { it.price }

// 문자열 정렬
val names = listOf("Charlie", "alice", "Bob")
println(names.sorted())               // [Bob, Charlie, alice] — 대소문자 구분
println(names.sortedBy { it.lowercase() })  // [alice, Bob, Charlie] — 대소문자 무시

enum class SortOption { PRICE_ASC, PRICE_DESC, RATING_DESC, NAME_ASC }

fun sortProducts(products: List<Product>, option: SortOption): List<Product> {
    return when (option) {
        SortOption.PRICE_ASC   -> products.sortedBy { it.price }
        SortOption.PRICE_DESC  -> products.sortedByDescending { it.price }
        SortOption.RATING_DESC -> products.sortedWith(
            compareByDescending<Product> { it.rating }.thenBy { it.price }
        )
        SortOption.NAME_ASC    -> products.sortedBy { it.name.lowercase() }
    }
}

import java.util.PriorityQueue

data class Task(val name: String, val priority: Int, val deadline: Long)

// 우선순위 높은 것(숫자 클수록) → 마감 빠른 것 순
val taskQueue = PriorityQueue<Task>(
    compareByDescending<Task> { it.priority }
        .thenBy { it.deadline }
)

taskQueue.add(Task("이메일 답장", 1, System.currentTimeMillis() + 3600000))
taskQueue.add(Task("버그 수정", 3, System.currentTimeMillis() + 1800000))
taskQueue.add(Task("문서 작성", 2, System.currentTimeMillis() + 7200000))

while (taskQueue.isNotEmpty()) {
    val task = taskQueue.poll()
    println("처리: ${task.name} (우선순위: ${task.priority})")
}
// 처리: 버그 수정 (우선순위: 3)
// 처리: 문서 작성 (우선순위: 2)
// 처리: 이메일 답장 (우선순위: 1)

val numbers = listOf(3, 1, 4, 1, 5, 9, 2, 6)

println(numbers.sortedWith(naturalOrder()))   // [1, 1, 2, 3, 4, 5, 6, 9]
println(numbers.sortedWith(reverseOrder()))   // [9, 6, 5, 4, 3, 2, 1, 1]

// nullable 정렬 — null을 맨 앞 또는 맨 뒤로
val nullables = listOf("banana", null, "apple", null, "cherry")
println(nullables.sortedWith(nullsFirst(naturalOrder())))
// [null, null, apple, banana, cherry]
println(nullables.sortedWith(nullsLast(naturalOrder())))
// [apple, banana, cherry, null, null]