Как загружать данные в Kotlin с корутинами (Первая часть)

suspend fun loadUserData(userId: String): User {
    val user = userApi.getUser(userId) // приостанавливается здесь
    val preferences = preferencesApi.getUserPrefs(userId) // и здесь
    return user.copy(preferences = preferences)
}

class HomeViewModel : ViewModel() {
    fun loadData() {
        viewModelScope.launch {
            try {
                val data = repository.fetchHomeData()
                _uiState.value = HomeUiState.Success(data)
            } catch (e: Exception) {
                _uiState.value = HomeUiState.Error(e.message)
            }
        }
    }
}

val deferred = async { loadUserProfile() }
val profile = deferred.await() // получаем результат

class DataRepository {
    private val repositoryScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
    
    fun loadMultipleDataSources() = repositoryScope.launch {
        val users = async { loadUsers() }
        val posts = async { loadPosts() }
        val comments = async { loadComments() }
        
        // Все три запроса выполняются параллельно
        val results = awaitAll(users, posts, comments)
    }
}

// Исключение поглощается
launch {
    throw RuntimeException("Boom!") // не упадёт
}
 
// Исключение всплывает
val result = async {
    throw RuntimeException("Boom!") // упадёт при await()
}
result.await() // здесь получим исключение

val handler = CoroutineExceptionHandler { _, exception ->
    println("Caught $exception")
}
 
val scope = CoroutineScope(Job() + handler)

val job = launch {
    try {
        repeat(1000) { i ->
            delay(100)
            println("Working $i")
        }
    } finally {
        println("Cleanup resources")
    }
}
 
delay(500)
job.cancel() // отменяем через полсекунды

suspend fun fetchUserProfile(userId: String): UserProfile {
    val basicInfo = userService.getBasicInfo(userId) // приостановка #1
    val avatar = imageService.loadAvatar(basicInfo.avatarUrl) // приостановка #2
    val settings = settingsService.getUserSettings(userId) // приостановка #3
    
    return UserProfile(basicInfo, avatar, settings)
}

fun regularFunction() {
    delay(1000) // ошибка компиляции!
}
 
suspend fun suspendFunction() {
    delay(1000) // всё хорошо
}

// НЕ suspend - быстрая операция в памяти
fun calculateSum(a: Int, b: Int): Int = a + b
 
// suspend - операция с базой данных
suspend fun saveUser(user: User): Long = userDao.insert(user)
 
// suspend - вызывает другие suspend-функции
suspend fun syncUserData(userId: String): SyncResult {
    val remoteUser = fetchRemoteUser(userId)
    val localId = saveUser(remoteUser)
    return SyncResult(localId, remoteUser.lastModified)
}

suspend fun fastOperation(): String {
    return "Instant result" // выполняется мгновенно
}

suspend fun <T> retry(
    times: Int,
    delay: Long = 1000,
    operation: suspend () -> T
): T {
    repeat(times - 1) {
        try {
            return operation()
        } catch (e: Exception) {
            delay(delay)
        }
    }
    return operation() // последняя попытка
}
 
// Использование
val result = retry(3, 2000) {
    apiService.getUserData(userId)
}

class UserRepository {
    suspend val currentUser: User
        get() = database.getCurrentUser()
}

inline suspend fun <T> T.also(crossinline block: suspend (T) -> Unit): T {
    block(this)
    return this
}
 
// Использование
val user = loadUser(id)
    .also { logUserAccess(it) }
    .also { updateLastSeen(it) }

// Было (с колбэками)
userService.getUser(userId) { user ->
    imageService.loadAvatar(user.avatarUrl) { avatar ->
        settingsService.getSettings(userId) { settings ->
            // код обработки вложен на три уровня
            val profile = UserProfile(user, avatar, settings)
            callback.onSuccess(profile)
        }
    }
}
 
// Стало (с suspend-функциями)
suspend fun loadUserProfile(userId: String): UserProfile {
    val user = userService.getUser(userId)
    val avatar = imageService.loadAvatar(user.avatarUrl)
    val settings = settingsService.getSettings(userId)
    return UserProfile(user, avatar, settings)
}

class DataProcessor {
    suspend fun processLargeDataset(data: List<String>): ProcessedData = 
        withContext(Dispatchers.Default) {
            // Тяжёлые вычисления на background потоке
            data.map { processItem(it) }
                .groupBy { it.category }
                .mapValues { calculateStats(it.value) }
        }
    
    suspend fun saveToDatabase(result: ProcessedData) = 
        withContext(Dispatchers.IO) {
            // Операции с базой данных
            database.insert(result)
        }
    
    suspend fun updateUI(result: ProcessedData) = 
        withContext(Dispatchers.Main) {
            // Обновление интерфейса
            viewState.value = ViewState.Success(result)
        }
}

suspend fun loadMultipleFiles(filePaths: List<String>): List<FileContent> =
    withContext(Dispatchers.IO) {
        filePaths.map { path ->
            async { loadFileContent(path) }
        }.awaitAll()
    }

class DatabaseManager {
    private val dbDispatcher = Executors.newSingleThreadExecutor().asCoroutineDispatcher()
    
    suspend fun executeTransaction(block: suspend () -> Unit) = 
        withContext(dbDispatcher) {
            database.beginTransaction()
            try {
                block()
                database.setTransactionSuccessful()
            } finally {
                database.endTransaction()
            }
        }
}

suspend fun logEvent(event: String) = withContext(Dispatchers.Unconfined) {
    logger.log(event) // быстрая операция
}

val customContext = SupervisorJob() + 
                   Dispatchers.IO + 
                   CoroutineName("DataSync") +
                   CoroutineExceptionHandler { _, exception ->
                       handleSyncError(exception)
                   }
 
CoroutineScope(customContext).launch {
    // корутина с настроенным контекстом
}

// Плохо - лишнее переключение
suspend fun loadUser(id: String): User = withContext(Dispatchers.IO) {
    val user = apiService.getUser(id) // уже suspend функция
    return@withContext user
}
 
// Хорошо - используем существующий контекст
suspend fun loadUser(id: String): User = apiService.getUser(id)

class NotificationManager {
    private val notificationChannel = Channel<Notification>(Channel.UNLIMITED)
    
    fun sendNotification(notification: Notification) {
        notificationChannel.trySend(notification)
    }
    
    suspend fun processNotifications() {
        for (notification in notificationChannel) {
            displayNotification(notification)
            delay(500) // пауза между уведомлениями
        }
    }
}

class DataStreamer {
    // Буферизованный канал для сглаживания пиков нагрузки
    private val dataChannel = Channel<DataChunk>(capacity = 100)
    
    suspend fun streamData() = coroutineScope {
        // Producer корутина
        launch {
            repeat(1000) { i ->
                val chunk = generateDataChunk(i)
                dataChannel.send(chunk)
            }
            dataChannel.close()
        }
        
        // Consumer корутина
        launch {
            dataChannel.consumeEach { chunk ->
                processChunk(chunk)
            }
        }
    }
}

class WorkDistributor {
    private val taskChannel = Channel<Task>()
    
    fun startWorkers(workerCount: Int) = coroutineScope {
        // Несколько worker корутин читают из одного канала
        repeat(workerCount) { workerId ->
            launch {
                for (task in taskChannel) {
                    println("Worker $workerId processing ${task.id}")
                    processTask(task)
                }
            }
        }
    }
    
    suspend fun submitTask(task: Task) {
        taskChannel.send(task)
    }
}

class LocationTracker {
    private val locationChannel = Channel<Location>(Channel.CONFLATED)
    
    fun updateLocation(location: Location) {
        locationChannel.trySend(location) // не блокируется
    }
    
    suspend fun observeLocation(): Flow<Location> = 
        locationChannel.receiveAsFlow()
}

class FileProcessor {
    suspend fun processFiles(filePaths: List<String>) = coroutineScope {
        val fileChannel = Channel<File>()
        
        launch {
            try {
                filePaths.forEach { path ->
                    fileChannel.send(File(path))
                }
            } finally {
                fileChannel.close() // важно закрыть канал
            }
        }
        
        launch {
            try {
                for (file in fileChannel) {
                    processFile(file)
                }
            } catch (e: ClosedReceiveChannelException) {
                println("Channel closed, finishing processing")
            }
        }
    }
}

class LogAggregator {
    private val logChannel = Channel<LogEntry>()
    
    // Fan-in: несколько источников логов
    fun collectLogs() = coroutineScope {
        launch { collectWebServerLogs() }
        launch { collectDatabaseLogs() }
        launch { collectApplicationLogs() }
        
        // Один потребитель обрабатывает все логи
        launch {
            for (logEntry in logChannel) {
                saveLogToFile(logEntry)
            }
        }
    }
    
    private suspend fun collectWebServerLogs() {
        webServer.logStream().collect { log ->
            logChannel.send(LogEntry.Web(log))
        }
    }
}

suspend fun robustChannelProcessing() = coroutineScope {
    val channel = Channel<String>()
    
    launch {
        try {
            repeat(10) { i ->
                if (i == 5) throw RuntimeException("Oops")
                channel.send("Message $i")
            }
        } catch (e: Exception) {
            channel.close(e) // закрываем с ошибкой
        }
    }
    
    launch {
        try {
            for (message in channel) {
                println(message)
            }
        } catch (e: ClosedReceiveChannelException) {
            println("Channel closed: ${e.cause}")
        }
    }
}

class DataSyncManager {
    private val syncScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
    
    fun startComplexSync() {
        val parentJob = syncScope.launch {
            println("Parent job started")
            
            val childJob1 = launch {
                delay(2000)
                println("Child 1 completed")
            }
            
            val childJob2 = launch {
                delay(3000) 
                println("Child 2 completed")
            }
            
            // Родитель ждет завершения всех детей
            childJob1.join()
            childJob2.join()
            println("Parent job completed")
        }
    }
}

val regularScope = CoroutineScope(Job())
 
regularScope.launch {
    launch { 
        delay(1000)
        throw RuntimeException("Child failed!")
    }
    
    launch {
        delay(2000) 
        println("This will never print") // отменится из-за исключения в соседней корутине
    }
}

val supervisorScope = CoroutineScope(SupervisorJob())
 
supervisorScope.launch {
    launch { 
        delay(1000)
        throw RuntimeException("Child failed!")
    }
    
    launch {
        delay(2000)
        println("This will print") // продолжит выполняться
    }
}

class LongRunningTask {
    suspend fun processLargeDataset(data: List<String>): List<ProcessedItem> {
        val results = mutableListOf<ProcessedItem>()
        
        for (item in data) {
            ensureActive() // проверяем, не отменена ли корутина
            
            val processed = heavyProcessing(item)
            results.add(processed)
            
            if (results.size % 100 == 0) {
                yield() // даем другим корутинам возможность выполниться
            }
        }
        
        return results
    }
}

val job = launch {
    try {
        longRunningOperation()
    } finally {
        if (!isActive) {
            println("Operation was cancelled, cleaning up...")
            cleanup()
        }
    }
}
 
// В другом месте
if (job.isActive) {
    job.cancel("User requested cancellation")
}

class NetworkRepository {
    private val repositoryJob = SupervisorJob()
    private val repositoryScope = CoroutineScope(repositoryJob + Dispatchers.IO)
    
    fun fetchData() = repositoryScope.launch {
        // операции с сетью
    }
    
    fun cleanup() {
        repositoryJob.cancelChildren() // отменяем все дочерние задачи
    }
}

suspend fun parallelDataProcessing(items: List<Item>) = coroutineScope {
    val chunks = items.chunked(100)
    
    chunks.map { chunk ->
        async { processChunk(chunk) }
    }.awaitAll().flatten()
}

val userSessionJob = SupervisorJob()
val networkConnectivityJob = SupervisorJob()
 
val dataFetchJob = CoroutineScope(userSessionJob + networkConnectivityJob).launch {
    // задача отменится при потере сессии ИЛИ сетевого соединения
}

class UserProfileManager {
    private val managerScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
    
    fun loadUserData(userId: String) {
        managerScope.launch { // родительская корутина
            val profile = async { userApi.getProfile(userId) } // дочерняя #1
            val friends = async { userApi.getFriends(userId) } // дочерняя #2  
            val posts = async { userApi.getPosts(userId) }     // дочерняя #3
            
            // Все три запроса выполняются параллельно
            val userData = UserData(
                profile = profile.await(),
                friends = friends.await(), 
                posts = posts.await()
            )
            
            updateUI(userData)
        }
    }
    
    fun cleanup() {
        managerScope.cancel() // отменяет ВСЕ активные корутины
    }
}

class HomeViewModel : ViewModel() {
    private val _homeState = MutableStateFlow<HomeState>(HomeState.Loading)
    val homeState = _homeState.asStateFlow()
    
    fun loadHomeData() {
        viewModelScope.launch {
            try {
                // Даже если пользователь быстро покинет экран,
                // эта корутина автоматически отменится
                val news = async { newsRepository.getLatestNews() }
                val weather = async { weatherRepository.getCurrentWeather() }
                val recommendations = async { recommendationRepository.getPersonalized() }
                
                _homeState.value = HomeState.Loaded(
                    news = news.await(),
                    weather = weather.await(), 
                    recommendations = recommendations.await()
                )
            } catch (e: CancellationException) {
                // Корутина была отменена - это нормально
                throw e
            } catch (e: Exception) {
                _homeState.value = HomeState.Error(e.message)
            }
        }
    }
}

suspend fun synchronizeUserData(userId: String): SyncResult = coroutineScope {
    val uploadJob = async { uploadPendingChanges(userId) }
    val downloadJob = async { downloadRemoteChanges(userId) }
    val cleanupJob = async { cleanupObsoleteData() }
    
    // Функция не завершится, пока все три операции не закончатся
    SyncResult(
        uploaded = uploadJob.await(),
        downloaded = downloadJob.await(),
        cleaned = cleanupJob.await()
    )
}

suspend fun downloadFile(url: String, destination: File) = coroutineScope {
    val connection = openConnection(url)
    
    try {
        val downloadJob = async {
            connection.inputStream.use { input ->
                destination.outputStream().use { output ->
                    input.copyTo(output)
                }
            }
        }
        
        downloadJob.await()
    } finally {
        connection.disconnect() // выполнится даже при отмене
    }
}

interface ArticleRepository {
    suspend fun getArticles(): List<Article>
    suspend fun getArticle(id: String): Article
    fun observeArticles(): Flow<List<Article>>
}

sealed class Result<out T> {
    data class Success<T>(val data: T) : Result<T>()
    data class Error(val exception: Exception) : Result<Nothing>()
    object Loading : Result<Nothing>()
}
 
suspend fun <T> safeApiCall(apiCall: suspend () -> T): Result<T> {
    return try {
        Result.Success(apiCall())
    } catch (e: Exception) {
        Result.Error(e)
    }
}

suspend fun loadUserDashboard(userId: String): DashboardData = coroutineScope {
    val profile = async { userService.getProfile(userId) }
    val notifications = async { notificationService.getUnread(userId) }
    val activities = async { activityService.getRecent(userId) }
    
    DashboardData(
        user = profile.await(),
        unreadCount = notifications.await().size,
        recentActivities = activities.await().take(5)
    )
}

interface UserRepository {
    suspend fun getUser(id: String): User
    suspend fun updateUser(user: User): User
    suspend fun deleteUser(id: String): Boolean
    fun observeUser(id: String): Flow<User>
}
 
class UserRepositoryImpl(
    private val userApi: UserApi,
    private val userDao: UserDao,
    private val cacheManager: CacheManager
) : UserRepository {
    
    override suspend fun getUser(id: String): User {
        return try {
            // Сначала пробуем кэш
            cacheManager.getUser(id) ?: run {
                // Затем API
                val user = userApi.getUser(id)
                cacheManager.saveUser(user)
                userDao.insertUser(user)
                user
            }
        } catch (networkError: NetworkException) {
            // Fallback на локальную базу
            userDao.getUser(id) ?: throw UserNotFoundException(id)
        }
    }
}

class ArticleRepositoryImpl : ArticleRepository {
    private val localArticles = MutableSharedFlow<List<Article>>()
    
    override fun observeArticles(): Flow<List<Article>> = flow {
        // Сначала отдаём кэшированные данные
        val cached = articleDao.getAllArticles()
        emit(cached)
        
        // Затем обновляем с сервера
        try {
            val fresh = articleApi.getArticles()
            articleDao.insertAll(fresh)
            emit(fresh)
        } catch (e: Exception) {
            // Если сервер недоступен, продолжаем с кэшированными данными
        }
    }.distinctUntilChanged()
    
    override suspend fun refreshArticles() {
        val fresh = articleApi.getArticles()
        articleDao.insertAll(fresh)
        localArticles.emit(articleDao.getAllArticles())
    }
}

class OrderRepository(
    private val orderApi: OrderApi,
    private val paymentApi: PaymentApi,
    private val inventoryApi: InventoryApi
) {
    
    suspend fun placeOrder(order: Order): OrderResult = coroutineScope {
        val inventoryCheck = async { inventoryApi.checkAvailability(order.items) }
        val paymentAuth = async { paymentApi.authorizePayment(order.payment) }
        
        val availabilityResult = inventoryCheck.await()
        val paymentResult = paymentAuth.await()
        
        if (availabilityResult.isSuccess && paymentResult.isSuccess) {
            val finalOrder = orderApi.createOrder(order)
            inventoryApi.reserveItems(order.items)
            OrderResult.Success(finalOrder)
        } else {
            OrderResult.Failed("Inventory or payment failed")
        }
    }
}

class WeatherRepository {
    private var cachedWeather: Weather? = null
    private var cacheTimestamp: Long = 0
    private val cacheTimeout = TimeUnit.MINUTES.toMillis(10)
    
    override suspend fun getCurrentWeather(): Weather {
        val now = System.currentTimeMillis()
        
        return if (cachedWeather != null && (now - cacheTimestamp) < cacheTimeout) {
            cachedWeather!!
        } else {
            val fresh = weatherApi.getCurrentWeather()
            cachedWeather = fresh
            cacheTimestamp = now
            fresh
        }
    }
}

class DataService {
    suspend fun loadCriticalData(): CriticalData {
        return try {
            val primaryData = primaryApi.getData()
            val secondaryData = secondaryApi.getData()
            CriticalData(primaryData, secondaryData)
        } catch (e: NetworkException) {
            // Специфичная обработка сетевых ошибок
            val fallbackData = localCache.getCachedData()
            if (fallbackData != null) {
                CriticalData.fromCache(fallbackData)
            } else {
                throw ServiceUnavailableException("No data available", e)
            }
        } catch (e: CancellationException) {
            // ВАЖНО: CancellationException нужно пробрасывать дальше
            throw e
        }
    }
}

val parentScope = CoroutineScope(Job() + Dispatchers.IO)
 
parentScope.launch {
    val job1 = launch {
        delay(1000)
        throw RuntimeException("Job1 failed")
    }
    
    val job2 = launch {
        delay(2000)
        println("Job2 completed") // никогда не выполнится
    }
    
    // Обе корутины отменятся из-за исключения в job1
}

val supervisorScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
supervisorScope.launch {
    val job1 = launch {
        delay(1000)
        throw RuntimeException("Job1 failed")
    }
    
    val job2 = launch {
        delay(2000)
        println("Job2 completed") // выполнится успешно
    }
    
    // job2 продолжит работать несмотря на ошибку в job1
}

val exceptionHandler = CoroutineExceptionHandler { _, exception ->
    when (exception) {
        is NetworkException -> logNetworkError(exception)
        is DatabaseException -> reportDatabaseIssue(exception)
        else -> logUnknownError(exception)
    }
}
 
val scope = CoroutineScope(SupervisorJob() + exceptionHandler)
 
scope.launch {
    throw NetworkException("Connection failed") // будет обработано handler'ом
}

val deferred = async {
    throw RuntimeException("Async failed")
}
 
try {
    val result = deferred.await() // исключение всплывёт здесь
} catch (e: Exception) {
    handleError(e)
}

sealed class ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>()
    data class Error(val exception: Throwable) : ApiResult<Nothing>()
}
 
suspend fun <T> safeApiCall(call: suspend () -> T): ApiResult<T> {
    return try {
        ApiResult.Success(call())
    } catch (e: CancellationException) {
        throw e // пробрасываем CancellationException
    } catch (e: Exception) {
        ApiResult.Error(e)
    }
}
 
// Использование
suspend fun loadUserProfile(id: String): ApiResult<UserProfile> {
    return safeApiCall { userApi.getProfile(id) }
}

suspend fun loadDashboardData(): DashboardResult = coroutineScope {
    val newsDeferred = async { safeApiCall { newsApi.getLatestNews() } }
    val weatherDeferred = async { safeApiCall { weatherApi.getCurrentWeather() } }
    val stocksDeferred = async { safeApiCall { stocksApi.getPortfolio() } }
    
    val newsResult = newsDeferred.await()
    val weatherResult = weatherDeferred.await() 
    val stocksResult = stocksDeferred.await()
    
    DashboardResult(
        news = if (newsResult is ApiResult.Success) newsResult.data else emptyList(),
        weather = if (weatherResult is ApiResult.Success) weatherResult.data else null,
        stocks = if (stocksResult is ApiResult.Success) stocksResult.data else emptyList(),
        hasErrors = listOf(newsResult, weatherResult, stocksResult).any { it is ApiResult.Error }
    )
}

class LocationService {
    fun observeLocation(): Flow<Location> = flow {
        while (true) {
            val currentLocation = getCurrentGpsLocation()
            emit(currentLocation)
            delay(5000) // обновляем каждые 5 секунд
        }
    }
    
    suspend fun startLocationTracking() {
        observeLocation().collect { location ->
            updateUI(location)
            saveLocationToDatabase(location)
        }
    }
}

class NewsRepository {
    fun getBreakingNews(): Flow<List<NewsArticle>> = flow {
        while (true) {
            val allNews = newsApi.getLatestNews()
            emit(allNews)
            delay(TimeUnit.MINUTES.toMillis(1))
        }
    }
    .map { articles -> articles.filter { it.isBreaking } }
    .filter { breakingNews -> breakingNews.isNotEmpty() }
    .distinctUntilChanged()
}

fun observeWeatherData(): Flow<WeatherData> = flow {
    while (true) {
        val weather = weatherApi.getCurrentWeather()
        emit(weather)
        delay(TimeUnit.MINUTES.toMillis(10))
    }
}
.catch { exception ->
    when (exception) {
        is NetworkException -> emit(getCachedWeather())
        else -> emit(WeatherData.unavailable())
    }
}

class ImageProcessor {
    fun processImages(imageUrls: Flow<String>): Flow<ProcessedImage> = 
        imageUrls.flatMapMerge(concurrency = 3) { url ->
            flow {
                val downloaded = downloadImage(url)
                val processed = applyFilters(downloaded)
                emit(processed)
            }
        }
}

class DashboardViewModel {
    private val userProfile = userRepository.observeCurrentUser()
    private val unreadMessages = messageRepository.observeUnreadCount() 
    private val notifications = notificationRepository.observeNotifications()
    
    val dashboardState = combine(userProfile, unreadMessages, notifications) { user, messages, notifs ->
        DashboardState(
            user = user,
            unreadCount = messages,
            hasNotifications = notifs.isNotEmpty()
        )
    }
}

class UserSessionManager {
    private val _sessionState = MutableStateFlow<SessionState>(SessionState.LoggedOut)
    val sessionState: StateFlow<SessionState> = _sessionState.asStateFlow()
    
    fun login(credentials: Credentials) {
        viewModelScope.launch {
            _sessionState.value = SessionState.LoggingIn
            try {
                val session = authService.login(credentials)
                _sessionState.value = SessionState.LoggedIn(session)
            } catch (e: Exception) {
                _sessionState.value = SessionState.LoginFailed(e.message)
            }
        }
    }
}

class CartManager {
    private val _cartItems = MutableStateFlow<List<CartItem>>(emptyList())
    val cartItems: StateFlow<List<CartItem>> = _cartItems.asStateFlow()
    
    private val _totalPrice = MutableStateFlow(0.0)
    val totalPrice: StateFlow<Double> = _totalPrice.asStateFlow()
    
    fun addItem(item: CartItem) {
        val currentItems = _cartItems.value.toMutableList()
        currentItems.add(item)
        _cartItems.value = currentItems
        updateTotalPrice()
    }
    
    private fun updateTotalPrice() {
        val total = _cartItems.value.sumOf { it.price * it.quantity }
        _totalPrice.value = total
    }
}

class NotificationManager {
    private val _notifications = MutableSharedFlow<Notification>()
    val notifications: SharedFlow<Notification> = _notifications.asSharedFlow()
    
    private val _toastMessages = MutableSharedFlow<String>(
        replay = 1, // последнее сообщение доступно новым подписчикам
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
    val toastMessages: SharedFlow<String> = _toastMessages.asSharedFlow()
    
    fun showNotification(notification: Notification) {
        _notifications.tryEmit(notification)
    }
    
    fun showToast(message: String) {
        _toastMessages.tryEmit(message)
    }
}

class UserDashboardViewModel {
    private val userProfile = userRepository.observeCurrentUser().stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        initialValue = null
    )
    
    private val notifications = notificationRepository.observeNotifications().stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000), 
        initialValue = emptyList()
    )
    
    val dashboardUiState = combine(userProfile, notifications) { user, notifs ->
        when {
            user == null -> DashboardUiState.Loading
            user.isActive -> DashboardUiState.Active(
                user = user,
                notificationCount = notifs.size,
                hasUrgentNotifications = notifs.any { it.isUrgent }
            )
            else -> DashboardUiState.Suspended(user)
        }
    }.stateIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        initialValue = DashboardUiState.Loading
    )
}

class GameStateManager {
    private val _gameState = MutableStateFlow<GameState>(GameState.Menu)
    val gameState: StateFlow<GameState> = _gameState.asStateFlow()
    
    private val _gameEvents = MutableSharedFlow<GameEvent>()
    val gameEvents: SharedFlow<GameEvent> = _gameEvents.asSharedFlow()
    
    fun startGame() {
        _gameState.value = GameState.Playing(level = 1, score = 0)
        _gameEvents.tryEmit(GameEvent.GameStarted)
    }
    
    fun updateScore(newScore: Int) {
        val currentState = _gameState.value
        if (currentState is GameState.Playing) {
            _gameState.value = currentState.copy(score = newScore)
            if (newScore > currentState.score + 100) {
                _gameEvents.tryEmit(GameEvent.ScoreBonus(newScore - currentState.score))
            }
        }
    }
}