@Serializable
data class Detail(val article: Article) : RouteScreen() {
    companion object {
        val typeMap = mapOf(typeOf<Detail>() to ArticlesType)
    }
}
object ArticlesType : NavType<Article>(isNullableAllowed = false) {
    override fun put(bundle: Bundle, key: String, value: Article) {
        bundle.putParcelable(key, value)
    }

    override fun get(bundle: Bundle, key: String): Article? =
        BundleCompat.getParcelable(bundle, key, Article::class.java)

    override fun parseValue(value: String): Article =
        Json.decodeFromString(Uri.decode(value))

    override fun serializeAsValue(value: Article): String =
        Uri.encode(Json.encodeToString(value))
}

NavHost(navController = navHostController, startDestination = "home") {
    composable("home") {
        HomeScreen(
            onNavigateToDetail = { id, title ->
                navHostController.navigate("detail/$id/$title")
            }
        )
    }
    composable(
        route = "detail/{id}/{title}",
        arguments = listOf(
            navArgument("id") { type = NavType.IntType },
            navArgument("title") { type = NavType.StringType }
        )
    ) {
        val id = it.arguments?.getInt("id")
        val title = it.arguments?.getString("title")
        DetailScreen(id = id, title = title)
    }
}

internal class ArticlesRepositoryImpl @Inject constructor(
    @Dispatcher(IO) private val ioDispatcher: CoroutineDispatcher
) {
    override fun getArticles(): Flow<List<Article>> =
        flow {
            emit(api.getArticles())
        }.flowOn(ioDispatcher)
}

// Retrofit의 기본 Call<T> → ApiResponse<T>로 자동 래핑
addCallAdapterFactory(ApiResponseCallAdapterFactory.create())
// 기본 형태
suspend fun getArticles(): Response<List<Article>>

// Sandwich가 만든 형태
suspend fun getArticles(): ApiResponse<List<Article>>

apiService.getSomething().onException {
    if (exception is UnknownHostException) {
        // 네트워크 끊김일 경우
    } else if (exception is SocketTimeoutException) {
        // 응답이 너무 늦는 경우
    }
}

val LocalBackgroundTheme = staticCompositionLocalOf { ArticleBackground() }

val LocalColors = compositionLocalOf<ArticleColors> {
    error("No colors provided")
}

// Local 정의
val LocalWindowSizeClass = staticCompositionLocalOf<WindowSizeClass> {
    error("WindowSizeClass not provided")
}

// CompositionLocalProvider 설정
val windowSizeClass = calculateWindowSizeClass(LocalContext.current as Activity)
CompositionLocalProvider(LocalWindowSizeClass provides windowSizeClass) {
    AppContent()
}

// 반응형 계산
@Composable
fun rememberResponsiveGridCells(): GridCells {
    return when (LocalWindowSizeClass.current.widthSizeClass) {
        WindowWidthSizeClass.Compact -> GridCells.Fixed(2)
        WindowWidthSizeClass.Medium -> GridCells.Adaptive(160.dp)
        WindowWidthSizeClass.Expanded -> GridCells.Adaptive(200.dp)
        else -> GridCells.Fixed(2)
    }
}

// 사용 예시
LazyVerticalGrid(columns = rememberResponsiveGridCells()) { ... }

SharedTransitionLayout
└── NavHost
├── composable<Home>
│   └── HomeScreen(animatedVisibilityScope, sharedTransitionScope)
└── composable<Detail>
    └── DetailScreen(animatedVisibilityScope, sharedTransitionScope)

SharedTransitionLayout
└── CompositionLocalProvider(LocalSharedTransitionScope)
└── NavHost
├── composable<Home>
│   └── CompositionLocalProvider(LocalAnimatedVisibilityScope)
│       └── HomeScreen() // 내부에서 Local*.current 로 스코프 접근
└── composable<Detail>
    └── CompositionLocalProvider(LocalAnimatedVisibilityScope)
        └── DetailScreen()

class SpotlessConventionPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        ...
    }
}

@Module
@InstallIn(SingletonComponent::class)
object DataStoreModule {

    private const val LIKE_DATA_STORE_NAME = "LIKE_PREFERENCES"
    
    private val Context.likeDataStore by preferencesDataStore(LIKE_DATA_STORE_NAME)  //컴파일 타임에 생성

    @Provides
    @Singleton 
    fun provideLikeDataStore(
        @ApplicationContext context: Context
    ) : DataStore<Preferences> = context.likeDataStore
}