inline fun runTask(task: () -> Unit) {
    println("작업 시작")
    task()
    println("작업 종료")
}

fun process(items: List<Int>) {
    runTask {
        for (item in items) {
            if (item < 0) return  // non-local return — process() 자체를 종료
            println(item)
        }
    }
}

// inline이 아니면 컴파일 에러
fun runTaskNonInline(task: () -> Unit) {
    task()
}

fun process2(items: List<Int>) {
    runTaskNonInline {
        if (true) return  // ❌ 컴파일 에러 — non-local return은 inline 함수에서만 가능
    }
}

inline fun runAsync(crossinline task: () -> Unit) {
    val thread = Thread {
        task()  // 다른 실행 컨텍스트(Thread)에서 호출됨
    }
    thread.start()
}

fun process(items: List<Int>) {
    runAsync {
        // return  // ❌ crossinline 람다는 non-local return 금지
        items.forEach { println(it) }
    }
}

// crossinline 없이 람다를 다른 컨텍스트에서 호출하려 하면 컴파일 에러
inline fun runAsyncWrong(task: () -> Unit) {  // crossinline 누락
    val thread = Thread {
        task()  // ❌ 컴파일 에러: "can't be inlined into different execution context"
    }
    thread.start()
}

inline fun processData(
    onStart: () -> Unit,
    noinline onComplete: () -> Unit  // 인라인되지 않음 — 별도 객체로 생성
) {
    onStart()
    saveCallback(onComplete)  // 함수 참조처럼 다른 곳에 저장/전달 가능
    println("처리 완료")
}

fun saveCallback(callback: () -> Unit) {
    // 콜백을 저장해두고 나중에 호출
    pendingCallbacks.add(callback)
}

// noinline이 필요한 이유 — 인라인 람다는 "저장"하거나 "다른 곳에 전달"할 수 없음
inline fun wrong(task: () -> Unit) {
    pendingCallbacks.add(task)  // ❌ 컴파일 에러 — 인라인 람다는 값으로 취급 불가
}

inline fun correct(noinline task: () -> Unit) {
    pendingCallbacks.add(task)  // ✅ noinline이므로 일반 함수 타입 객체로 존재
}

inline fun example(
    crossinline onCross: () -> Unit,
    noinline onNoinline: () -> Unit
) {
    Thread { onCross() }.start()      // crossinline — 다른 컨텍스트 호출 허용
    val ref: () -> Unit = onNoinline  // noinline — 변수에 저장 가능
}

inline fun <T> runOnBackground(
    crossinline action: () -> T,
    crossinline onResult: (T) -> Unit
) {
    Thread {
        val result = action()
        Handler(Looper.getMainLooper()).post {
            onResult(result)  // 다른 스레드(메인) 컨텍스트에서 호출 — crossinline 필요
        }
    }.start()
}

// 사용
runOnBackground(
    action = { repository.loadHeavyData() },
    onResult = { data -> updateUi(data) }
)

class EventBus {
    private val listeners = mutableListOf<() -> Unit>()

    inline fun subscribe(
        immediate: () -> Unit,
        noinline persistent: () -> Unit
    ) {
        immediate()                 // 즉시 인라인 실행
        listeners.add(persistent)   // 저장해야 하므로 noinline 필요
    }

    fun notifyAll() = listeners.forEach { it() }
}

// kotlin.system.measureTimeMillis — inline 함수
inline fun measureTimeMillis(block: () -> Unit): Long {
    val start = System.currentTimeMillis()
    block()
    return System.currentTimeMillis() - start
}

fun loadUsers(): List<User> {
    lateinit var result: List<User>
    val time = measureTimeMillis {
        result = repository.fetchUsers()
        // return result  // non-local return으로 fun loadUsers()까지 종료 가능 (가능하지만 비권장)
    }
    println("로딩 시간: ${time}ms")
    return result
}