内联函数（Inline Function）

// 普通高阶函数
fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 调用处（每次调用都会创建 operation 对应的闭包对象）
fun main() {
    // 循环调用，会创建 1000 个闭包对象
    repeat(1000) {
        val result = calculate(10, 20) { x, y -> x + y }
        println(result)
    }
}

// 内联高阶函数
inline fun calculate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

// 调用处（代码被内联，无对象创建）
fun main() {
    // 循环调用，无任何闭包对象创建
    repeat(1000) {
        // 内联后，这里直接执行：val result = 10 + 20
        val result = calculate(10, 20) { x, y -> x + y }
        println(result)
    }
}

// 示例1：基础内联函数（优化高阶函数）
inline fun withLock(lock: Any, action: () -> Unit) {
    synchronized(lock) {
        action()
    }
}

// 示例2：noinline + crossinline
inline fun testInline(
    inlineAction: () -> Unit,
    noinline noInlineAction: () -> Unit,
    crossinline crossInlineAction: () -> Unit
) {
    inlineAction() // 内联执行
    val thread = Thread(noInlineAction) // 非内联参数可作为函数参数传递
    thread.start()
    
    // crossinline参数可在协程/回调中调用
    kotlinx.coroutines.runBlocking {
        crossInlineAction()
    }
}

// 使用
fun main() {
    val lock = Any()
    withLock(lock) {
        println("执行加锁操作") // 代码会被内联到withLock的调用处
    }
}

// 一个普通的非内联高阶函数（需要接收函数类型参数）
fun normalHigherOrderFunc(func: () -> Unit) {
    func()
}

// 内联函数，尝试把函数类型参数传给上面的非内联函数
inline fun inlineFunc(inlineParam: () -> Unit) {
    // 编译报错！因为 inlineParam 被内联后是一段代码，不是可传递的对象
    normalHigherOrderFunc(inlineParam)
}

fun normalHigherOrderFunc(func: () -> Unit) {
    func()
}

// 用 noinline 标记不需要内联的参数
inline fun inlineFunc(
    inlineParam: () -> Unit,       // 这个参数会被内联
    noinline noInlineParam: () -> Unit  // 这个参数不被内联，保留为闭包对象
) {
    inlineParam()  // 内联执行，无对象创建开销
    normalHigherOrderFunc(noInlineParam)  // 可正常传递，因为是普通闭包对象
}

// 内联函数，尝试把 lambda 传给 Runnable
inline fun doSomething(block: () -> Unit) {
    // 编译报错！原因：
    // 1. block 是内联的，支持非局部返回（lambda 里写 return 会退出调用 doSomething 的外层函数）
    // 2. 但 block 被放到了 Runnable 中执行（异步/另一个上下文），此时非局部返回会破坏程序逻辑
    Thread { block() }.start()
}

// 调用处
fun test() {
    println("test start")
    doSomething {
        // 如果允许非局部返回，这里的 return 会直接退出 test() 函数
        // 但 block 是在新线程执行的，此时 test() 可能已经执行完了，返回操作会失效且不安全
        return // 编译器会提前阻止这种风险
    }
    println("test end")
}

// 关键：给 block 加上 crossinline 修饰
inline fun doSomething(crossinline block: () -> Unit) {
    // 现在可以安全地把 block 传给 Runnable 了
    Thread { block() }.start()
}

// 调用处
fun test() {
    println("test start")
    doSomething {
        // 1. 这里不能写 return（非局部返回被禁止），编译报错
        // return  // 报错：'return' is not allowed here
        
        // 2. 只能用局部返回（返回当前 lambda，不影响外层 test 函数）
        return@doSomething 
        
        println("这段代码不会执行")
    }
    println("test end") // 一定会执行，因为 lambda 无法退出外层函数
}

// 执行结果：
// test start
// test end
// （新线程中的 block 执行了局部返回，不会打印那段代码）

// 内联函数：在主线程执行逻辑
inline fun runOnMainThread(crossinline action: () -> Unit) {
    // Handler 切换到主线程，action 被传递到另一个执行上下文
    android.os.Handler(android.os.Looper.getMainLooper()).post {
        action() // 安全执行，因为 crossinline 禁止了非局部返回
    }
}

// 调用处（比如 Activity 中）
fun updateUI() {
    println("开始更新UI")
    runOnMainThread {
        // 这里只能局部返回，不能用 return 退出 updateUI()
        // 保证即使 UI 操作异步执行，外层函数也能完整执行
        updateTextView("Hello")
        return@runOnMainThread // 局部返回，仅退出当前 lambda
    }
    println("UI更新逻辑已提交") // 一定会执行
}

// 普通高阶函数（无 inline）
fun normalFunc(block: () -> Unit) {
    block()
    println("normalFunc 后续代码") // 一定会执行
}

fun test1() {
    println("test1 开始")
    normalFunc {
        // 这里不能直接写 return（编译报错），因为 block 是闭包对象，非内联
        // return // 报错：'return' is not allowed here
        
        // 只能用局部返回：仅退出当前 lambda，不影响 test1
        return@normalFunc
        println("lambda 内部后续代码") // 不会执行
    }
    println("test1 结束") // 一定会执行
}

// 执行结果：
// test1 开始
// normalFunc 后续代码
// test1 结束

// 内联高阶函数（inline）
inline fun inlineFunc(block: () -> Unit) {
    block()
    println("inlineFunc 后续代码") // 不会执行！因为 block 里的 return 退出了外层函数
}

fun test2() {
    println("test2 开始")
    inlineFunc {
        // 非局部返回：直接退出外层的 test2 函数
        return
        println("lambda 内部后续代码") // 不会执行
    }
    println("test2 结束") // 不会执行！因为已经 return 退出了 test2
}

// 执行结果：
// test2 开始

inline fun findFirstPositive(numbers: List<Int>, block: (Int) -> Boolean): Int? {
    for (num in numbers) {
        if (block(num)) {
            return num // 找到后返回
        }
    }
    return null
}

fun processNumbers() {
    val list = listOf(-3, -2, -1, 4, 5)
    val firstPositive = findFirstPositive(list) { num ->
        // 非局部返回：满足条件时，直接退出 findFirstPositive（进而退出 processNumbers）
        if (num > 0) {
            return@findFirstPositive true // 局部返回（给 block 的返回值）
        }
        false
    }
    
    // 另一种写法：直接在 lambda 中退出 processNumbers
    findFirstPositive(list) { num ->
        if (num > 0) {
            println("找到第一个正数：$num")
            return // 非局部返回，直接退出 processNumbers
        }
        false
    }
    println("这段代码不会执行") // 因为上面的 return 已经退出了 processNumbers
}

inline fun doAsync(crossinline block: () -> Unit) {
    Thread {
        // block 在内联函数中，但执行在新线程
        // 如果允许非局部返回，block 里的 return 想退出外层函数，但外层函数可能已经执行完了
        // 因此 crossinline 禁止这种非局部返回，只允许局部返回
        block()
    }.start()
}

fun testAsync() {
    doAsync {
        // return // 编译报错：crossinline 禁止非局部返回
        return@doAsync // 仅退出 lambda，安全
    }
}