import androidx.compose.runtime.LaunchedEffect

@Composable
fun UserProfileScreen(userId: String, viewModel: ProfileViewModel = viewModel()) {
    // LaunchedEffect(key1 = userId): userId가 바뀔 때마다 새로 실행
    // 최초 컴포지션 시 1회 실행 + userId 값이 변경될 때마다 재실행
    LaunchedEffect(userId) {
        viewModel.loadUser(userId)  // suspend 함수 호출 가능
    }

    // LaunchedEffect(Unit): 딱 한 번만 실행 (컴포지션에 처음 들어올 때)
    LaunchedEffect(Unit) {
        viewModel.logScreenView("ProfileScreen")
    }

    // 화면 UI...
}

// key가 여러 개인 경우: 둘 중 하나라도 바뀌면 재실행
@Composable
fun SearchResults(query: String, filter: String) {
    var results by remember { mutableStateOf<List<Item>>(emptyList()) }

    LaunchedEffect(query, filter) {  // query 또는 filter가 바뀔 때마다 재검색
        results = searchApi(query, filter)
    }

    LazyColumn { items(results) { ItemRow(it) } }
}

import androidx.compose.runtime.rememberCoroutineScope
import kotlinx.coroutines.launch

@Composable
fun ScrollToTopButton(listState: LazyListState) {
    // rememberCoroutineScope: Composable의 생명주기에 묶인 CoroutineScope 생성
    val scope = rememberCoroutineScope()

    Button(onClick = {
        // onClick은 suspend 함수가 아니므로 직접 suspend 함수를 호출할 수 없음
        // → scope.launch로 코루틴을 새로 시작해야 함
        scope.launch {
            listState.animateScrollToItem(0)
        }
    }) {
        Text("맨 위로")
    }
}

import androidx.compose.runtime.DisposableEffect

@Composable
fun LifecycleAwareComponent(lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current) {
    var isResumed by remember { mutableStateOf(false) }

    // DisposableEffect(key): key가 바뀌거나 Composable이 제거될 때 onDispose 실행
    DisposableEffect(lifecycleOwner) {
        val observer = LifecycleEventObserver { _, event ->
            when (event) {
                Lifecycle.Event.ON_RESUME -> isResumed = true
                Lifecycle.Event.ON_PAUSE  -> isResumed = false
                else -> {}
            }
        }
        // 등록: Composable이 컴포지션에 들어올 때 리스너 등록
        lifecycleOwner.lifecycle.addObserver(observer)

        // onDispose: 반드시 반환해야 함 — Composable이 사라지거나 key가 바뀔 때 실행
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)  // 리스너 해제 (메모리 누수 방지)
        }
    }

    Text(if (isResumed) "화면 활성 상태" else "화면 비활성 상태")
}

import androidx.compose.runtime.SideEffect

@Composable
fun AnalyticsScreen(userId: String, analyticsService: AnalyticsService) {
    // SideEffect: 재구성이 "성공적으로 완료될 때마다" 실행 (조건 key 없음)
    // Compose 외부 시스템(analyticsService)에 최신 상태를 동기화하는 용도
    SideEffect {
        analyticsService.setUserProperty("user_id", userId)
    }

    // 화면 UI...
}

import androidx.compose.runtime.produceState

@Composable
fun rememberNetworkStatus(): State<Boolean> {
    val context = LocalContext.current

    // produceState: 초기값을 주고, 블록 안에서 값을 갱신하는 State 생성
    return produceState(initialValue = false) {
        val connectivityManager = context.getSystemService(ConnectivityManager::class.java)
        val callback = object : ConnectivityManager.NetworkCallback() {
            override fun onAvailable(network: Network) { value = true }   // State 값 갱신
            override fun onLost(network: Network) { value = false }
        }
        connectivityManager.registerDefaultNetworkCallback(callback)

        // awaitDispose: DisposableEffect의 onDispose와 동일한 역할
        awaitDispose {
            connectivityManager.unregisterNetworkCallback(callback)
        }
    }
}

// 사용
@Composable
fun NetworkStatusBanner() {
    val isConnected by rememberNetworkStatus()
    if (!isConnected) {
        Text("네트워크 연결 없음", color = Color.Red)
    }
}

@Composable
fun Timeout(onTimeout: () -> Unit) {
    // rememberUpdatedState: onTimeout이 재구성으로 바뀌어도 항상 최신 참조 유지
    val currentOnTimeout by rememberUpdatedState(onTimeout)

    // LaunchedEffect(true): 절대 재실행되지 않음 (컴포지션 동안 딱 한 번의 대기)
    LaunchedEffect(true) {
        delay(5000)
        currentOnTimeout()  // 5초 뒤 실행 시점의 "최신" onTimeout 사용
    }
}