Flow,
StateFlow,
SharedFlow
& Channels

class FeedViewModel(repo: FeedRepository) : ViewModel() {

    // replay=0: no history. New subscribers see nothing until next emit.
    // extraBufferCapacity=1: don't suspend emitter for 1 pending event.
    private val _events = MutableSharedFlow<UiEvent>(
        replay = 0,
        extraBufferCapacity = 1,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
    val events: SharedFlow<UiEvent> = _events

    fun onLikeClicked(postId: String) {
        viewModelScope.launch {
            repo.likePost(postId)
            // tryEmit: non-suspending. Returns false if buffer full.
            _events.tryEmit(UiEvent.ShowSnackbar("Liked!"))
            // emit: suspending — waits if buffer full
            // _events.emit(UiEvent.ShowSnackbar("Liked!"))
        }
    }

    fun onDeleteClicked(postId: String) {
        viewModelScope.launch {
            repo.deletePost(postId)
            _events.emit(UiEvent.NavigateBack)
        }
    }
}

// Collecting in Fragment
repeatOnLifecycle(Lifecycle.State.STARTED) {
    viewModel.events.collect { event ->
        when (event) {
            is UiEvent.ShowSnackbar  -> showSnackbar(event.message)
            is UiEvent.NavigateBack  -> findNavController().popBackStack()
            is UiEvent.ShowDialog    -> showDialog(event.config)
        }
    }
}

val locationUpdates: SharedFlow<Location> =
    locationProvider.updates()        // cold Flow from GPS hardware
        .shareIn(
            scope = viewModelScope,
            started = SharingStarted.WhileSubscribed(5000),
            replay = 1                  // late subscribers get last location
        )
// Now multiple collectors share ONE GPS subscription instead of
// each opening their own (expensive!) GPS connection.

// ✗ UNSAFE — keeps collecting in background
lifecycleScope.launch {
    viewModel.state.collect { render(it) }
}

// ✓ SAFE — pauses when STOPPED, resumes when STARTED
lifecycleScope.launch {
    repeatOnLifecycle(Lifecycle.State.STARTED) {
        // Collect multiple flows concurrently within the same lifecycle
        launch { viewModel.uiState.collect { render(it) } }
        launch { viewModel.events.collect { handleEvent(it) } }
    }
}

// ✓ COMPOSE — lifecycle-aware by default
val state by viewModel.uiState.collectAsStateWithLifecycle()
//                                ↑ stops collection when UI is not visible
//                                  USE THIS not .collectAsState()

class ArticleViewModel(
    private val repo: ArticleRepository,
    private val savedState: SavedStateHandle
) : ViewModel() {

    // State — use StateFlow, exposed read-only
    val articles: StateFlow<ArticleState> =
        savedState.getStateFlow("filter", Filter.All)
            .flatMapLatest { filter -> repo.getArticles(filter) }
            .map { ArticleState.Success(it) }
            .catch { emit(ArticleState.Error(it.message)) }
            .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), ArticleState.Loading)

    // One-shot events — use SharedFlow with replay=0
    private val _events = MutableSharedFlow<UiEvent>(extraBufferCapacity = 1)
    val events = _events.asSharedFlow()

    fun onArticleClicked(article: Article) {
        viewModelScope.launch {
            _events.emit(UiEvent.Navigate("/article/${article.id}"))
        }
    }

    fun onBookmarkClicked(article: Article) {
        viewModelScope.launch {
            repo.toggleBookmark(article.id)
            _events.tryEmit(UiEvent.ShowSnackbar("Bookmarked"))
        }
    }
}