public fun LaunchedEffect(key1: Any?, block: suspend CoroutineScope.() -> Unit)

@Composable
fun MyComposable(count: Int, onIncrement: () -> Unit) {
    val name = remember { mutableStateOf("Loading...") }
    LaunchedEffect(Unit) {
        Log.d("EffectTest", "LaunchedEffect 시작: 사용자 이름 가져오는 중...")
        name.value = fetchUserName()
    }

    Column {
        Text(
            text = "Hello ${name.value}!, count: $count",
            modifier = Modifier
        )
        Button(onClick = onIncrement) {
            Text(text = "Click Me") // 카운트 증가 (리컴포지션 유발)
        }
    }
}

suspend fun fetchUserName(): String {
    delay(1000) // 1초 지연 시뮬레이션
    return listOf("Jame", "Json", "Dean").random()
}

@Composable
fun MyComposable(count: Int, onIncrement: () -> Unit) {
    val name = remember { mutableStateOf("Loading...") }
    LaunchedEffect(count) {
        Log.d("EffectTest", "Key $count: LaunchedEffect 시작: 사용자 이름 가져오는 중...")
        try {
            name.value = fetchUserName()
        } catch (e: CancellationException) {
            Log.w("EffectTest", "Key $count: 이전 코루틴이 취소되었습니다!")
        } finally {
            Log.d("EffectTest", "--- LaunchedEffect 종료 (Key: $count) ---")
        }
    }

    Column {
        Text(
            text = "Hello ${name.value}!, count: $count",
            modifier = Modifier
        )
        Button(onClick = onIncrement) {
            Text(text = "Click Me") // 카운트 증가 (리컴포지션 유발)
        }
    }
}

suspend fun fetchUserName(): String {
    delay(5000) // 5초 지연 시뮬레이션
    return listOf("Jame", "Json", "Dean").random()
}

D  Key 0: LaunchedEffect 시작: 사용자 이름 가져오는 중...
W  Key 0: 이전 코루틴이 취소되었습니다!
D  --- LaunchedEffect 종료 (Key: 0) ---
D  Key 1: LaunchedEffect 시작: 사용자 이름 가져오는 중...
D  --- LaunchedEffect 종료 (Key: 1) ---

// [문제점] onClick은 suspend 함수를 직접 호출할 수 없음
@Composable
fun BadSnackbarExample(snackbarHostState: SnackbarHostState) {
    Button(
        onClick = {
            // 🚨 컴파일 오류 발생: suspend 함수는 코루틴 내에서만 호출 가능
            // snackbarHostState.showSnackbar("메시지")
        }
    ) {
        Text("스낵바 표시")
    }
}

//
@Composable
fun BadSnackbarExample(snackbarHostState: SnackbarHostState) {
    Button(
        onClick = {
            // 🚨 문제점 1: GlobalScope 사용은 지양됨 (앱 전체 생명주기에 연결되어 취소 관리가 어려움)
            // 🚨 문제점 2: 해당 컴포저블이 사라져도 작업이 계속 실행될 수 있음
            GlobalScope.launch { 
                snackbarHostState.showSnackbar("메시지")
            }
        }
    ) {
        Text("스낵바 표시")
    }
}

// ✅ Case 2: rememberCoroutineScope 사용 (권장되는 방법)
@Composable
fun GoodSnackbarExample(snackbarHostState: SnackbarHostState) {
    // ✨ 장점 1: 컴포저블의 생명주기에 연결된 Scope를 안전하게 기억 (remember)
    val scope = rememberCoroutineScope() 

    Button(
        onClick = {
            // ✨ 장점 2: 해당 Scope 내에서 코루틴을 시작하여 suspend 함수 호출
            scope.launch { 
                // ✨ 장점 3: 컴포저블이 사라지면 이 코루틴도 자동 취소됨
                snackbarHostState.showSnackbar(
                    message = "메시지가 표시되었습니다!",
                    actionLabel = "닫기"
                )
            }
        }
    ) {
        Text("스낵바 표시")
    }
}

// ⚠️ Stale State 문제가 발생하는 Composable 함수
@Composable
fun BadStateContent(count: Int, onClick: () -> Unit) {
    // LaunchedEffect의 Key가 Unit이므로, 컴포저블이 화면에 있는 동안 단 한 번만 실행됨 (재시작되지 않음)
    LaunchedEffect(Unit) {
        // 1. LaunchedEffect가 처음 실행될 때의 count 값만 캡처하여 기억함
        Log.d("Remember", "5초 타이머 시작! 초기 count: $count")

        delay(5000) // 5초 동안 비동기 대기

        // 2. 5초 후 호출 시점: 
        // 외부에서 Button 클릭으로 인해 count가 1, 2, 3 등으로 증가해도, 
        // 이 블록 안의 count는 LaunchedEffect가 시작될 때 캡처한 '오래된 초기값'($count)만 유지하고 출력합니다.
        Log.d("Remember", "5초 후 LaunchedEffect 내부의 count: $count") // ❌ Stale State(오래된 상태) 출력!
    }

    Column {
        // 이 Text는 리컴포지션될 때마다 최신 count 값을 즉시 반영하여 출력함
        Text("현재 화면에 표시되는 최신 count: $count")
        Button(onClick = onClick) {
            Text("Click Me (count 증가)")
        }
    }
}

// ✨ LaunchedEffect 내부에서 최신 상태를 참조하는 Composable 함수
@Composable
fun CorrectStateContent(count: Int, onClick: () -> Unit) {
    
    // 💡 해결책: 'count' 값을 rememberUpdatedState로 래핑하여 최신 값을 기억합니다.
    // 'latestCount'는 컴포저블이 리컴포즈될 때마다 자동으로 최신 count 값으로 업데이트됩니다.
    val latestCount by rememberUpdatedState(count)

    // Key = Unit: 타이머는 절대 재시작되지 않고 5초 동안 실행을 유지합니다.
    LaunchedEffect(Unit) { 
        Log.d("Remember", "5초 타이머 시작! (재시작 없음)")
        
        delay(5000) // 5초 동안 비동기 대기
        
        // 1. 5초 후 호출 시점: 
        // LaunchedEffect는 'latestCount'를 참조합니다. 
        // latestCount는 불변 객체이지만, 내부적으로는 가장 최신 업데이트된 count 값을 가지고 있습니다.
        Log.d("Remember", "5초 후 LaunchedEffect 내부의 최신 count: $latestCount") // ✅ 최신 상태(Latest State) 출력!
    }
    
    Column {
        // 화면 표시는 여전히 최신 count 값을 즉시 반영
        Text("현재 화면에 표시되는 최신 count: $count") 
        Button(onClick = onClick) {
            Text("Click Me (count 증가)")
        }
    }
}

@Composable
fun HomeScreen(
    lifecycleOwner: LifecycleOwner = LocalLifecycleOwner.current,
    onStart: ()->Unit, // '시작됨(started)' 분석 이벤트를 전송
    onStop: ()->Unit //'종료됨(stopped)' 분석 이벤트를 전송
) {
    // 새로운 람다가 제공될 때 현재 람다를 안전하게 업데이트합니다.
    val currentOnStart = rememberUpdatedState(onStart)
    val currentOnStop = rememberUpdatedState(onStop)

    // `lifecycleOwner`가 변경되면, 이 effect를 폐기하고 재설정합니다
    DisposableEffect(lifecycleOwner) {
        // 분석 이벤트 전송을 위해 저장된 콜백을 트리거하는 옵저버를 생성합니다.
        val observer = LifecycleEventObserver { _, event ->
            if (event == Lifecycle.Event.ON_START) {
                currentOnStart.value()
            } else if (event == Lifecycle.Event.ON_STOP) {
                currentOnStop.value()
            }
        }

        lifecycleOwner.lifecycle.addObserver(observer = observer)

        // 이 effect를 호출한 컴포저블이 사라지게 되면 옵저버를 제거합니다.
        onDispose {
            lifecycleOwner.lifecycle.removeObserver(observer)
        }
    }
}

@Composable
fun rememberFirebaseAnalytics(user: User): FirebaseAnalytics {
    // remember 로 FirebaseAnalytics 는 한번만 생성
    val analytics: FirebaseAnalytics = remember {
        FirebaseAnalytics()
    }

    // user 변경에 의해 컴포지션이 발생할 때마다,
    // 현재 User의 userType으로 FirebaseAnalytics를 업데이트 합니다. 
    // 이로써 향후 모든 분석 이벤트에 해당 메타데이터가 첨부되도록 보장합니다.
    SideEffect {
        analytics.setUserProperty("userType", user.userType)
    }
    return analytics
}

@Composable
fun loadNetworkImage(
    url: String,
    imageRepository: ImageRepository = ImageRepository()
): State<Result<Image>> {
    // Result.Loading을 초기값으로 갖는 State<T>를 생성합니다.
    // 만약 `url` 또는 `imageRepository`가 변경되면, 실행 중이던 생산자(producer)는 취소되고
    // 새로운 입력값(url, imageRepository)으로 다시 시작됩니다.
    return produceState<Result<Image>>(initialValue = Result.Loading, url, imageRepository) {
        // produceState 내부: LaunchedEffect와 동일하게 코루틴 환경이 제공됩니다.
        // 코루틴 내에서 정지 함수(suspend calls)를 호출할 수 있습니다.
        val image = imageRepository.load(url)

        // State 값 업데이트: 에러(Error) 또는 성공(Success) 결과로 State를 갱신합니다.
        // 💡 이 'value =' 업데이트는 이 State를 읽고 있는 모든 Composable에서
        //    자동으로 Recomposition을 트리거합니다.
        value = if (image == null) {
            Result.Error
        } else {
            Result.Success(image)
        }
    }
}

// 외부 시스템: 콜백을 통해 위치를 업데이트하는 가상의 매니저
data class Location(val latitude: Double, val longitude: Double)

interface LocationListener {
    fun onLocationUpdate(location: Location)
}

class LocationManager {
    private var listener: LocationListener? = null

    fun registerListener(l: LocationListener) {
        listener = l
        // 💡 최초 위치를 즉시 제공한다고 가정
        l.onLocationUpdate(Location(37.5665, 126.9780)) // 서울 시청
    }

    fun unregisterListener() {
        listener = null
    }

    // 외부에서 임의로 위치를 변경시키는 함수 (실제로는 GPS 갱신으로 발생)
    fun simulateLocationChange(newLocation: Location) {
        listener?.onLocationUpdate(newLocation)
    }
}

@Composable
fun observeCurrentLocation(manager: LocationManager, initialLocation: Location): State<Location> {
    // [1] produceState 시작: 초기 값(initialLocation)을 설정하고 코루틴 스코프 제공
    return produceState(initialValue = initialLocation, key1 = manager) {
        
        // [2] 콜백 리스너 정의: LocationManager가 위치를 업데이트하면 produceState의 'value'를 갱신
        val listener = object : LocationListener {
            override fun onLocationUpdate(location: Location) {
                // 💡 이 코드를 통해 Compose State 값이 업데이트되고 Recomposition이 발생합니다.
                value = location 
            }
        }

        // [3] 리스너 등록 (Effect 시작)
        manager.registerListener(listener)

        // [4] onDispose 블록: Composable이 제거되거나 'manager' 키가 변경될 때 정리 작업 실행
        awaitDispose {
            manager.unregisterListener() // 리스너 해제
        }
    }
}

@Composable
fun LocationDisplayScreen() {
    val locationManager = remember { LocationManager() }
    
    // 초기 위치를 '0.0, 0.0'으로 설정하고, observeCurrentLocation을 통해 실제 위치를 구독
    val locationState = observeCurrentLocation(
        manager = locationManager,
        initialLocation = Location(0.0, 0.0) 
    )
    
    val location = locationState.value // State의 현재 값 참조
    
    // UI 로직 (State 값이 변경될 때마다 자동 업데이트됨)
    Column(Modifier.padding(16.dp)) {
        Text("현재 위치 정보", style = MaterialTheme.typography.h6)
        Text("위도 (Latitude): ${location.latitude}")
        Text("경도 (Longitude): ${location.longitude}")

        Spacer(Modifier.height(16.dp))

        // 위치 변경 시뮬레이션 버튼
        Button(onClick = {
            val newLat = location.latitude + 0.001
            val newLon = location.longitude + 0.001
            // 💡 외부 매니저의 상태를 변경하여, 콜백을 통해 Compose 상태가 갱신되도록 유도
            locationManager.simulateLocationChange(Location(newLat, newLon))
        }) {
            Text("위치 시뮬레이션 갱신")
        }
    }
}

@Composable
fun MessageList(messages: List<Message>) { // MessageList 함수는 메시지 목록을 매개변수로 받습니다.
    Box {
        val listState = rememberLazyListState() // LazyColumn의 스크롤 상태를 기억합니다.
        LazyColumn(state = listState) {
            // ... 메시지 아이템들 ...
        }
        
        // 첫 번째 보이는 항목이 첫 번째 항목(index 0)을 지났을 때 버튼을 표시합니다.
        // 불필요한 리컴포지션을 최소화하기 위해, 
        // remembered derived state 를 사용합니다.
        val showButton by remember { 
            // derivedStateOf를 사용하여 불필요한 리컴포지션을 최소화합니다.
            derivedStateOf { 
                listState.firstVisibleItemIndex > 0 // 첫 번째 보이는 항목의 인덱스가 0보다 클 때 (즉, 목록이 스크롤되어 상단이 안 보일 때)
            }
        }
        
        AnimatedVisibility(visible = showButton) {
            ScrollToTopButton() // "맨 위로 스크롤" 버튼 표시
        }
    }
}

// ⚠️ 사용하지 금지. derivedStateOf의 잘못된 사용 예시입니다.
var firstName by remember { mutableStateOf("") } 
var lastName by remember { mutableStateOf("") } 

// ❌ 나쁜 사용: derivedStateOf를 사용하여 불필요하게 fullName을 계산합니다.
// (firstName이나 lastName이 변경될 때마다 fullNameBad의 'State 객체'가 업데이트되고 리컴포즈를 유발합니다.)
val fullNameBad by remember { derivedStateOf { "$firstName $lastName" } } 

// ✅ 올바른 사용: 이 방법이 가장 단순하고 효율적입니다.
// (firstName이나 lastName이 변경되면 이 Composable이 리컴포즈될 때 fullNameCorrect가 자동으로 최신 값을 계산합니다.)
val fullNameCorrect = "$firstName $lastName"

val listState = rememberLazyListState()

LazyColumn(state = listState) {
    // ...
}

LaunchedEffect(listState) {
    snapshotFlow { listState.firstVisibleItemIndex }
        .map { index -> index > 0 }
        .distinctUntilChanged()
        .filter { it == true }
        .collect {
            // 이벤트 전송
            MyAnalyticsService.sendScrolledPastFirstItemEvent()
        }
}

EffectName(restartIfThisKeyChanges, orThisKey, orThisKey, ...) { block }