// 일반 고차 함수 — 매번 람다 객체 생성
fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    println("소요 시간: ${System.currentTimeMillis() - start}ms")
    return result
}

// 컴파일 후 (개념적으로)
// block이 Function0 인터페이스 객체로 전달됨

inline fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    println("소요 시간: ${System.currentTimeMillis() - start}ms")
    return result
}

// 사용
val result = measureTime {
    heavyComputation()
}

// 컴파일 후 (개념적으로 — 함수 본문이 삽입됨)
val start = System.currentTimeMillis()
val result = heavyComputation()
println("소요 시간: ${System.currentTimeMillis() - start}ms")

inline fun findFirst(list: List<Int>, predicate: (Int) -> Boolean): Int? {
    for (element in list) {
        if (predicate(element)) return element
    }
    return null
}

fun search(numbers: List<Int>): Int? {
    numbers.forEach {           // forEach는 inline
        if (it > 10) return it  // 이 return은 search() 함수에서 반환
    }
    return null
}

// Kotlin의 forEach, filter, map 등이 모두 inline이므로
// 이런 패턴이 자연스럽게 동작합니다

inline fun performAction(
    inlineAction: () -> Unit,
    noinline storedAction: () -> Unit   // 람다 객체로 유지
) {
    inlineAction()                       // 인라인 삽입
    val saved = storedAction             // 변수에 저장 가능
    scheduleForLater(saved)              // 다른 함수에 전달 가능
}

fun scheduleForLater(action: () -> Unit) {
    // 나중에 실행
}

inline fun runAsync(crossinline block: () -> Unit) {
    Thread {
        block()   // 다른 스레드에서 실행 — non-local return 불가
    }.start()
}

fun example() {
    runAsync {
        println("비동기 실행")
        // return  // 컴파일 에러 — crossinline 람다에서 non-local return 금지
    }
}

// reified 없이 — 런타임 타입 체크 불가
fun <T> isType(value: Any): Boolean {
    // return value is T   // 컴파일 에러: T는 런타임에 소거됨
    return false
}

// reified 사용 — 런타임 타입 체크 가능
inline fun <reified T> isType(value: Any): Boolean {
    return value is T
}

println(isType<String>("hello"))   // true
println(isType<Int>("hello"))      // false
println(isType<List<*>>(listOf())) // true

// 1. 타입 캐스팅
inline fun <reified T> Any.castOrNull(): T? = this as? T

val obj: Any = "hello"
val str: String? = obj.castOrNull<String>()   // "hello"
val num: Int? = obj.castOrNull<Int>()         // null

// 2. 컬렉션 필터링 — 표준 라이브러리에 reified로 이미 제공됨
val mixed: List<Any> = listOf(1, "hello", 2, "world", 3.14)
val strings: List<String> = mixed.filterIsInstance<String>()
// ["hello", "world"]

// 3. JSON/설정 파싱 (Jackson 예시 패턴)
inline fun <reified T> String.fromJson(): T {
    return objectMapper.readValue(this, T::class.java)
}

val user: User = jsonString.fromJson<User>()
// T::class.java — reified 덕분에 런타임에 User.class 전달 가능

// 4. Android/Spring에서 findView, getBean 패턴
inline fun <reified T : Any> ApplicationContext.getBean(): T {
    return getBean(T::class.java)
}
// val service: UserService = context.getBean()

// filterIsInstance — 가장 대표적인 reified 활용
val mixed: List<Any> = listOf(1, "a", 2, "b", 3.0)
val ints: List<Int> = mixed.filterIsInstance<Int>()         // [1, 2]
val strings: List<String> = mixed.filterIsInstance<String>() // ["a", "b"]

// let, run, apply, also, with — 모두 inline
// T::class 접근
inline fun <reified T> typeNameOf(): String = T::class.simpleName ?: "Unknown"
println(typeNameOf<String>())   // String
println(typeNameOf<List<*>>())  // List

// ✅ inline이 적합한 경우 — 람다를 매개변수로 받는 작은 함수
inline fun <T> withLock(lock: Lock, block: () -> T): T {
    lock.lock()
    try { return block() }
    finally { lock.unlock() }
}

// ❌ inline이 부적합한 경우 — 람다 없는 일반 함수
// inline fun add(a: Int, b: Int) = a + b   // 의미 없음, 경고 발생

// ❌ 매우 큰 함수 — 코드 팽창
// inline fun complexProcess(block: () -> Unit) {
//     // 수백 줄의 코드...
//     block()
// }