// 스코프 함수 없이
val user = findUser(id)
if (user != null) {
    user.name = "홍길동"
    user.email = "hong@example.com"
    userRepository.save(user)
}

// apply + let으로 간결하게
findUser(id)?.apply {
    name = "홍길동"
    email = "hong@example.com"
}?.let { userRepository.save(it) }

// 기본 사용
val name = "  kotlin  "
val upper = name.let {
    val trimmed = it.trim()
    trimmed.uppercase()         // 람다 결과 반환
}
println(upper)                  // KOTLIN

// null 안전 체크 (가장 많이 쓰이는 패턴)
val user: User? = findUser(id)
user?.let {
    sendEmail(it.email)         // user가 null이 아닐 때만 실행
    println("이메일 전송: ${it.name}")
}

// 결과를 다른 타입으로 변환
val length: Int = "hello".let { it.length }

// 객체 멤버에 직접 접근하면서 결과 계산
data class Config(var host: String = "", var port: Int = 0, var timeout: Int = 0)

val config = Config()
val connectionString = config.run {
    host = "localhost"
    port = 5432
    timeout = 30
    "$host:$port (timeout=${timeout}s)"   // 람다 결과 반환
}
println(connectionString)   // localhost:5432 (timeout=30s)

// 확장 없이 블록 실행 (수신 객체 없는 run)
val result = run {
    val x = 10
    val y = 20
    x + y                               // 30
}

data class StringBuilder(var value: String = "")

// 여러 멤버에 접근하면서 결과 계산
val report = with(orderRepository.findById(orderId)) {
    """
    주문 번호: $id
    고객: $customerName
    금액: ${amount.formatCurrency()}
    상태: $status
    """.trimIndent()
}

// 객체 초기화
data class UserDto(
    var name: String = "",
    var email: String = "",
    var role: String = "USER"
)

val dto = UserDto().apply {
    name = "홍길동"
    email = "hong@example.com"
    role = "ADMIN"
}

// 빌더 패턴 대체
val alert = AlertDialog.Builder(context).apply {
    setTitle("확인")
    setMessage("삭제하시겠습니까?")
    setPositiveButton("확인") { _, _ -> delete() }
    setNegativeButton("취소", null)
}.create()

// 컬렉션 초기화에도 유용
val headers = mutableMapOf<String, String>().apply {
    put("Content-Type", "application/json")
    put("Authorization", "Bearer $token")
    put("X-Request-Id", UUID.randomUUID().toString())
}

// 로깅을 체이닝 중간에 삽입
val user = createUser(request)
    .also { log.info("사용자 생성: ${it.id}") }
    .also { sendWelcomeEmail(it.email) }

// 검증
fun saveUser(user: User): User {
    return user
        .also { require(it.name.isNotBlank()) { "이름이 비어있습니다" } }
        .also { require(it.email.contains("@")) { "이메일이 유효하지 않습니다" } }
        .let { userRepository.save(it) }
}

data class Order(
    val id: String,
    var status: OrderStatus = OrderStatus.PENDING,
    var totalAmount: Long = 0
)

enum class OrderStatus { PENDING, CONFIRMED, SHIPPED }

fun processOrder(orderId: String): String {
    return findOrder(orderId)
        ?.also { log.info("주문 처리 시작: ${it.id}") }     // 로깅
        ?.apply {
            status = OrderStatus.CONFIRMED                   // 상태 변경
            totalAmount = calculateTotal(id)                 // 금액 계산
        }
        ?.also { orderRepository.save(it) }                  // 저장
        ?.let { "주문 ${it.id} 처리 완료 (${it.totalAmount}원)" }  // 결과 변환
        ?: "주문을 찾을 수 없습니다"
}

// ❌ 깊은 중첩 — 가독성 저하
val result = user?.let { u ->
    u.order?.let { o ->
        o.items?.let { items ->
            items.sumOf { it.price }
        }
    }
}
// ✅ 대신 — 코드를 함수로 분리하거나 안전 호출 연산자 사용
val result = user?.order?.items?.sumOf { it.price }

// ❌ 단순 null 체크에 let 남용
if (user != null) {
    user.let { println(it.name) }   // let이 불필요
}
// ✅ 대신
user?.let { println(it.name) }

// ❌ apply 내에서 it 사용 혼동
val obj = Foo().apply {
    value = it.calculate()   // it은 외부 람다의 it — 의도가 불명확
}

// ❌ 너무 긴 스코프 함수 블록 — 함수로 추출하는 것이 낫습니다
val config = Config().apply {
    // 30줄의 복잡한 설정 로직...
}
// ✅ 대신
fun createDefaultConfig() = Config().apply {
    // 논리적으로 묶인 설정만
}