class Example {
    public val publicProp = "공개"
    internal val internalProp = "모듈 내부"
    protected val protectedProp = "하위 클래스"
    private val privateProp = "클래스 내부"
}

// Kotlin에는 package-private 없음 (Java의 default)
// Kotlin의 internal이 더 강력한 대안

// Java: package-private (같은 패키지면 접근 가능)
// → 외부 라이브러리에서 같은 패키지명으로 접근 가능 (취약)

// Kotlin: internal (컴파일 모듈 단위로 제한)
// → 다른 모듈에서는 접근 불가 (더 안전한 캡슐화)

internal class InternalService {  // 이 모듈 밖에서 사용 불가
    fun process() = "내부 처리"
}

// :core 모듈

// 외부에 공개할 API
public interface UserRepository {
    suspend fun getUser(id: Int): User
    suspend fun saveUser(user: User)
}

// 모듈 내부 구현 — 외부에서 직접 접근 불가
internal class UserRepositoryImpl(
    private val dao: UserDao,
    private val api: UserApi
) : UserRepository {
    override suspend fun getUser(id: Int): User { /* ... */ }
    override suspend fun saveUser(user: User) { /* ... */ }
}

// Hilt 등 DI에서 internal 구현체 바인딩
@Module
@InstallIn(SingletonComponent::class)
internal object CoreModule {
    @Provides
    fun provideUserRepository(dao: UserDao, api: UserApi): UserRepository =
        UserRepositoryImpl(dao, api)
}

// :app 모듈
// UserRepository (public 인터페이스) → 사용 가능
// UserRepositoryImpl (internal) → 접근 불가 (캡슐화 성공)
class UserViewModel(private val repo: UserRepository) : ViewModel()

// Utils.kt

private fun helperFunction() = "내부 도우미"  // 이 파일 안에서만 사용

fun publicFunction(): String {
    return helperFunction()  // 같은 파일 → OK
}

// Other.kt
// helperFunction()  // 컴파일 에러: 다른 파일에서 접근 불가

abstract class BaseViewModel : ViewModel() {
    // 하위 클래스에서만 사용 가능
    protected fun launchSafely(block: suspend CoroutineScope.() -> Unit) {
        viewModelScope.launch {
            try { block() }
            catch (e: Exception) { handleError(e) }
        }
    }

    protected open fun handleError(e: Exception) {
        println("에러: ${e.message}")
    }
}

class UserViewModel : BaseViewModel() {
    fun loadUser(id: Int) {
        launchSafely {  // protected 함수 사용
            val user = repository.getUser(id)
            _user.value = user
        }
    }

    override fun handleError(e: Exception) {
        super.handleError(e)
        _error.value = e.message
    }
}

@PublishedApi
internal fun internalHelper(): String = "내부 구현"

inline fun publicInlineFunction(): String {
    return internalHelper()  // @PublishedApi 없으면 컴파일 에러
}

// SDK 설계 시 internal로 구현 세부사항 숨기기
class AnalyticsSDK private constructor(
    private val apiKey: String
) {
    // 공개 API
    fun track(event: String, properties: Map<String, Any> = emptyMap()) {
        internalTracker.send(event, properties)
    }

    fun identify(userId: String) {
        internalTracker.setUser(userId)
    }

    companion object {
        @JvmStatic
        fun create(apiKey: String): AnalyticsSDK = AnalyticsSDK(apiKey)
    }

    // 내부 구현 — SDK 사용자에게 노출 안 됨
    internal val internalTracker = EventTracker(apiKey)
    internal fun flushQueue() = internalTracker.flush()
}

internal class EventTracker(private val apiKey: String) {
    fun send(event: String, properties: Map<String, Any>) { /* ... */ }
    fun setUser(userId: String) { /* ... */ }
    fun flush() { /* ... */ }
}