제어문과 표현식 — when과 if가 값을 반환하는 언어

// 자바 스타일
var max: Int
if (a > b) {
    max = a
} else {
    max = b
}

// 코틀린 스타일 — if가 값을 반환
val max = if (a > b) a else b

// val result = if (x > 0) "양수"  // 컴파일 에러! else가 필요

val result = if (x > 0) "양수" else "0 이하"  // OK

// 블록으로도 사용 가능 — 마지막 줄이 반환값
val description = if (score >= 90) {
    println("축하합니다")
    "A등급"                    // 이 줄이 반환값
} else if (score >= 80) {
    "B등급"
} else {
    "C등급"
}

fun describe(x: Any): String = when (x) {
    1 -> "하나"
    "hello" -> "인사"
    is Long -> "Long 타입"
    !is String -> "문자열이 아님"
    else -> "기타"
}

val message = when (statusCode) {
    200 -> "성공"
    404 -> "찾을 수 없음"
    500 -> "서버 에러"
    else -> "알 수 없는 상태"   // 표현식일 때 else 필수
}

fun classify(value: Any) {
    when (value) {
        // 1. 상수 매칭
        0 -> println("영")
        1, 2 -> println("1 또는 2")          // 여러 값을 콤마로 묶기

        // 2. 범위 검사
        in 3..10 -> println("3에서 10 사이")
        !in 100..200 -> println("100~200 밖")

        // 3. 타입 검사 (스마트 캐스트 적용)
        is String -> println("문자열 길이: ${value.length}")
        is List<*> -> println("리스트 크기: ${value.size}")

        // 4. else
        else -> println("기타")
    }
}

fun classifyTemperature(temp: Int): String = when {
    temp < 0 -> "영하"
    temp < 10 -> "춥다"
    temp < 25 -> "적당하다"
    temp < 35 -> "덥다"
    else -> "폭염"
}

sealed class Result {
    data class Success(val data: String) : Result()
    data class Error(val message: String) : Result()
    object Loading : Result()
}

fun handle(result: Result): String = when (result) {
    is Result.Success -> "데이터: ${result.data}"
    is Result.Error -> "에러: ${result.message}"
    Result.Loading -> "로딩 중..."
    // else 불필요! sealed class의 모든 하위 타입을 처리했으므로
}

// 닫힌 범위 (1부터 10까지, 10 포함)
val closed = 1..10         // 1, 2, 3, ..., 10

// 반열린 범위 (1부터 10 미만)
val halfOpen = 1..<10      // 1, 2, 3, ..., 9   (Kotlin 1.8+)

// 역순 범위
val reversed = 10 downTo 1 // 10, 9, 8, ..., 1

// step으로 간격 지정
val stepped = 1..20 step 3 // 1, 4, 7, 10, 13, 16, 19

// in 연산자로 범위 검사
val age = 25
if (age in 19..64) {
    println("성인")
}

// for 루프에서 사용
for (i in 1..5) {
    print("$i ")  // 1 2 3 4 5
}

// 인덱스와 함께
val items = listOf("사과", "바나나", "체리")
for (i in items.indices) {
    println("$i: ${items[i]}")
}

// withIndex 활용
for ((index, value) in items.withIndex()) {
    println("$index: $value")
}

val isLowerCase = 'a' in 'a'..'z'
val isUpperCase = 'A' in 'A'..'Z'

// when에서도 활용
fun classifyChar(c: Char) = when (c) {
    in 'a'..'z' -> "소문자"
    in 'A'..'Z' -> "대문자"
    in '0'..'9' -> "숫자"
    else -> "기타"
}

// 레이블로 바깥 루프를 제어
outer@ for (i in 1..5) {
    for (j in 1..5) {
        if (j == 3) break@outer     // 바깥 루프까지 탈출
        println("$i, $j")
    }
}
// 출력: 1, 1 / 1, 2 (j가 3이 되면 전체 루프 종료)

outer@ for (i in 1..3) {
    for (j in 1..3) {
        if (j == 2) continue@outer  // 바깥 루프의 다음 반복으로
        println("$i, $j")
    }
}
// 출력: 1, 1 / 2, 1 / 3, 1

fun findFirstNegative(numbers: List<Int>): Int? {
    numbers.forEach {
        if (it < 0) return it  // findFirstNegative 함수 전체를 반환!
    }
    return null
}

fun printPositives(numbers: List<Int>) {
    numbers.forEach {
        if (it < 0) return@forEach  // 이 람다만 종료 (continue처럼 동작)
        println(it)
    }
    println("완료")  // 이 줄은 항상 실행됨
}

fun printPositives2(numbers: List<Int>) {
    numbers.forEach(fun(value) {
        if (value < 0) return   // 익명 함수만 종료 (람다와 다르게 동작)
        println(value)
    })
    println("완료")  // 항상 실행됨
}

// Range 기반 반복
for (i in 0 until 10) {    // 0..<10과 동일
    print("$i ")
}

// 컬렉션 순회
val fruits = listOf("사과", "바나나", "체리")
for (fruit in fruits) {
    println(fruit)
}

// 구조 분해
val map = mapOf("이름" to "코틀린", "버전" to "2.0")
for ((key, value) in map) {
    println("$key: $value")
}

var count = 0
while (count < 5) {
    println(count)
    count++
}

do {
    val input = readLine()
} while (input != "quit")