// Regular higher-order function — creates a lambda object every call
fun <T> measureTime(block: () -> T): T {
    val start = System.currentTimeMillis()
    val result = block()
    println("Elapsed: ${System.currentTimeMillis() - start}ms")
    return result
}

// After compilation (conceptually)
// block is passed as a Function0 interface object

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

// Usage
val result = measureTime {
    heavyComputation()
}

// After compilation (conceptually — function body is inserted)
val start = System.currentTimeMillis()
val result = heavyComputation()
println("Elapsed: ${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 is inline
        if (it > 10) return it  // This return exits the search() function
    }
    return null
}

// Kotlin's forEach, filter, map, etc. are all inline, so
// these patterns work naturally

inline fun performAction(
    inlineAction: () -> Unit,
    noinline storedAction: () -> Unit   // Kept as a lambda object
) {
    inlineAction()                       // Inlined
    val saved = storedAction             // Can be stored in a variable
    scheduleForLater(saved)              // Can be passed to another function
}

fun scheduleForLater(action: () -> Unit) {
    // Execute later
}

inline fun runAsync(crossinline block: () -> Unit) {
    Thread {
        block()   // Runs on another thread — no non-local return allowed
    }.start()
}

fun example() {
    runAsync {
        println("Running asynchronously")
        // return  // Compile error — non-local return not allowed in crossinline lambdas
    }
}

// Without reified — runtime type check is not possible
fun <T> isType(value: Any): Boolean {
    // return value is T   // Compile error: T is erased at runtime
    return false
}

// Using reified — runtime type check is possible
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. Type casting
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. Collection filtering — already provided by the standard library with reified
val mixed: List<Any> = listOf(1, "hello", 2, "world", 3.14)
val strings: List<String> = mixed.filterIsInstance<String>()
// ["hello", "world"]

// 3. JSON / configuration parsing (Jackson pattern)
inline fun <reified T> String.fromJson(): T {
    return objectMapper.readValue(this, T::class.java)
}

val user: User = jsonString.fromJson<User>()
// T::class.java — thanks to reified, User.class can be passed at runtime

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

// filterIsInstance — the most representative use of 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 — all inline
// Accessing T::class
inline fun <reified T> typeNameOf(): String = T::class.simpleName ?: "Unknown"
println(typeNameOf<String>())   // String
println(typeNameOf<List<*>>())  // List

// Suitable for inline — a small function that takes a lambda parameter
inline fun <T> withLock(lock: Lock, block: () -> T): T {
    lock.lock()
    try { return block() }
    finally { lock.unlock() }
}

// Not suitable for inline — a regular function with no lambda
// inline fun add(a: Int, b: Int) = a + b   // Meaningless, triggers a warning

// Not suitable — very large function (code bloat)
// inline fun complexProcess(block: () -> Unit) {
//     // Hundreds of lines of code...
//     block()
// }