계약과 컨텍스트 — contract, context receivers로 컴파일러에게 더 많은 정보 주기

fun isNotNull(value: Any?): Boolean = value != null

fun process(value: String?) {
    if (value != null) {
        println(value.length) // ✅ 스마트 캐스트 동작
    }

    if (isNotNull(value)) {
        println(value.length) // ❌ 컴파일 에러! 스마트 캐스트 안 됨
    }
}

import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract

@OptIn(ExperimentalContracts::class)
fun isNotNull(value: Any?): Boolean {
    contract {
        returns(true) implies (value != null)
    }
    return value != null
}

fun process(value: String?) {
    if (isNotNull(value)) {
        println(value.length) // ✅ 스마트 캐스트 동작!
    }
}

// 타입 체크
@OptIn(ExperimentalContracts::class)
fun Any?.isString(): Boolean {
    contract {
        returns(true) implies (this@isString is String)
    }
    return this is String
}

val value: Any? = "Hello"
if (value.isString()) {
    println(value.length) // ✅ String으로 스마트 캐스트
}

// false 반환 시 조건
@OptIn(ExperimentalContracts::class)
fun requireNotEmpty(list: List<*>?): Boolean {
    contract {
        returns(true) implies (list != null)
        returns(false) implies (list == null)
    }
    return !list.isNullOrEmpty()
}

@OptIn(ExperimentalContracts::class)
inline fun <T> executeOnce(block: () -> T): T {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
    }
    return block()
}

// 이 계약 덕분에 val 초기화가 가능
val result: String
executeOnce {
    result = "초기화됨" // ✅ EXACTLY_ONCE이므로 val 초기화 허용
}
println(result) // ✅ 컴파일러가 초기화됨을 보장

// require 함수의 contract
public inline fun require(value: Boolean) {
    contract {
        returns() implies value // 함수가 정상 반환하면 value는 true
    }
    if (!value) throw IllegalArgumentException()
}

// 덕분에 이런 코드가 가능
fun process(name: String?) {
    require(name != null) // 이 줄을 지나면 name은 non-null
    println(name.length)  // ✅ 스마트 캐스트 동작
}

// check 함수도 동일한 패턴
fun validate(age: Int?) {
    check(age != null) { "나이가 null입니다" }
    println(age + 1) // ✅ Int로 스마트 캐스트
}

// 이 함수는 LoggingContext가 스코프에 있을 때만 호출 가능
context(LoggingContext)
fun processOrder(order: Order) {
    log("주문 처리 시작: ${order.id}") // LoggingContext의 멤버
    // ...
    log("주문 처리 완료")
}

interface LoggingContext {
    fun log(message: String)
}

interface TransactionContext {
    fun <T> execute(sql: String, vararg params: Any?): T
    fun commit()
    fun rollback()
}

// 이 함수들은 TransactionContext 안에서만 호출 가능
context(TransactionContext)
fun createUser(name: String, email: String): Long {
    return execute("INSERT INTO users (name, email) VALUES (?, ?)", name, email)
}

context(TransactionContext)
fun assignRole(userId: Long, role: String) {
    execute<Unit>("INSERT INTO user_roles (user_id, role) VALUES (?, ?)", userId, role)
}

// 사용
fun registerUser(name: String, email: String) {
    transaction { // TransactionContext를 스코프에 제공
        val userId = createUser(name, email)
        assignRole(userId, "USER")
        commit()
    }
}

context(LoggingContext, TransactionContext)
fun createUserWithLog(name: String, email: String): Long {
    log("사용자 생성 시작: $name")
    val userId = execute<Long>("INSERT INTO users ...", name, email)
    log("사용자 생성 완료: $userId")
    return userId
}

// 확장 함수 — "이 객체에 대해" 동작
fun LoggingContext.process(order: Order) { /* ... */ }

// context receiver — "이 컨텍스트 안에서" 동작
context(LoggingContext)
fun process(order: Order) { /* ... */ }

interface ValidationContext {
    fun addError(field: String, message: String)
    val errors: List<ValidationError>
    val isValid: Boolean get() = errors.isEmpty()
}

context(ValidationContext)
fun validateEmail(email: String) {
    if (!email.contains("@")) {
        addError("email", "유효한 이메일이 아닙니다")
    }
}

context(ValidationContext)
fun validateAge(age: Int) {
    if (age < 0 || age > 150) {
        addError("age", "유효한 나이가 아닙니다")
    }
}

fun validateUser(email: String, age: Int): List<ValidationError> {
    return buildValidation {
        validateEmail(email)
        validateAge(age)
    }.errors
}

context(TestContext)
fun User.shouldBeActive() {
    assert(this.isActive) { "사용자가 활성 상태여야 합니다" }
    log("검증 통과: 사용자 ${this.id} 활성 상태")
}

interface TransactionScope {
    fun <T> execute(sql: String, vararg params: Any?): T
}

// 확장 함수로 스코프 제한
fun TransactionScope.createUser(name: String, email: String): Long {
    return execute("INSERT INTO users ...", name, email)
}

// with로 스코프 제공
fun registerUser(name: String, email: String) {
    withTransaction { // this = TransactionScope
        val userId = createUser(name, email)
        // ...
    }
}