// 구체 타입을 모르는 List를 매개변수로 받아야 할 때
fun printSize(list: List<*>) {
    println("크기: ${list.size}")
}

printSize(listOf(1, 2, 3))
printSize(listOf("a", "b"))
printSize(listOf(User("철수"), User("영희")))
// 타입 인자가 Int든 String이든 User든 상관없이 받을 수 있음

// ❌ 제네릭 타입 자체를 매개변수로 받으면 타입 인자가 고정됨
fun printSizeWrong(list: List<Int>) { /* Int 리스트만 받음 */ }

// ❌ Any로 받으면 List라는 사실조차 잃음
fun printSizeWrong2(list: Any) { /* list.size 접근 불가 */ }

val numbers: List<Int> = listOf(1, 2, 3)

// List<*> — "타입은 모르지만 List다" (읽기는 안전, 쓰기는 제한)
val starList: List<*> = numbers
val item: Any? = starList[0]  // Any?로만 읽을 수 있음

// MutableList<*> — add 시 구체 타입을 모르므로 추가 불가 (Nothing 취급)
val mutableStarList: MutableList<*> = mutableListOf(1, 2, 3)
// mutableStarList.add(4)  // ❌ 컴파일 에러 — 어떤 타입인지 모르므로 안전하지 않음

// List<Any?> — "모든 타입을 섞어 담을 수 있는 List"
val mixedList: MutableList<Any?> = mutableListOf(1, "a", true)
mixedList.add(3.14)  // ✅ Any?는 모든 타입을 허용하므로 추가 가능

// List<*>는 List<Any?>의 "서브타입을 모르는 버전" — 다른 의미
val intList: List<Int> = listOf(1, 2, 3)
val starRef: List<*> = intList         // ✅ 가능 — 타입 인자를 숨김
// val anyRef: List<Any?> = intList    // ❌ List<Int>는 List<Any?>의 서브타입 아님 (invariant)

// out T — covariant. *는 Any?(상한)로 취급됨, 읽기만 가능
class Producer<out T>(private val item: T) {
    fun get(): T = item
}

val p: Producer<*> = Producer("hello")
val value: Any? = p.get()  // T가 Any?로 추론됨

// in T — contravariant. *는 Nothing(하한)으로 취급됨, 쓰기 불가
class Consumer<in T> {
    fun consume(item: T) { println(item) }
}

val c: Consumer<*> = Consumer<String>()
// c.consume("hi")  // ❌ 컴파일 에러 — T가 Nothing으로 취급되어 어떤 값도 전달 불가

// 무공변 T (out/in 없음) — *는 "T : 상한 upper bound"로 취급, 읽기만 안전
class Box<T>(var value: T)

val box: Box<*> = Box("hello")
val item: Any? = box.value   // 읽기는 가능
// box.value = "world"        // ❌ 쓰기 불가 — 구체 타입을 모르므로 안전하지 않음

// 함수에서 "타입은 모르지만 어떤 제네릭 클래스인지는 안다"
fun describe(list: List<*>): String = "리스트, 크기 ${list.size}"

// "완전히 타입을 모른다" — 제네릭 자체도 모름
fun describeAny(value: Any?): String = "값: $value"

describe(listOf(1, 2, 3))      // "리스트, 크기 3" — List라는 구조 정보 유지
describeAny(listOf(1, 2, 3))   // "값: [1, 2, 3]" — List인지 알 수 없음, toString만 가능

fun isEmptyCollection(value: Any?): Boolean {
    return when (value) {
        is List<*>  -> value.isEmpty()
        is Map<*, *> -> value.isEmpty()
        is Set<*>   -> value.isEmpty()
        else -> false
    }
}

// Bundle/Intent extras 검사 시 활용
fun logExtras(bundle: Bundle) {
    for (key in bundle.keySet()) {
        val value = bundle.get(key)
        if (value is List<*>) {
            println("$key: List 크기 ${value.size}")
        }
    }
}

fun flattenJsonArray(value: Any?): List<String> {
    return when (value) {
        is List<*> -> value.map { it.toString() }
        is Array<*> -> value.map { it.toString() }
        else -> listOf(value.toString())
    }
}

fun bindAnyAdapter(adapter: RecyclerView.Adapter<*>) {
    // 구체 ViewHolder 타입은 모르지만 Adapter라는 사실은 알고 있음
    println("아이템 수: ${adapter.itemCount}")
}

// Class<*> — 클래스 타입 인자를 모를 때
fun getSimpleName(clazz: Class<*>): String = clazz.simpleName
getSimpleName(User::class.java)
getSimpleName(Post::class.java)