Compose side effect APIs: LaunchedEffect, DisposableEffect

// SideEffect: runs after EVERY successful recomposition; no key, no cleanup.
// Use only to push Compose state into non-Compose systems.
SideEffect { analyticsTracker.setScreen("Home") }

// LaunchedEffect: launches a suspending coroutine; cancels and restarts on key change;
// cancelled automatically when composable leaves.
// Use for async work triggered by entering composition or state changes.
LaunchedEffect(userId) { viewModel.loadUser(userId) }

// DisposableEffect: for non-suspend side effects that need cleanup.
// onDispose runs when the key changes OR composable leaves. Always provide cleanup.
DisposableEffect(lifecycle) {
    val observer = LifecycleEventObserver { _, event -> viewModel.onLifecycle(event) }
    lifecycle.addObserver(observer)
    onDispose { lifecycle.removeObserver(observer) }  // always required
}

// ❌ WRONG: using LaunchedEffect for a non-suspend listener registration
// (no cleanup possible — the listener leaks when composable leaves)
LaunchedEffect(Unit) {
    SomeSdk.addListener { event -> handle(event) }
    // Never removed
}

// ✅ Use DisposableEffect instead for any registration that needs cleanup
DisposableEffect(Unit) {
    SomeSdk.addListener { event -> handle(event) }
    onDispose { SomeSdk.removeListener() }
}

// ❌ CHURN: new filtered List and new onClick lambdas created on every recomposition
@Composable
fun FeedScreen(posts: List<Post>, onLike: (Post) -> Unit) {
    val activePosts = posts.filter { it.isActive }  // new List every time
    LazyColumn {
        items(activePosts) { post ->
            PostCard(post, onClick = { onLike(post) })  // new lambda per item per recompose
        }
    }
}

// ✅ CORRECT: cache expensive computations; pass stable lambdas from ViewModel
@Composable
fun FeedScreen(posts: List<Post>, onLike: (Post) -> Unit) {
    val activePosts = remember(posts) { posts.filter { it.isActive } }  // recomputed only when posts changes
    LazyColumn {
        items(activePosts, key = { it.id }) { post ->   // stable key avoids full rebind
            PostCard(post, onClick = { onLike(post) })
        }
    }
}
// Move filtering to ViewModel so composable receives already-filtered list

// ❌ WRONG: Toast shown on every recomposition (including trivial state changes)
@Composable
fun WelcomeScreen() {
    Toast.makeText(LocalContext.current, "Welcome!", Toast.LENGTH_SHORT).show()
}

// ✅ CORRECT: wrap in LaunchedEffect(Unit) — runs once on entry;
//             use applicationContext for Toast to avoid capturing the Activity context
@Composable
fun WelcomeScreen() {
    val context = LocalContext.current.applicationContext  // applicationContext — rotation-safe
    LaunchedEffect(Unit) {
        Toast.makeText(context, "Welcome!", Toast.LENGTH_SHORT).show()
    }
}

// ❌ MEMORY WASTE: replay buffer retains the last emission of a large search result page
class SearchViewModel : ViewModel() {
    private val _results = MutableSharedFlow<SearchResultPage>(replay = 1)
    // SearchResultPage contains a List<Product> with thumbnails — potentially MBs
    // Even after the user navigates away, the last page stays pinned in the replay cache
    val results: SharedFlow<SearchResultPage> = _results
}

// ✅ CORRECT option A: use StateFlow — single cached value, clearly intentional
class SearchViewModel : ViewModel() {
    private val _results = MutableStateFlow<SearchResultPage?>(null)
    val results: StateFlow<SearchResultPage?> = _results.asStateFlow()

    fun clearResults() { _results.value = null }  // explicitly release on navigate away
}

// ✅ CORRECT option B: replay = 0 for event streams where no cache is needed
class SearchViewModel : ViewModel() {
    private val _events = MutableSharedFlow<SearchEvent>(replay = 0, extraBufferCapacity = 1)
    val events: SharedFlow<SearchEvent> = _events
}

// ✅ CORRECT option C: if large payload is needed, emit only IDs and load on demand
class SearchViewModel : ViewModel() {
    private val _resultIds = MutableStateFlow<List<String>>(emptyList())
    val resultIds: StateFlow<List<String>> = _resultIds.asStateFlow()
    // UI fetches full objects from Room cache by ID — no large objects pinned in Flow
}