open class Rectangle {
    open var width: Int = 0
    open var height: Int = 0

    fun area(): Int = width * height
}

class Square : Rectangle() {
    // 정사각형은 width와 height가 항상 같아야 함
    override var width: Int = 0
        set(value) { field = value; super.height = value }   // height도 같이 변경
    override var height: Int = 0
        set(value) { field = value; super.width = value }    // width도 같이 변경
}

// 직사각형을 기대하는 코드
fun resize(rect: Rectangle) {
    rect.width = 10
    rect.height = 5
    println("넓이: ${rect.area()}")  // 기대값: 50
}

resize(Rectangle())  // 넓이: 50 ✅
resize(Square())     // 넓이: 25 ❌ — width=5, height=5 로 세팅됨

interface Shape {
    fun area(): Int
}

class Rectangle(val width: Int, val height: Int) : Shape {
    override fun area() = width * height
}

class Square(val side: Int) : Shape {
    override fun area() = side * side
}

// Shape를 받는 코드 — 어떤 구현체가 와도 area()는 올바르게 동작
fun printArea(shape: Shape) {
    println("넓이: ${shape.area()}")
}

printArea(Rectangle(10, 5))  // 넓이: 50
printArea(Square(5))         // 넓이: 25

open class Bird {
    open fun fly() {
        println("날고 있습니다")
    }
}

class Sparrow : Bird() {
    override fun fly() {
        println("참새가 날고 있습니다")
    }
}

// 타조는 새이지만 날 수 없음
class Ostrich : Bird() {
    override fun fly() {
        throw UnsupportedOperationException("타조는 날 수 없습니다")  // ❌
    }
}

fun makeBirdFly(bird: Bird) {
    bird.fly()  // Bird라면 당연히 날 수 있다고 기대
}

makeBirdFly(Sparrow())  // 참새가 날고 있습니다 ✅
makeBirdFly(Ostrich())  // UnsupportedOperationException 💥

interface Bird {
    fun breathe()
    fun eat()
}

interface FlyingBird : Bird {
    fun fly()
}

class Sparrow : FlyingBird {
    override fun breathe() = println("참새 호흡")
    override fun eat() = println("참새 식사")
    override fun fly() = println("참새가 날고 있습니다")
}

class Ostrich : Bird {
    override fun breathe() = println("타조 호흡")
    override fun eat() = println("타조 식사")
    // fly()는 없음 — 계약에도 없음 ✅
}

fun makeBirdFly(bird: FlyingBird) {
    bird.fly()  // FlyingBird라면 반드시 날 수 있음
}

makeBirdFly(Sparrow())  // 참새가 날고 있습니다 ✅
// makeBirdFly(Ostrich())  — 컴파일 에러로 방지 ✅

open class FileReader {
    open fun readLine(): String {
        return "파일 한 줄"
        // IOException 발생 가능 (checked)
    }
}

class NetworkFileReader : FileReader() {
    override fun readLine(): String {
        // ⚠️ 부모는 선언하지 않은 NetworkException을 던짐
        throw RuntimeException("네트워크 오류")
    }
}

fun process(reader: FileReader) {
    // FileReader를 믿고 예외 처리를 하지 않음
    val line = reader.readLine()  // NetworkFileReader라면 예외 발생
    println(line)
}

class NetworkFileReader(private val url: String) : FileReader() {
    override fun readLine(): String {
        return try {
            fetchLine(url)
        } catch (e: Exception) {
            ""  // 부모 계약 범위 안에서 처리
        }
    }

    private fun fetchLine(url: String): String = "네트워크에서 읽은 한 줄"
}

interface Repository<T> {
    fun findById(id: Long): T?
    fun save(item: T)
    fun delete(id: Long)
}

// 읽기 전용인데 Repository를 구현 — save/delete를 막아야 함
class ReadOnlyUserRepository : Repository<User> {
    override fun findById(id: Long): User? = User(id, "홍길동")

    override fun save(item: User) {
        throw UnsupportedOperationException("읽기 전용입니다")  // ❌
    }

    override fun delete(id: Long) {
        throw UnsupportedOperationException("읽기 전용입니다")  // ❌
    }
}

fun syncUser(repo: Repository<User>, id: Long) {
    val user = repo.findById(id) ?: return
    repo.save(user.copy(name = "업데이트"))  // ReadOnlyUserRepository면 예외 💥
}

interface ReadableRepository<T> {
    fun findById(id: Long): T?
    fun findAll(): List<T>
}

interface WritableRepository<T> : ReadableRepository<T> {
    fun save(item: T)
    fun delete(id: Long)
}

// 읽기 전용 — 계약에 쓰기 없음
class ReadOnlyUserRepository : ReadableRepository<User> {
    override fun findById(id: Long): User? = User(id, "홍길동")
    override fun findAll(): List<User> = listOf(User(1L, "홍길동"))
}

// 읽기/쓰기 모두 지원
class UserRepository : WritableRepository<User> {
    private val store = mutableMapOf<Long, User>()

    override fun findById(id: Long) = store[id]
    override fun findAll() = store.values.toList()
    override fun save(item: User) { store[item.id] = item }
    override fun delete(id: Long) { store.remove(id) }
}

// 읽기만 필요한 곳은 ReadableRepository를 받음
fun displayUser(repo: ReadableRepository<User>, id: Long) {
    println(repo.findById(id))
}

// 쓰기까지 필요한 곳은 WritableRepository를 받음
fun syncUser(repo: WritableRepository<User>, id: Long) {
    val user = repo.findById(id) ?: return
    repo.save(user.copy(name = "업데이트"))  // 안전 ✅
}

sealed class ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>()
    data class Failure(val error: Throwable) : ApiResult<Nothing>()
    object Loading : ApiResult<Nothing>()
}

fun <T> handleResult(result: ApiResult<T>) {
    when (result) {
        is ApiResult.Success  -> println("성공: ${result.data}")
        is ApiResult.Failure  -> println("실패: ${result.error.message}")
        is ApiResult.Loading  -> println("로딩 중...")
        // 새 서브타입 추가 시 컴파일 에러로 강제 처리 ✅
    }
}