import kotlinx.coroutines.*

// suspend 함수는 대기 중에는 스레드를 점유하지 않습니다
suspend fun fetchUserName(userId: Int): String {
    delay(500)  // Thread.sleep 대신 delay (스레드 비블로킹)
    return "User_$userId"
}

suspend fun fetchUserScore(userId: Int): Int {
    delay(300)
    return userId * 10
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    // 여기부터 코루틴 컨텍스트
    val name = fetchUserName(1)
    println("이름: $name")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job: Job = launch {
        delay(1000)
        println("백그라운드 작업 완료")
    }

    println("launch 이후 즉시 실행됨")
    job.join()  // job이 완료될 때까지 대기 (선택적)
    println("모든 작업 완료")
}
// 출력:
// launch 이후 즉시 실행됨
// 백그라운드 작업 완료
// 모든 작업 완료

import kotlinx.coroutines.*

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()

    val job1 = launch { delay(1000); println("작업 1 완료") }
    val job2 = launch { delay(800); println("작업 2 완료") }
    val job3 = launch { delay(600); println("작업 3 완료") }

    job1.join()
    job2.join()
    job3.join()

    val elapsed = System.currentTimeMillis() - startTime
    println("총 소요 시간: ${elapsed}ms")
    // 약 1000ms (순차 실행이라면 2400ms)
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val startTime = System.currentTimeMillis()

    // 두 작업을 동시에 시작
    val deferred1: Deferred<String> = async { fetchUserName(1) }
    val deferred2: Deferred<Int>    = async { fetchUserScore(1) }

    // 각각 완료될 때까지 대기 후 결과 수신
    val name  = deferred1.await()
    val score = deferred2.await()

    val elapsed = System.currentTimeMillis() - startTime
    println("이름: $name, 점수: $score (${elapsed}ms)")
    // 약 500ms (순차라면 800ms)
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    // CPU 집약적 작업 → Default
    val result = withContext(Dispatchers.Default) {
        (1..1_000_000).sum()
    }
    println("합계: $result")

    // I/O 작업 → IO
    val data = withContext(Dispatchers.IO) {
        delay(100) // DB 쿼리 시뮬레이션
        "DB 데이터"
    }
    println("데이터: $data")
}

import kotlinx.coroutines.*

suspend fun loadFromDatabase(id: Int): String = withContext(Dispatchers.IO) {
    delay(200)  // DB 쿼리 시뮬레이션
    "Record_$id"
}

suspend fun processData(raw: String): String = withContext(Dispatchers.Default) {
    // CPU 집약적 처리
    raw.uppercase().reversed()
}

fun main() = runBlocking {
    val raw = loadFromDatabase(42)
    val processed = processData(raw)
    println(processed)  // 42_DROCER
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    // coroutineScope는 모든 자식이 완료될 때까지 대기
    coroutineScope {
        val job1 = launch {
            delay(1000)
            println("자식 1 완료")
        }
        val job2 = launch {
            delay(500)
            println("자식 2 완료")
        }
        // 이 블록은 job1, job2 모두 완료된 후 반환됨
    }
    println("모든 자식 완료 후 이 라인 실행")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch(Dispatchers.Default) {
        var count = 0
        while (isActive) {  // 취소 신호 확인
            count++
            if (count % 100_000 == 0) {
                yield()  // 다른 코루틴에게 실행 기회를 주고, 취소 확인
            }
        }
        println("루프 종료 (count=$count)")
    }

    delay(50)   // 50ms 후 취소
    job.cancel()
    job.join()
    println("완료")
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            println("작업 시작")
            delay(5000)
            println("작업 완료 (취소되면 이 줄은 실행 안 됨)")
        } finally {
            println("정리 중 (취소돼도 실행됨)")
            // withContext(NonCancellable) { ... }  ← 정리 중 추가 suspend 필요 시
        }
    }

    delay(200)
    println("취소 요청")
    job.cancelAndJoin()  // cancel() + join()
    println("완료")
}
// 출력:
// 작업 시작
// 취소 요청
// 정리 중 (취소돼도 실행됨)
// 완료

import kotlinx.coroutines.*

fun main() = runBlocking {
    // launch: 부수 효과, 결과 불필요
    launch {
        delay(100)
        println("로그 기록 완료")  // 결과를 반환할 필요 없음
    }

    // async: 결과 필요
    val price: Deferred<Double> = async {
        delay(200)
        9900.0
    }

    val totalPrice = price.await() * 1.1
    println("최종 가격: $totalPrice")
}

import kotlinx.coroutines.*

data class UserProfile(
    val name: String,
    val score: Int,
    val badges: List<String>
)

suspend fun fetchName(id: Int): String = withContext(Dispatchers.IO) {
    delay(300)
    "Alice"
}

suspend fun fetchScore(id: Int): Int = withContext(Dispatchers.IO) {
    delay(200)
    1500
}

suspend fun fetchBadges(id: Int): List<String> = withContext(Dispatchers.IO) {
    delay(250)
    listOf("신규 가입", "첫 결제", "VIP")
}

suspend fun buildUserProfile(userId: Int): UserProfile = coroutineScope {
    val nameDeferred   = async { fetchName(userId) }
    val scoreDeferred  = async { fetchScore(userId) }
    val badgesDeferred = async { fetchBadges(userId) }

    UserProfile(
        name   = nameDeferred.await(),
        score  = scoreDeferred.await(),
        badges = badgesDeferred.await()
    )
    // 총 ~300ms (순차라면 750ms)
}

fun main() = runBlocking {
    val profile = buildUserProfile(1)
    println(profile)
}