위임 패턴 — by 키워드로 상속 없이 기능을 재사용하는 방법

interface Logger {
    fun log(message: String)
    fun error(message: String)
}

class ConsoleLogger : Logger {
    override fun log(message: String) = println("[LOG] $message")
    override fun error(message: String) = println("[ERROR] $message")
}

// ConsoleLogger에게 Logger 구현을 위임
class UserService(logger: Logger) : Logger by logger {
    fun createUser(name: String) {
        log("사용자 생성: $name") // Logger의 메서드를 직접 호출 가능
    }
}

class FilteredLogger(private val delegate: Logger) : Logger by delegate {
    // error만 직접 구현, log는 위임
    override fun error(message: String) {
        delegate.error("[FILTERED] $message")
        // 추가 로직: 알림 전송 등
    }
}

class DatabaseConnection {
    // 처음 접근할 때 한 번만 초기화
    val connection by lazy {
        println("DB 연결 생성")
        DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb")
    }
}

// 단일 스레드 환경이라면 NONE으로 오버헤드 제거
val config by lazy(LazyThreadSafetyMode.NONE) {
    loadConfig()
}

import kotlin.properties.Delegates

class User {
    var name: String by Delegates.observable("초기값") { property, oldValue, newValue ->
        println("${property.name}: $oldValue → $newValue")
    }
}

val user = User()
user.name = "김코틀린" // name: 초기값 → 김코틀린

var age: Int by Delegates.vetoable(0) { _, _, newValue ->
    newValue >= 0 // 음수는 거부
}

age = 25  // 성공
age = -1  // 거부 — age는 여전히 25

import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty

// 값 변경 시 자동으로 trim 적용하는 위임
class TrimmedString(private var value: String = "") : ReadWriteProperty<Any?, String> {

    override fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return value
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        this.value = value.trim()
    }
}

class Form {
    var username: String by TrimmedString()
    var email: String by TrimmedString()
}

val form = Form()
form.username = "  김코틀린  "
println(form.username) // "김코틀린" — 자동 trim

class ValidatedProperty(private val pattern: Regex) {
    operator fun provideDelegate(
        thisRef: Any?,
        property: KProperty<*>
    ): ReadWriteProperty<Any?, String> {
        // 프로퍼티 이름 검증 등
        println("${property.name} 프로퍼티에 위임 등록")
        return object : ReadWriteProperty<Any?, String> {
            private var value = ""
            override fun getValue(thisRef: Any?, property: KProperty<*>) = value
            override fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
                require(value.matches(pattern)) { "패턴 불일치: $value" }
                this.value = value
            }
        }
    }
}

class Config {
    var port: String by ValidatedProperty(Regex("\\d+"))
}

class User(map: Map<String, Any?>) {
    val name: String by map
    val age: Int by map
}

val user = User(mapOf("name" to "김코틀린", "age" to 28))
println(user.name) // 김코틀린
println(user.age)  // 28

class MutableUser(map: MutableMap<String, Any?>) {
    var name: String by map
    var age: Int by map
}

interface HasLogger {
    val logger: org.slf4j.Logger
}

class LoggerDelegate : HasLogger {
    override val logger by lazy {
        org.slf4j.LoggerFactory.getLogger(this::class.java)
    }
}

class OrderService : HasLogger by LoggerDelegate() {
    fun placeOrder() {
        logger.info("주문 생성")
    }
}

class PreferenceProperty<T>(
    private val prefs: SharedPreferences,
    private val key: String,
    private val defaultValue: T
) : ReadWriteProperty<Any?, T> {
    @Suppress("UNCHECKED_CAST")
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        return prefs.all[key] as? T ?: defaultValue
    }

    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        prefs.edit().apply {
            when (value) {
                is String -> putString(key, value)
                is Int -> putInt(key, value)
                is Boolean -> putBoolean(key, value)
                else -> throw IllegalArgumentException("지원하지 않는 타입")
            }
            apply()
        }
    }
}