Use Inline Functions Reified

// ✅ Inline function
inline fun measureTime(block: () -> Unit): Long {
  val start = System.currentTimeMillis()
  block()
  return System.currentTimeMillis() - start
}

// ✅ Usage - no lambda object created
val time = measureTime {
  // This code is inlined at call site
  processData()
}

// ❌ Regular function - creates lambda object
fun repeat(times: Int, action: () -> Unit) {
  for (i in 1..times) {
    action()  // Lambda object allocated
  }
}

// ✅ Inline - no allocation
inline fun repeatInline(times: Int, action: () -> Unit) {
  for (i in 1..times) {
    action()  // Inlined, no allocation
  }
}

// Compiled result for: repeatInline(3) { println("Hi") }
// Becomes:
// for (i in 1..3) {
//   println("Hi")
// }

// ❌ Regular function - type erased
fun <T> getClassName(): String {
  // return T::class.simpleName  // ❌ Cannot access T at runtime
  return "Unknown"
}

// ✅ Inline with reified
inline fun <reified T> getClassName(): String {
  return T::class.simpleName ?: "Unknown"
}

// ✅ Usage
println(getClassName<String>())  // "String"
println(getClassName<Int>())     // "Int"
println(getClassName<List<String>>())  // "List"

// ✅ Reified type casting
inline fun <reified T> Any.asInstance(): T? {
  return this as? T
}

// ✅ Usage
val obj: Any = "Hello"
val str: String? = obj.asInstance<String>()  // ✅ "Hello"
val num: Int? = obj.asInstance<Int>()        // null

// ✅ Reified filter
inline fun <reified T> List<*>.filterByType(): List<T> {
  return this.filterIsInstance<T>()
}

// ✅ Usage
val mixed: List<Any> = listOf("Hello", 42, "World", 3.14, "Kotlin")
val strings = mixed.filterByType<String>()
println(strings)  // [Hello, World, Kotlin]

// ✅ Inline function enables return from lambda
inline fun processItems(items: List<String>, action: (String) -> Unit) {
  for (item in items) {
    action(item)
  }
}

fun findAndProcess(items: List<String>) {
  processItems(items) { item ->
    if (item == "stop") {
      return  // Returns from findAndProcess, not lambda
    }
    println(item)
  }
  println("Done")  // May not execute if "stop" found
}

// ❌ Regular function - compilation error
fun regularProcess(items: List<String>, action: (String) -> Unit) {
  for (item in items) {
    action(item)
  }
}

fun cannotReturn(items: List<String>) {
  regularProcess(items) { item ->
    // return  // ❌ Compilation error
    println(item)
  }
}

inline fun processWithLabel(items: List<String>, action: (String) -> Unit) {
  for (item in items) {
    action(item)
  }
}

fun process(items: List<String>) {
  processWithLabel(items) { item ->
    if (item.isEmpty()) {
      return@processWithLabel  // Returns from lambda only
    }
    println(item)
  }
  println("Always executed")
}

// ✅ crossinline prevents non-local returns
inline fun executeAsync(crossinline action: () -> Unit) {
  thread {  // Lambda stored in thread
    action()
  }
}

fun usage() {
  executeAsync {
    // return  // ❌ Compilation error - crossinline disallows this
    println("Executed asynchronously")
  }
}

// ✅ Without crossinline would cause runtime issues
inline fun broken(action: () -> Unit) {
  thread {
    action()  // If action has return, undefined behavior
  }
}

// ✅ noinline for specific parameters
inline fun process(
  inline action1: () -> Unit,
  noinline action2: () -> Unit  // Not inlined
) {
  action1()  // Inlined
  storeAction(action2)  // Can store because not inlined
}

fun storeAction(action: () -> Unit) {
  // Store for later use
}

// ✅ Higher-order functions with lambdas
inline fun <T> measure(block: () -> T): Pair<T, Long> {
  val start = System.nanoTime()
  val result = block()
  val time = System.nanoTime() - start
  return result to time
}

// ✅ Reified type parameters needed
inline fun <reified T> Gson.fromJson(json: String): T {
  return this.fromJson(json, T::class.java)
}

// ✅ Control flow (forEach, repeat)
inline fun repeat(times: Int, action: (Int) -> Unit) {
  for (i in 0 until times) {
    action(i)
  }
}

// ❌ Large function bodies - increases code size
inline fun hugeFunction() {
  // 100+ lines of code
  // Inlining duplicates all this code
}

// ❌ Recursive functions - can't inline
inline fun factorial(n: Int): Int {
  return if (n <= 1) 1 else n * factorial(n - 1)  // ❌ Won't inline
}

// ❌ No lambdas - unnecessary
inline fun add(a: Int, b: Int): Int {
  return a + b  // No benefit from inlining
}

// ❌ Inlining everything
inline fun add(a: Int, b: Int) = a + b
inline fun multiply(a: Int, b: Int) = a * b
// No lambdas - inlining provides no benefit

// ✅ Only inline when beneficial
fun add(a: Int, b: Int) = a + b
fun multiply(a: Int, b: Int) = a * b

// ❌ Large inline function called many times
inline fun processData(data: List<Int>): List<Int> {
  // 50+ lines of processing logic
  return data.filter { it > 0 }
    .map { it * 2 }
    .sorted()
    // ... many more operations
}

// Called 100 times = 5000+ lines of bytecode

// ✅ Regular function
fun processData(data: List<Int>): List<Int> {
  // Large logic stays in one place
  return data.filter { it > 0 }
    .map { it * 2 }
    .sorted()
}

class Point(val x: Double, val y: Double) {
  // ✅ Inline property
  inline val magnitude: Double
    get() = Math.sqrt(x * x + y * y)
}

// Call site inlines getter
val point = Point(3.0, 4.0)
println(point.magnitude)  // Math.sqrt(3.0 * 3.0 + 4.0 * 4.0) inlined

// ✅ Inline extension
inline fun <T> List<T>.second(): T {
  return this[1]
}

// ✅ With reified types
inline fun <reified T> List<*>.countOfType(): Int {
  return this.count { it is T }
}