refactor: simplify app bootstrap and root errors

Remove duplicate auth ValidationType and use the shared network model instead.
Add support for both "sms" and "2fa_sms" SMS validation values.

.github/workflows/build.yml

@@ -40,7 +40,7 @@ jobs:
           echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
 
       - name: Upload APK with original name
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ env.APK_NAME }}
           path: ${{ env.APK_PATH }}
@@ -56,7 +56,7 @@ jobs:
             echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
 
       - name: Upload APK with original name
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: ${{ env.APK_NAME }}
           path: ${{ env.APK_PATH }}

.github/workflows/create_release.yml

@@ -34,7 +34,7 @@ jobs:
         run: ./gradlew assembleRelease
 
       - name: Upload release APK
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.apk
           path: app/build/outputs/apk/release/app-release.apk
@@ -43,7 +43,7 @@ jobs:
         run: ./gradlew bundleRelease
 
       - name: Upload release Bundle
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.aab
           path: app/build/outputs/bundle/release/app-release.aab

TECH_DEBT_AUDIT.md

@@ -0,0 +1,131 @@
+# Fast Messenger Tech Debt Audit
+
+## Critical
+
+### `core/network/src/main/kotlin/dev/meloda/fast/network/interceptor/Error14HandlingInterceptor.kt`
+- captcha flow is built around `wait/notify`, a raw executor, and shared mutable state.
+- risk: deadlocks, leaked jobs, hard-to-reproduce auth hangs.
+- fix: rewrite as suspend-based flow with timeout and explicit cancellation.
+
+### `core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollEventParser.kt`
+- file mixes parsing, dispatching, IO loading, and concurrency orchestration.
+- risk: regressions when VK event format changes.
+- fix: split by event family and add parser tests.
+
+### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/MessagesHistoryViewModelImpl.kt`
+- view model is doing too much: loaders, navigation, selection, long poll hooks, read peers, dialog flow.
+- risk: brittle state transitions and untestable branching.
+- fix: extract coordinators/handlers per concern.
+
+### `app/src/main/kotlin/dev/meloda/fast/MainViewModel.kt`
+- root bootstrap handles auth, locale, long poll, permissions, profile, and start destination in one class.
+- risk: startup bugs and hidden coupling between flows.
+- fix: move startup/permission orchestration into dedicated controllers.
+
+### `app/src/main/kotlin/dev/meloda/fast/presentation/RootScreen.kt`
+- root composable owns too many top-level flows and dialogs.
+- risk: UI orchestration drift and hard-to-read navigation logic.
+- fix: split dialogs, bootstrap, and navigation concern into smaller composables.
+
+## High
+
+### `core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollEventParser.kt`
+- uses many `Log.d` calls and large `when` branches.
+- fix: reduce logging noise and add structured tracing only where needed.
+
+### `core/network/src/main/kotlin/dev/meloda/fast/network/ResponseConverterFactory.kt`
+- double-parsing response bodies and only logging malformed payloads.
+- risk: opaque failures and harder debugging.
+- fix: normalize error conversion and surface typed failures.
+
+### `feature/profile/src/main/kotlin/dev/meloda/fast/profile/ProfileViewModel.kt`
+- `loadAccountInfo()` has an empty error branch.
+- risk: profile can fail silently.
+- fix: set `baseError` and show fallback UI.
+
+### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/attachments/Attachments.kt`
+- attachment preview logic still sits in UI layer and mixes fallback behavior.
+- risk: silent drops of unsupported attachments.
+- fix: move preview mapping to domain/ui-model layer.
+
+### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/Link.kt`
+- title handling is nullable and duplicated with preview logic.
+- fix: create a small UI model for link rendering.
+
+### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/File.kt`
+- preview extraction is inline and branches on raw model internals.
+- fix: extract to mapper/UI model.
+
+### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/presentation/MessagesList.kt`
+- message-item interaction is dense and repeated.
+- fix: normalize scroll/reply handlers and reduce nested callbacks.
+
+## Medium
+
+### `core/data/src/main/kotlin/dev/meloda/fast/data/VkUsersMap.kt`
+- lookup helpers were using unsafe assumptions on external data.
+- status: already improved, but should stay covered by tests.
+
+### `core/data/src/main/kotlin/dev/meloda/fast/data/VkGroupsMap.kt`
+- same risk profile as users map.
+- status: already improved, still needs tests.
+
+### `core/domain/src/main/kotlin/dev/meloda/fast/domain/OAuthUseCaseImpl.kt`
+- auth success mapping used forced unwraps on server data.
+- status: already improved, but auth contract should be validated.
+
+### `app/src/main/kotlin/dev/meloda/fast/presentation/MainActivity.kt`
+- service lifecycle now respects config changes, but app exit semantics should be documented.
+- fix: keep explicit separation of app-close vs config-change behavior.
+
+### `build-logic/convention/src/main/kotlin/dev/meloda/fast/KotlinAndroid.kt`
+- build-tools are pinned to the local environment.
+- risk: portable builds may drift between machines.
+- fix: prefer SDK-managed consistency or document required SDK version.
+
+### `app/src/main/kotlin/dev/meloda/fast/presentation/RootErrorDialog.kt`
+- currently hardcodes English strings for some errors.
+- fix: localize all texts through resources.
+
+### `app/src/main/kotlin/dev/meloda/fast/presentation/RootScreen.kt`
+- root-level error dialog is better, but some orchestration still remains in the root composable.
+- fix: split into smaller root flows over time.
+
+## Low
+
+### `core/ui/src/main/kotlin/dev/meloda/fast/ui/components/AnimatedDots.kt`
+- marked TODO rewrite.
+- fix when touching related loading UI.
+
+### `core/ui/src/main/kotlin/dev/meloda/fast/ui/theme/AppTheme.kt`
+- color picker TODO suggests unfinished theme customization.
+
+### `core/model/src/main/kotlin/dev/meloda/fast/model/api/data/LongPollUpdates.kt`
+- `List<List<Any>>` is a weakly typed API boundary.
+- fix: introduce explicit event DTOs.
+
+### `core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkMessage.kt`
+- attachment persistence is still a TODO area.
+
+### `core/model/src/main/kotlin/dev/meloda/fast/model/database/VkMessageEntity.kt`
+- attachment storage/restoration is unresolved.
+
+### `core/common/src/main/kotlin/dev/meloda/fast/common/model/LongPollState.kt`
+- Android 15 support TODO.
+
+### `feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/MessagesHistoryViewModelImpl.kt`
+- large commented-out legacy block should be removed once upload flow is reimplemented.
+
+### `feature/auth/src/main/kotlin/dev/meloda/fast/auth/login/LoginViewModel.kt`
+- debug/auth token acquisition TODO indicates unfinished auth path.
+
+## What To Do First
+1. Rewrite captcha interceptor.
+2. Split `LongPollEventParser`.
+3. Extract `MessagesHistoryViewModelImpl` orchestration.
+4. Localize `RootErrorDialog` strings.
+5. Add tests for auth, long poll parsing, and attachment mapping.
+
+## Note
+- Current code is already better on crash-prone nullable handling and service lifecycle.
+- Remaining work is mostly structural and testability-focused.

app/build.gradle.kts

@@ -13,8 +13,8 @@ android {
     defaultConfig {
         applicationId = "dev.meloda.fastvk"
 
-        versionCode = 10
-        versionName = "0.2.2"
+        versionCode = 11
+        versionName = "0.2.3"
     }
 
     signingConfigs {
@@ -79,6 +79,9 @@ android {
 }
 
 dependencies {
+    implementation(libs.acra.email)
+    implementation(libs.acra.dialog)
+
     implementation(projects.feature.auth)
 
     implementation(projects.feature.chatmaterials)

app/src/main/kotlin/dev/meloda/fast/MainViewModel.kt

@@ -2,7 +2,6 @@ package dev.meloda.fast
 
 import android.content.Intent
 import android.os.Build
-import android.util.Log
 import androidx.appcompat.app.AppCompatDelegate
 import androidx.core.app.NotificationCompat
 import androidx.core.os.LocaleListCompat
@@ -38,6 +37,7 @@ interface MainViewModel {
     val startDestination: StateFlow<Any?>
     val isNeedToReplaceWithAuth: StateFlow<Boolean>
     val currentUser: StateFlow<VkUser?>
+    val baseError: StateFlow<BaseError?>
 
     val isNeedToShowNotificationsDeniedDialog: StateFlow<Boolean>
     val isNeedToShowNotificationsRationaleDialog: StateFlow<Boolean>
@@ -45,6 +45,7 @@ interface MainViewModel {
     val isNeedToRequestNotifications: StateFlow<Boolean>
 
     fun onError(error: BaseError)
+    fun onErrorConsumed()
 
     fun onNavigatedToAuth()
 
@@ -73,6 +74,7 @@ class MainViewModelImpl(
     override val startDestination = MutableStateFlow<Any?>(null)
     override val isNeedToReplaceWithAuth = MutableStateFlow(false)
     override val currentUser = MutableStateFlow<VkUser?>(null)
+    override val baseError = MutableStateFlow<BaseError?>(null)
 
     override val isNeedToShowNotificationsDeniedDialog = MutableStateFlow(false)
     override val isNeedToShowNotificationsRationaleDialog = MutableStateFlow(false)
@@ -82,6 +84,10 @@ class MainViewModelImpl(
     private var openNotificationsSettings = false
     private var openAppSettings = false
 
+    init {
+        listenLongPollState()
+    }
+
     override fun onError(error: BaseError) {
         when (error) {
             BaseError.SessionExpired,
@@ -89,9 +95,15 @@ class MainViewModelImpl(
                 isNeedToReplaceWithAuth.update { true }
             }
 
-            else -> Unit // TODO: 21-Mar-25, Danil Nikolaev: show error in ui
+            else -> {
+                baseError.update { error }
             }
         }
+    }
+
+    override fun onErrorConsumed() {
+        baseError.update { null }
+    }
 
     override fun onNavigatedToAuth() {
         isNeedToReplaceWithAuth.update { false }
@@ -203,10 +215,6 @@ class MainViewModelImpl(
         viewModelScope.launch(Dispatchers.IO) {
             val currentAccount = getCurrentAccountUseCase()
 
-            Log.d("MainViewModel", "currentAccount: $currentAccount")
-
-            listenLongPollState()
-
             if (currentAccount != null) {
                 UserConfig.apply {
                     this.userId = currentAccount.userId

app/src/main/kotlin/dev/meloda/fast/common/AppGlobal.kt

@@ -4,8 +4,14 @@ import android.app.Application
 import androidx.preference.PreferenceManager
 import coil.ImageLoader
 import coil.ImageLoaderFactory
+import com.skydoves.compose.stability.runtime.ComposeStabilityAnalyzer
+import dev.meloda.fast.auth.BuildConfig
 import dev.meloda.fast.common.di.applicationModule
 import dev.meloda.fast.datastore.AppSettings
+import org.acra.config.dialog
+import org.acra.config.mailSender
+import org.acra.data.StringFormat
+import org.acra.ktx.initAcra
 import org.koin.android.ext.android.get
 import org.koin.android.ext.koin.androidContext
 import org.koin.android.ext.koin.androidLogger
@@ -18,10 +24,14 @@ class AppGlobal : Application(), ImageLoaderFactory {
 
         val preferences = PreferenceManager.getDefaultSharedPreferences(this)
         AppSettings.init(preferences)
+        ComposeStabilityAnalyzer.setEnabled(BuildConfig.DEBUG)
 
         initKoin()
+        initAcra()
     }
 
+    override fun newImageLoader(): ImageLoader = get()
+
     private fun initKoin() {
         startKoin {
             androidLogger()
@@ -30,5 +40,21 @@ class AppGlobal : Application(), ImageLoaderFactory {
         }
     }
 
-    override fun newImageLoader(): ImageLoader = get()
+    private fun initAcra() {
+        initAcra {
+            buildConfigClass = BuildConfig::class.java
+            reportFormat = StringFormat.JSON
+
+            mailSender {
+                mailTo = "lischenkodev@gmail.com"
+                reportAsFile = true
+                reportFileName = "Crash.txt"
+            }
+
+            dialog {
+                text = "App crashed"
+                enabled = true
+            }
+        }
+    }
 }

app/src/main/kotlin/dev/meloda/fast/common/di/ApplicationModule.kt

@@ -7,9 +7,7 @@ import androidx.preference.PreferenceManager
 import coil.ImageLoader
 import coil.annotation.ExperimentalCoilApi
 import dev.meloda.fast.MainViewModelImpl
-import dev.meloda.fast.auth.captcha.di.captchaModule
-import dev.meloda.fast.auth.login.di.loginModule
-import dev.meloda.fast.auth.validation.di.validationModule
+import dev.meloda.fast.auth.authModule
 import dev.meloda.fast.chatmaterials.di.chatMaterialsModule
 import dev.meloda.fast.common.LongPollController
 import dev.meloda.fast.common.LongPollControllerImpl
@@ -38,9 +36,7 @@ import org.koin.dsl.module
 val applicationModule = module {
     includes(domainModule)
     includes(
-        loginModule,
-        validationModule,
-        captchaModule,
+        authModule,
         convosModule,
         settingsModule,
         messagesHistoryModule,

app/src/main/kotlin/dev/meloda/fast/navigation/MainGraph.kt

@@ -8,9 +8,9 @@ import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.BottomNavigationItem
 import dev.meloda.fast.presentation.MainScreen
 import dev.meloda.fast.profile.navigation.Profile
+import dev.meloda.fast.ui.R
 import dev.meloda.fast.ui.util.ImmutableList
 import kotlinx.serialization.Serializable
-import dev.meloda.fast.ui.R
 
 @Serializable
 object MainGraph

app/src/main/kotlin/dev/meloda/fast/presentation/MainActivity.kt

@@ -9,7 +9,6 @@ import android.content.res.Configuration
 import android.os.Build
 import android.os.Bundle
 import android.provider.Settings
-import android.util.Log
 import androidx.activity.SystemBarStyle
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
@@ -65,9 +64,6 @@ class MainActivity : AppCompatActivity() {
 
         setContent {
             val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
-            LaunchedEffect(viewModel) {
-                Log.d("VM_CREATE", "onCreate: viewModel: $viewModel")
-            }
 
             LifecycleResumeEffect(true) {
                 viewModel.onAppResumed(intent)

app/src/main/kotlin/dev/meloda/fast/presentation/MainScreen.kt

@@ -45,6 +45,7 @@ import dev.meloda.fast.friends.navigation.friendsScreen
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.BottomNavigationItem
 import dev.meloda.fast.navigation.MainGraph
+import dev.meloda.fast.profile.navigation.Profile
 import dev.meloda.fast.profile.navigation.profileScreen
 import dev.meloda.fast.ui.theme.LocalBottomPadding
 import dev.meloda.fast.ui.theme.LocalHazeState
@@ -69,15 +70,18 @@ fun MainScreen(
     val theme = LocalThemeConfig.current
     val hazeState = remember { HazeState(true) }
     val navController = rememberNavController()
-
-    var selectedItemIndex by rememberSaveable {
-        mutableIntStateOf(1)
+    val defaultTabIndex = remember(navigationItems) {
+        navigationItems.indexOfFirst { it.route == ConvoGraph }.takeIf { it >= 0 } ?: 0
     }
 
-    BackHandler(enabled = selectedItemIndex != 1) {
+    var selectedItemIndex by rememberSaveable {
+        mutableIntStateOf(defaultTabIndex)
+    }
+
+    BackHandler(enabled = selectedItemIndex != defaultTabIndex) {
         val currentRoute = navigationItems[selectedItemIndex].route
 
-        selectedItemIndex = 1
+        selectedItemIndex = defaultTabIndex
         navController.navigate(navigationItems[selectedItemIndex].route) {
             popUpTo(route = currentRoute) {
                 inclusive = true
@@ -127,7 +131,7 @@ fun MainScreen(
                             }
                         },
                         icon = {
-                            if (index == navigationItems.size - 1) {
+                            if (item.route == Profile) {
                                 var isLoading by remember {
                                     mutableStateOf(true)
                                 }

app/src/main/kotlin/dev/meloda/fast/presentation/RootErrorDialog.kt

@@ -0,0 +1,38 @@
+package dev.meloda.fast.presentation
+
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.res.stringResource
+import dev.meloda.fast.model.BaseError
+import dev.meloda.fast.ui.R
+
+@Composable
+fun RootErrorDialog(
+    baseError: BaseError?,
+    onDismiss: () -> Unit,
+    onConfirm: () -> Unit,
+) {
+    if (baseError == null) return
+
+    val errorText = when (baseError) {
+        BaseError.ConnectionError -> "Connection error"
+        BaseError.InternalError -> "Internal error"
+        BaseError.UnknownError -> "Unknown error"
+        is BaseError.SimpleError -> baseError.message
+        BaseError.SessionExpired -> "Session expired"
+        BaseError.AccountBlocked -> "Account blocked"
+    }
+
+    AlertDialog(
+        onDismissRequest = onDismiss,
+        title = { Text(text = stringResource(id = R.string.warning)) },
+        text = { Text(text = errorText) },
+        confirmButton = {
+            TextButton(onClick = onConfirm) {
+                Text(text = stringResource(id = R.string.try_again))
+            }
+        }
+    )
+}

app/src/main/kotlin/dev/meloda/fast/presentation/RootScreen.kt

@@ -4,16 +4,12 @@ import android.Manifest
 import android.content.Intent
 import android.net.Uri
 import android.provider.Settings
-import android.util.Log
 import androidx.activity.compose.LocalActivity
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
 import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
@@ -41,6 +37,7 @@ import com.google.accompanist.permissions.rememberPermissionState
 import dev.meloda.fast.MainViewModel
 import dev.meloda.fast.MainViewModelImpl
 import dev.meloda.fast.auth.authNavGraph
+import dev.meloda.fast.auth.captcha.presentation.CaptchaScreen
 import dev.meloda.fast.auth.navigateToAuth
 import dev.meloda.fast.chatmaterials.navigation.chatMaterialsScreen
 import dev.meloda.fast.chatmaterials.navigation.navigateToChatMaterials
@@ -48,6 +45,8 @@ import dev.meloda.fast.common.LongPollController
 import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.convos.navigation.createChatScreen
 import dev.meloda.fast.convos.navigation.navigateToCreateChat
+import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.datastore.CaptchaTokenResult
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.languagepicker.navigation.languagePickerScreen
 import dev.meloda.fast.languagepicker.navigation.navigateToLanguagePicker
@@ -69,9 +68,7 @@ import dev.meloda.fast.ui.theme.LocalNavController
 import dev.meloda.fast.ui.theme.LocalNavRootController
 import dev.meloda.fast.ui.theme.LocalThemeConfig
 import dev.meloda.fast.ui.theme.LocalUser
-import dev.meloda.fast.ui.util.ImmutableList
 import dev.meloda.fast.ui.util.ImmutableList.Companion.toImmutableList
-import dev.meloda.fast.ui.util.immutableListOf
 import dev.meloda.fast.ui.util.isNeedToEnableDarkMode
 import org.koin.androidx.compose.koinViewModel
 import org.koin.compose.koinInject
@@ -91,9 +88,6 @@ fun RootScreen(
     val longPollStateToApply by longPollController.stateToApply.collectAsStateWithLifecycle()
 
             val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
-    LaunchedEffect(viewModel) {
-        Log.d("VM_CREATE", "RootScreen(): viewModel: $viewModel")
-    }
 
     val currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
 
@@ -125,13 +119,11 @@ fun RootScreen(
     }
 
         LifecycleResumeEffect(longPollStateToApply) {
-        Log.d("LongPollMainActivity", "longPollStateToApply: $longPollStateToApply")
         if (longPollStateToApply != LongPollState.Background) {
             if (longPollStateToApply.isLaunched() && longPollCurrentState.isLaunched()
                 && longPollCurrentState != longPollStateToApply
             ) {
                 toggleLongPollService(false, null)
-                Log.d("LongPoll", "recreate()")
             }
 
             toggleLongPollService(
@@ -240,6 +232,7 @@ fun RootScreen(
             val context = LocalContext.current
             val startDestination by viewModel.startDestination.collectAsStateWithLifecycle()
             val isNeedToOpenAuth by viewModel.isNeedToReplaceWithAuth.collectAsStateWithLifecycle()
+            val baseError by viewModel.baseError.collectAsStateWithLifecycle()
             val isNeedToShowDeniedDialog by viewModel.isNeedToShowNotificationsDeniedDialog.collectAsStateWithLifecycle()
             val isNeedToShowRationaleDialog by viewModel.isNeedToShowNotificationsRationaleDialog.collectAsStateWithLifecycle()
 
@@ -303,15 +296,24 @@ fun RootScreen(
                 )
             }
 
+            RootErrorDialog(
+                baseError = baseError,
+                onDismiss = viewModel::onErrorConsumed,
+                onConfirm = viewModel::onErrorConsumed
+            )
+
             if (startDestination != null) {
                 CompositionLocalProvider(
                     LocalNavRootController provides navController,
                     LocalNavController provides navController
                 ) {
                     var photoViewerInfo by rememberSaveable {
-                        mutableStateOf<Pair<ImmutableList<String>, Int?>?>(null)
+                        mutableStateOf<Pair<List<String>, Int?>?>(null)
                     }
 
+                    val captchaRedirectUri by AppSettings.getCaptchaRedirectUriFlow()
+                        .collectAsStateWithLifecycle()
+
                     Box(modifier = Modifier.fillMaxSize()) {
                         NavHost(
                             navController = navController,
@@ -333,10 +335,10 @@ fun RootScreen(
                                 onSettingsButtonClicked = navController::navigateToSettings,
                                 onNavigateToMessagesHistory = navController::navigateToMessagesHistory,
                                 onPhotoClicked = { url ->
-                                    photoViewerInfo = immutableListOf(url) to null
+                                    photoViewerInfo = listOf(url) to null
                                 },
                                 onMessageClicked = navController::navigateToMessagesHistory,
-                                onNavigateToCreateChat = navController::navigateToCreateChat
+                                onNavigateToCreateChat = navController::navigateToCreateChat,
                             )
 
                             messagesHistoryScreen(
@@ -344,13 +346,13 @@ fun RootScreen(
                                 onBack = navController::navigateUp,
                                 onNavigateToChatMaterials = navController::navigateToChatMaterials,
                                 onNavigateToPhotoViewer = { photos, index ->
-                                    photoViewerInfo = photos.toImmutableList() to index
+                                    photoViewerInfo = photos to index
                                 }
                             )
                             chatMaterialsScreen(
                                 onBack = navController::navigateUp,
                                 onPhotoClicked = { url ->
-                                    photoViewerInfo = immutableListOf(url) to null
+                                    photoViewerInfo = listOf(url) to null
                                 }
                             )
                             createChatScreen(
@@ -378,9 +380,23 @@ fun RootScreen(
                         }
 
                         PhotoViewDialog(
-                            photoViewerInfo = photoViewerInfo,
+                            photoViewerInfo = photoViewerInfo?.let { info ->
+                                info.first.toImmutableList() to info.second
+                            },
                             onDismiss = { photoViewerInfo = null }
                         )
+
+                        CaptchaScreen(
+                            captchaRedirectUri = captchaRedirectUri,
+                            onBack = {
+                                AppSettings.setCaptchaResult(CaptchaTokenResult.Cancelled)
+                            },
+                            onResult = { result ->
+                                AppSettings.setCaptchaResult(
+                                    CaptchaTokenResult.Success(result)
+                                )
+                            },
+                        )
                     }
                 }
             }

app/src/main/kotlin/dev/meloda/fast/service/longpolling/LongPollingService.kt

@@ -16,11 +16,17 @@ import dev.meloda.fast.common.LongPollController
 import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.model.LongPollState
+import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.AppSettings
 import dev.meloda.fast.domain.LongPollUpdatesParser
 import dev.meloda.fast.domain.LongPollUseCase
+import dev.meloda.fast.domain.MessagesUseCase
+import dev.meloda.fast.domain.StoreUsersUseCase
+import dev.meloda.fast.model.api.data.VkGroupData
+import dev.meloda.fast.model.api.data.VkUserData
+import dev.meloda.fast.model.api.data.asDomain
 import dev.meloda.fast.model.api.data.LongPollUpdates
 import dev.meloda.fast.model.api.data.VkLongPollData
 import dev.meloda.fast.ui.R
@@ -32,10 +38,11 @@ import kotlinx.coroutines.Job
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlinx.coroutines.flow.last
 import org.koin.android.ext.android.inject
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 import kotlin.time.Duration.Companion.seconds
 
 class LongPollingService : Service() {
@@ -55,6 +62,8 @@ class LongPollingService : Service() {
     private val coroutineScope = CoroutineScope(coroutineContext)
 
     private val longPollUseCase: LongPollUseCase by inject()
+    private val messagesUseCase: MessagesUseCase by inject()
+    private val storeUsersUseCase: StoreUsersUseCase by inject()
     private val updatesParser: LongPollUpdatesParser by inject()
 
     private var currentJob: Job? = null
@@ -150,6 +159,8 @@ class LongPollingService : Service() {
             var serverInfo = getServerInfo()
                 ?: throw LongPollException(message = "bad VK response (server info)")
 
+            syncLongPollHistory(serverInfo)
+
             var lastUpdatesResponse: LongPollUpdates? = getUpdatesResponse(serverInfo)
                 ?: throw LongPollException(message = "initiation error: bad VK response (last updates)")
 
@@ -160,6 +171,7 @@ class LongPollingService : Service() {
                     failCount++
                     serverInfo = getServerInfo()
                         ?: throw LongPollException(message = "failed retrieving server info after error: bad VK response (server info #2)")
+                    syncLongPollHistory(serverInfo)
                     lastUpdatesResponse = getUpdatesResponse(serverInfo)
                     continue
                 }
@@ -179,6 +191,7 @@ class LongPollingService : Service() {
                             ?: throw LongPollException(
                                 message = "failed retrieving server info after error: bad VK response (server info #3)"
                             )
+                        syncLongPollHistory(serverInfo)
                         lastUpdatesResponse = getUpdatesResponse(serverInfo)
                     }
 
@@ -196,6 +209,9 @@ class LongPollingService : Service() {
                                 updates.forEach(updatesParser::parseNextUpdate)
                             }
 
+                            AppSettings.LongPoll.ts = lastUpdatesResponse.ts ?: serverInfo.ts
+                            AppSettings.LongPoll.pts = lastUpdatesResponse.pts ?: AppSettings.LongPoll.pts
+
                             lastUpdatesResponse = getUpdatesResponse(serverInfo.copy(ts = newTs))
                         }
                     }
@@ -204,7 +220,7 @@ class LongPollingService : Service() {
         }
     }
 
-    private suspend fun getServerInfo(): VkLongPollData? = suspendCoroutine {
+    private suspend fun getServerInfo(): VkLongPollData? = suspendCancellableCoroutine {
         longPollUseCase.getLongPollServer(
             needPts = true,
             version = VkConstants.LP_VERSION
@@ -224,7 +240,7 @@ class LongPollingService : Service() {
 
     private suspend fun getUpdatesResponse(
         server: VkLongPollData
-    ): LongPollUpdates? = suspendCoroutine {
+    ): LongPollUpdates? = suspendCancellableCoroutine {
         longPollUseCase.getLongPollUpdates(
             serverUrl = "https://${server.server}",
             key = server.key,
@@ -246,6 +262,73 @@ class LongPollingService : Service() {
         }
     }
 
+    private suspend fun syncLongPollHistory(serverInfo: VkLongPollData) {
+        val cursorTs = AppSettings.LongPoll.ts ?: serverInfo.ts
+        val cursorPts = AppSettings.LongPoll.pts ?: serverInfo.pts
+        val maxMsgId = messagesUseCase.getLocalMaxMessageId()
+
+        var currentTs = cursorTs
+        var currentPts = cursorPts
+        var more: Int?
+
+        do {
+            val historyResponse = getLongPollHistory(
+                ts = currentTs,
+                pts = currentPts,
+                maxMsgId = maxMsgId
+            ) ?: return
+
+            historyResponse.history.orEmpty().forEach(updatesParser::parseNextUpdate)
+
+            historyResponse.messages?.items.orEmpty().takeIf { it.isNotEmpty() }?.let { rawMessages ->
+                val messages = rawMessages.map { it.asDomain() }
+                messagesUseCase.storeMessages(messages)
+            }
+
+            historyResponse.profiles.orEmpty().takeIf { it.isNotEmpty() }?.let { profiles ->
+                val users = profiles.map(VkUserData::mapToDomain)
+                VkMemoryCache.appendUsers(users)
+                storeUsersUseCase(users).last()
+            }
+
+            historyResponse.groups.orEmpty().takeIf { it.isNotEmpty() }?.let { groups ->
+                VkMemoryCache.appendGroups(groups.map(VkGroupData::mapToDomain))
+            }
+
+            currentTs = historyResponse.ts ?: historyResponse.fromPts ?: currentTs
+            currentPts = historyResponse.newPts ?: historyResponse.pts ?: currentPts
+            more = historyResponse.more
+
+            AppSettings.LongPoll.ts = currentTs
+            AppSettings.LongPoll.pts = currentPts
+        } while (more == 1)
+    }
+
+    private suspend fun getLongPollHistory(
+        ts: Int,
+        pts: Int,
+        maxMsgId: Long?
+    ): dev.meloda.fast.model.api.data.LongPollHistoryResponse? = suspendCancellableCoroutine {
+        longPollUseCase.getLongPollHistory(
+            ts = ts,
+            pts = pts,
+            lpVersion = VkConstants.LP_VERSION,
+            maxMsgId = maxMsgId,
+            eventsLimit = 1000,
+            msgsLimit = 200
+        ).listenValue(coroutineScope) { state ->
+            state.processState(
+                success = { response ->
+                    it.resume(response)
+                },
+                error = { error ->
+                    Log.e(TAG, "getLongPollHistory: error: $error")
+                    it.resume(null)
+                }
+            )
+        }
+    }
+
     private fun handleError(throwable: Throwable) {
         Log.e(TAG, "error: $throwable")
 

app/src/main/kotlin/dev/meloda/fast/service/longpolling/di/LongPollModule.kt

@@ -1,6 +1,7 @@
 package dev.meloda.fast.service.longpolling.di
 
 import dev.meloda.fast.domain.LongPollUpdatesParser
+import dev.meloda.fast.domain.LongPollUpdatesReducer
 import dev.meloda.fast.domain.LongPollUseCase
 import dev.meloda.fast.domain.LongPollUseCaseImpl
 import org.koin.core.module.dsl.singleOf
@@ -10,4 +11,5 @@ import org.koin.dsl.module
 val longPollModule = module {
     singleOf(::LongPollUseCaseImpl) bind LongPollUseCase::class
     singleOf(::LongPollUpdatesParser)
+    singleOf(::LongPollUpdatesReducer)
 }

build-logic/convention/src/main/kotlin/AndroidApplicationComposeConventionPlugin.kt

@@ -10,6 +10,7 @@ class AndroidApplicationComposeConventionPlugin : Plugin<Project> {
         with(target) {
             apply(plugin = "com.android.application")
             apply(plugin = "org.jetbrains.kotlin.plugin.compose")
+            apply(plugin = "com.github.skydoves.compose.stability.analyzer")
 
             val extension = extensions.getByType<ApplicationExtension>()
             configureAndroidCompose(extension)

build-logic/convention/src/main/kotlin/AndroidApplicationConventionPlugin.kt

@@ -1,5 +1,6 @@
 import com.android.build.api.dsl.ApplicationExtension
 import dev.meloda.fast.configureKotlinAndroid
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -14,9 +15,9 @@ class AndroidApplicationConventionPlugin : Plugin<Project> {
             extensions.configure<ApplicationExtension> {
                 configureKotlinAndroid(this)
                 defaultConfig {
-                    targetSdk = 36
-                    compileSdk = 36
-                    minSdk = 23
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
                 }
             }
         }

build-logic/convention/src/main/kotlin/AndroidLibraryComposeConventionPlugin.kt

@@ -1,19 +1,26 @@
 import com.android.build.api.dsl.LibraryExtension
 import dev.meloda.fast.configureAndroidCompose
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.apply
-import org.gradle.kotlin.dsl.getByType
+import org.gradle.kotlin.dsl.configure
 
 class AndroidLibraryComposeConventionPlugin : Plugin<Project> {
     override fun apply(target: Project) {
         with(target) {
             apply(plugin = "com.android.library")
             apply(plugin = "org.jetbrains.kotlin.plugin.compose")
+            apply(plugin = "com.github.skydoves.compose.stability.analyzer")
 
-            val extension = extensions.getByType<LibraryExtension>()
-            extension.androidResources.enable = false
-            configureAndroidCompose(extension)
+            extensions.configure<LibraryExtension> {
+                configureAndroidCompose(this)
+                androidResources.enable = false
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                }
+            }
         }
     }
 }

build-logic/convention/src/main/kotlin/AndroidTestConventionPlugin.kt

@@ -1,5 +1,6 @@
 import com.android.build.api.dsl.TestExtension
 import dev.meloda.fast.configureKotlinAndroid
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -13,7 +14,11 @@ class AndroidTestConventionPlugin : Plugin<Project> {
 
             extensions.configure<TestExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = 36
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
+                }
             }
         }
     }

build-logic/convention/src/main/kotlin/dev/meloda/fast/KotlinAndroid.kt

@@ -24,7 +24,8 @@ internal fun Project.configureKotlinAndroid(
     }
 
     commonExtension.apply {
-        compileSdk = 36
+        compileSdk = getVersionInt("compileSdk")
+        buildToolsVersion = "36.1.0"
     }
 
     configureKotlin<KotlinAndroidProjectExtension>()
@@ -61,6 +62,7 @@ private inline fun <reified T : KotlinBaseExtension> Project.configureKotlin() =
             "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
             "-opt-in=kotlinx.coroutines.FlowPreview",
             "-Xannotation-default-target=param-property",
+            "-Xcontext-parameters"
         )
     }
 }

build-logic/convention/src/main/kotlin/dev/meloda/fast/ProjectExtensions.kt

@@ -7,3 +7,8 @@ import org.gradle.kotlin.dsl.getByType
 
 val Project.libs
     get(): VersionCatalog = extensions.getByType<VersionCatalogsExtension>().named("libs")
+
+
+fun Project.getVersionInt(alias: String): Int {
+    return libs.findVersion(alias).get().requiredVersion.toInt()
+}

build.gradle.kts

@@ -9,4 +9,5 @@ plugins {
     alias(libs.plugins.ksp) apply false
     alias(libs.plugins.module.graph) apply true
     alias(libs.plugins.versions) apply true
+    alias(libs.plugins.stability.analyzer) apply false
 }

core/common/src/main/kotlin/dev/meloda/fast/common/extensions/Extensions.kt

@@ -13,6 +13,7 @@ import kotlinx.coroutines.flow.launchIn
 import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.onStart
 import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 import kotlin.reflect.KClass
 import kotlin.time.Duration
 import kotlin.time.Duration.Companion.seconds
@@ -45,6 +46,14 @@ fun <T> Flow<T>.listenValue(
     action: suspend (T) -> Unit
 ): Job = onEach(action::invoke).launchIn(coroutineScope)
 
+fun CoroutineScope.launchDbRefresh(
+    load: suspend () -> Unit,
+    after: suspend () -> Unit
+): Job = launch {
+    load()
+    after()
+}
+
 fun createTimerFlow(
     time: Int,
     onStartAction: (suspend () -> Unit)? = null,

core/common/src/main/kotlin/dev/meloda/fast/common/paging/Paging.kt

@@ -0,0 +1,25 @@
+package dev.meloda.fast.common.paging
+
+fun canPaginate(pageSize: Int, loadedCount: Int): Boolean = loadedCount == pageSize
+
+fun isPaginationExhausted(
+    pageSize: Int,
+    loadedCount: Int,
+    hasExistingItems: Boolean
+): Boolean = loadedCount != pageSize && hasExistingItems
+
+fun <T> mergePage(
+    existing: List<T>,
+    page: List<T>,
+    offset: Int
+): List<T> = if (offset == 0) page else existing + page
+
+data class LoadingFlags(
+    val isLoading: Boolean,
+    val isPaginating: Boolean
+)
+
+fun loadingFlags(offset: Int, isLoading: Boolean): LoadingFlags = LoadingFlags(
+    isLoading = offset == 0 && isLoading,
+    isPaginating = offset > 0 && isLoading
+)

core/common/src/main/kotlin/dev/meloda/fast/common/util/TimeUtils.kt

@@ -1,7 +1,6 @@
 package dev.meloda.fast.common.util
 
 import com.conena.nanokt.jvm.util.dayOfMonth
-import com.conena.nanokt.jvm.util.hour
 import com.conena.nanokt.jvm.util.hourOfDay
 import com.conena.nanokt.jvm.util.millisecond
 import com.conena.nanokt.jvm.util.minute
@@ -12,6 +11,12 @@ import java.text.SimpleDateFormat
 import java.util.Calendar
 import java.util.Date
 import java.util.Locale
+import kotlin.time.Clock
+import kotlin.time.Duration.Companion.days
+import kotlin.time.Duration.Companion.hours
+import kotlin.time.Duration.Companion.minutes
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.Instant
 
 object TimeUtils {
 
@@ -56,37 +61,23 @@ object TimeUtils {
         monthShort: () -> String,
         weekShort: () -> String,
         dayShort: () -> String,
+        minuteShort: () -> String,
+        secondShort: () -> String,
         now: () -> String
     ): String {
-        val now = Calendar.getInstance()
-        val then = Calendar.getInstance().also { it.timeInMillis = date }
+        val now = Clock.System.now()
+        val then = Instant.fromEpochMilliseconds(date)
+        val diff = now - then
 
         return when {
-            now.year != then.year -> {
-                "${now.year - then.year}${yearShort().lowercase()}"
-            }
-
-            now.month != then.month -> {
-                "${now.month - then.month}${monthShort().lowercase()}"
-            }
-
-            now.dayOfMonth != then.dayOfMonth -> {
-                val change = now.dayOfMonth - then.dayOfMonth
-
-                if (change % 7 == 0) {
-                    "${change / 7}${weekShort().lowercase()}"
-                } else {
-                    "$change${dayShort().lowercase()}"
-                }
-            }
-
-            now.hour == then.hour && now.minute == then.minute -> {
-                now().lowercase()
-            }
-
-            else -> {
-                SimpleDateFormat("HH:mm", Locale.getDefault()).format(date)
-            }
+            diff > 365.days -> "${diff.inWholeDays / 365}${yearShort().lowercase()}"
+            diff > 30.days -> "${diff.inWholeDays / 30}${monthShort().lowercase()}"
+            diff > 7.days -> "${diff.inWholeDays / 7}${weekShort().lowercase()}"
+            diff > 1.days -> "${diff.inWholeDays}${dayShort().lowercase()}"
+            diff > 1.hours -> "${diff.inWholeHours}h"
+            diff > 1.minutes -> "${diff.inWholeMinutes}${minuteShort().lowercase()}"
+            diff > 1.seconds -> "${diff.inWholeSeconds}${secondShort().lowercase()}"
+            else -> now().lowercase()
         }
     }
 }

core/common/src/main/kotlin/dev/meloda/fast/common/util/Utils.kt

@@ -1,7 +1,17 @@
 package dev.meloda.fast.common.util
 
 import java.net.URLEncoder
+import java.security.MessageDigest
 
 fun String.urlEncode(encoding: String = "utf-8"): String {
     return URLEncoder.encode(this, encoding)
 }
+
+fun String.sha256() = this.hashString("SHA-256")
+
+fun String.hashString(algorithm: String): String {
+    return MessageDigest
+        .getInstance(algorithm)
+        .digest(this.toByteArray())
+        .fold("") { str, it -> str + "%02x".format(it) }
+}

core/data/src/main/kotlin/dev/meloda/fast/data/AccessTokenInterceptor.kt

@@ -1,24 +1,18 @@
 package dev.meloda.fast.data
 
-import androidx.core.net.toUri
 import okhttp3.Interceptor
 import okhttp3.Response
-import java.net.URLEncoder
 
 class AccessTokenInterceptor : Interceptor {
 
     override fun intercept(chain: Interceptor.Chain): Response {
-        val builder = chain.request().url.newBuilder()
+        val request = chain.request()
+        val urlBuilder = request.url.newBuilder()
 
-        val uri = builder.build().toUri().toString().toUri()
-
-        if (uri.getQueryParameter("access_token") == null) {
-            builder.addQueryParameter(
-                "access_token",
-                URLEncoder.encode(UserConfig.accessToken, "utf-8")
-            )
+        if (request.url.queryParameter("access_token") == null) {
+            urlBuilder.addQueryParameter("access_token", UserConfig.accessToken)
         }
 
-        return chain.proceed(chain.request().newBuilder().apply { url(builder.build()) }.build())
+        return chain.proceed(request.newBuilder().url(urlBuilder.build()).build())
     }
 }

core/data/src/main/kotlin/dev/meloda/fast/data/UserConfig.kt

@@ -24,6 +24,9 @@ object UserConfig {
         accessToken = ""
         fastToken = ""
         userId = -1
+        trustedHash = null
+        exchangeToken = null
+        AppSettings.LongPoll.clear()
     }
 
     fun isLoggedIn(): Boolean {

core/data/src/main/kotlin/dev/meloda/fast/data/VkGroupsMap.kt

@@ -21,12 +21,10 @@ class VkGroupsMap(
         else map[abs(convo.id)]
 
     fun messageActionGroup(message: VkMessage): VkGroupDomain? =
-        if (message.actionMemberId == null || message.actionMemberId!! >= 0) null
-        else map[abs(message.actionMemberId!!)]
+        message.actionMemberId?.takeIf { it < 0 }?.let { map[abs(it)] }
 
     fun messageActionGroup(message: VkMessageData): VkGroupDomain? =
-        if (message.action?.memberId == null || message.action!!.memberId!! >= 0) null
-        else map[abs(message.action!!.memberId!!)]
+        message.action?.memberId?.takeIf { it < 0 }?.let { map[abs(it)] }
 
     fun messageGroup(message: VkMessage): VkGroupDomain? =
         if (!message.isGroup()) null

core/data/src/main/kotlin/dev/meloda/fast/data/VkMemoryCache.kt

@@ -1,6 +1,5 @@
 package dev.meloda.fast.data
 
-import dev.meloda.fast.data.UserConfig.userId
 import dev.meloda.fast.model.api.domain.VkContactDomain
 import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
@@ -38,7 +37,15 @@ object VkMemoryCache {
         contacts.forEach { contact -> VkMemoryCache.contacts[contact.userId] = contact }
     }
 
-    operator fun set(userid: Long, user: VkUser) {
+    fun clear() {
+        users.clear()
+        groups.clear()
+        messages.clear()
+        convos.clear()
+        contacts.clear()
+    }
+
+    operator fun set(userId: Long, user: VkUser) {
         users[userId] = user
     }
 

core/data/src/main/kotlin/dev/meloda/fast/data/VkUsersMap.kt

@@ -20,12 +20,10 @@ class VkUsersMap(
         else map[convo.id]
 
     fun messageActionUser(message: VkMessage): VkUser? =
-        if (message.actionMemberId == null || message.actionMemberId!! <= 0) null
-        else map[message.actionMemberId]
+        message.actionMemberId?.takeIf { it > 0 }?.let(map::get)
 
     fun messageActionUser(message: VkMessageData): VkUser? =
-        if (message.action?.memberId == null || message.action!!.memberId!! <= 0) null
-        else map[message.action!!.memberId]
+        message.action?.memberId?.takeIf { it > 0 }?.let(map::get)
 
     fun messageUser(message: VkMessage): VkUser? =
         if (!message.isUser()) null

core/data/src/main/kotlin/dev/meloda/fast/data/api/convos/ConvosRepository.kt

@@ -8,6 +8,9 @@ import dev.meloda.fast.network.RestApiErrorDomain
 interface ConvosRepository {
 
     suspend fun storeConvos(convos: List<VkConvo>)
+    suspend fun getLocalConvos(): List<VkConvo>
+    suspend fun getLocalConvoById(peerId: Long): VkConvo?
+    suspend fun deleteLocalConvo(peerId: Long)
 
     suspend fun getConvos(
         count: Int?,

core/data/src/main/kotlin/dev/meloda/fast/data/api/convos/ConvosRepositoryImpl.kt

@@ -19,11 +19,13 @@ import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.model.api.domain.asEntity
+import dev.meloda.fast.model.database.VkConvoEntity
 import dev.meloda.fast.model.api.requests.ConvosGetRequest
 import dev.meloda.fast.network.RestApiErrorDomain
 import dev.meloda.fast.network.mapApiDefault
 import dev.meloda.fast.network.mapApiResult
 import dev.meloda.fast.network.service.convos.ConvosService
+import dev.meloda.fast.model.database.asExternalModel
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -40,6 +42,28 @@ class ConvosRepositoryImpl(
         convoDao.insertAll(convos.map(VkConvo::asEntity))
     }
 
+    override suspend fun getLocalConvos(): List<VkConvo> = withContext(Dispatchers.IO) {
+        convoDao.getAllWithMessage().map { convoWithMessage ->
+            convoWithMessage.convo.asExternalModel().copy(
+                lastMessage = convoWithMessage.message?.asExternalModel()
+            )
+        }.sorted()
+    }
+
+    override suspend fun getLocalConvoById(peerId: Long): VkConvo? = withContext(Dispatchers.IO) {
+        convoDao.getByIdWithMessage(peerId)?.let { convoWithMessage ->
+            convoWithMessage.convo.asExternalModel().copy(
+                lastMessage = convoWithMessage.message?.asExternalModel()
+            )
+        }
+    }
+
+    override suspend fun deleteLocalConvo(peerId: Long) {
+        withContext(Dispatchers.IO) {
+            convoDao.deleteById(peerId)
+        }
+    }
+
     override suspend fun getConvos(
         count: Int?,
         offset: Int?,
@@ -198,4 +222,28 @@ class ConvosRepositoryImpl(
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
         convosService.unarchive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
+
+    private fun List<VkConvo>.sorted(): List<VkConvo> {
+        val newConvos = toMutableList()
+
+        val pinnedConvos = newConvos
+            .filter(VkConvo::isPinned)
+            .sortedWith { c1, c2 ->
+                val diff = c2.majorId - c1.majorId
+
+                if (diff == 0) {
+                    c2.minorId - c1.minorId
+                } else {
+                    diff
+                }
+            }
+
+        newConvos.removeAll(pinnedConvos)
+        newConvos.sortWith { c1, c2 ->
+            (c2.lastMessage?.date ?: 0) - (c1.lastMessage?.date ?: 0)
+        }
+
+        newConvos.addAll(0, pinnedConvos)
+        return newConvos
+    }
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/longpoll/LongPollRepository.kt

@@ -1,6 +1,7 @@
 package dev.meloda.fast.data.api.longpoll
 
 import dev.meloda.fast.model.api.data.LongPollUpdates
+import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.VkLongPollData
 import dev.meloda.fast.network.RestApiErrorDomain
 import com.slack.eithernet.ApiResult
@@ -21,4 +22,14 @@ interface LongPollRepository {
         mode: Int,
         version: Int
     ): ApiResult<LongPollUpdates, RestApiErrorDomain>
+
+    suspend fun getLongPollHistory(
+        ts: Int,
+        pts: Int,
+        lpVersion: Int,
+        lastN: Int? = null,
+        maxMsgId: Long? = null,
+        eventsLimit: Int? = null,
+        msgsLimit: Int? = null
+    ): ApiResult<LongPollHistoryResponse, RestApiErrorDomain>
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/longpoll/LongPollRepositoryImpl.kt

@@ -1,7 +1,9 @@
 package dev.meloda.fast.data.api.longpoll
 
 import dev.meloda.fast.model.api.data.LongPollUpdates
+import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.VkLongPollData
+import dev.meloda.fast.model.api.requests.LongPollGetHistoryRequest
 import dev.meloda.fast.model.api.requests.LongPollGetUpdatesRequest
 import dev.meloda.fast.model.api.requests.MessagesGetLongPollServerRequest
 import dev.meloda.fast.network.RestApiErrorDomain
@@ -52,4 +54,29 @@ class LongPollRepositoryImpl(
 
         longPollService.getResponse(serverUrl, requestModel.map).mapDefault()
     }
+
+    override suspend fun getLongPollHistory(
+        ts: Int,
+        pts: Int,
+        lpVersion: Int,
+        lastN: Int?,
+        maxMsgId: Long?,
+        eventsLimit: Int?,
+        msgsLimit: Int?
+    ): ApiResult<LongPollHistoryResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+        val requestModel = LongPollGetHistoryRequest(
+            ts = ts,
+            pts = pts,
+            lpVersion = lpVersion,
+            lastN = lastN,
+            maxMsgId = maxMsgId,
+            eventsLimit = eventsLimit,
+            msgsLimit = msgsLimit
+        )
+
+        messagesService.getLongPollHistory(requestModel.map).mapApiResult(
+            successMapper = { response -> response.requireResponse() },
+            errorMapper = { error -> error?.toDomain() }
+        )
+    }
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/messages/MessagesRepository.kt

@@ -14,6 +14,12 @@ interface MessagesRepository {
 
     suspend fun storeMessages(messages: List<VkMessage>)
 
+    suspend fun getLocalMessages(convoId: Long): List<VkMessage>
+    suspend fun getLocalMessageById(messageId: Long): VkMessage?
+    suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage?
+    suspend fun getLocalMaxMessageId(): Long?
+    suspend fun deleteLocalMessages(messageIds: List<Long>)
+
     suspend fun getHistory(
         convoId: Long,
         offset: Int?,

core/data/src/main/kotlin/dev/meloda/fast/data/api/messages/MessagesRepositoryImpl.kt

@@ -22,6 +22,7 @@ import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.model.api.domain.asEntity
+import dev.meloda.fast.model.database.VkMessageEntity
 import dev.meloda.fast.model.api.requests.MessagesCreateChatRequest
 import dev.meloda.fast.model.api.requests.MessagesDeleteRequest
 import dev.meloda.fast.model.api.requests.MessagesEditRequest
@@ -39,6 +40,7 @@ import dev.meloda.fast.model.api.requests.MessagesUnpinMessageRequest
 import dev.meloda.fast.model.api.responses.MessagesGetConvoMembersResponse
 import dev.meloda.fast.model.api.responses.MessagesGetReadPeersResponse
 import dev.meloda.fast.model.api.responses.MessagesSendResponse
+import dev.meloda.fast.model.database.asExternalModel
 import dev.meloda.fast.network.RestApiErrorDomain
 import dev.meloda.fast.network.mapApiDefault
 import dev.meloda.fast.network.mapApiResult
@@ -354,6 +356,28 @@ class MessagesRepositoryImpl(
         messageDao.insertAll(messages.map(VkMessage::asEntity))
     }
 
+    override suspend fun getLocalMessages(convoId: Long): List<VkMessage> = withContext(Dispatchers.IO) {
+        messageDao.getAll(convoId).map(VkMessageEntity::asExternalModel)
+    }
+
+    override suspend fun getLocalMessageById(messageId: Long): VkMessage? = withContext(Dispatchers.IO) {
+        messageDao.getById(messageId)?.asExternalModel()
+    }
+
+    override suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage? = withContext(Dispatchers.IO) {
+        messageDao.getByConvoMessageId(convoId, cmId)?.asExternalModel()
+    }
+
+    override suspend fun getLocalMaxMessageId(): Long? = withContext(Dispatchers.IO) {
+        messageDao.getMaxId()
+    }
+
+    override suspend fun deleteLocalMessages(messageIds: List<Long>) {
+        withContext(Dispatchers.IO) {
+            messageDao.deleteByIds(messageIds)
+        }
+    }
+
     override suspend fun edit(
         peerId: Long,
         messageId: Long?,

core/data/src/main/kotlin/dev/meloda/fast/data/api/oauth/OAuthRepository.kt

@@ -23,5 +23,6 @@ interface OAuthRepository {
         validationCode: String?,
         captchaSid: String?,
         captchaKey: String?,
+        successToken: String?
     ): ApiResult<GetSilentTokenResponse, OAuthErrorDomain>
 }

core/data/src/main/kotlin/dev/meloda/fast/data/api/oauth/OAuthRepositoryImpl.kt

@@ -79,7 +79,8 @@ class OAuthRepositoryImpl(
                     VkOAuthError.NEED_CAPTCHA -> {
                         OAuthErrorDomain.CaptchaRequiredError(
                             captchaSid = response.captchaSid.orEmpty(),
-                            captchaImageUrl = response.captchaImage.orEmpty()
+                            captchaImageUrl = response.captchaImage.orEmpty(),
+                            redirectUri = response.redirectUri
                         )
                     }
 
@@ -122,6 +123,7 @@ class OAuthRepositoryImpl(
         validationCode: String?,
         captchaSid: String?,
         captchaKey: String?,
+        successToken: String?
     ): ApiResult<GetSilentTokenResponse, OAuthErrorDomain> =
         withContext(Dispatchers.IO) {
             val requestModel = AuthDirectRequest(
@@ -135,6 +137,7 @@ class OAuthRepositoryImpl(
                 validationCode = validationCode,
                 captchaSid = captchaSid,
                 captchaKey = captchaKey,
+                successToken = successToken
             )
 
             oAuthService.getSilentToken(requestModel.map).mapResult(
@@ -175,7 +178,8 @@ class OAuthRepositoryImpl(
                         VkOAuthError.NEED_CAPTCHA -> {
                             OAuthErrorDomain.CaptchaRequiredError(
                                 captchaSid = response.captchaSid.orEmpty(),
-                                captchaImageUrl = response.captchaImage.orEmpty()
+                                captchaImageUrl = response.captchaImage.orEmpty(),
+                                redirectUri = response.redirectUri
                             )
                         }
 

core/database/src/main/kotlin/dev/meloda/fast/database/dao/ConvoDao.kt

@@ -9,9 +9,13 @@ import dev.meloda.fast.model.database.VkConvoEntity
 @Dao
 abstract class ConvoDao : EntityDao<VkConvoEntity> {
 
-    @Query("SELECT * FROM convos")
+    @Query("SELECT * FROM convos ORDER BY majorId DESC, minorId DESC")
     abstract suspend fun getAll(): List<VkConvoEntity>
 
+    @Transaction
+    @Query("SELECT * FROM convos ORDER BY majorId DESC, minorId DESC")
+    abstract suspend fun getAllWithMessage(): List<ConvoWithMessage>
+
     @Query("SELECT * FROM convos WHERE id IN (:ids)")
     abstract suspend fun getAllByIds(ids: List<Int>): List<VkConvoEntity>
 
@@ -22,6 +26,9 @@ abstract class ConvoDao : EntityDao<VkConvoEntity> {
     @Query("SELECT * FROM convos WHERE id IS (:id)")
     abstract suspend fun getByIdWithMessage(id: Long): ConvoWithMessage?
 
+    @Query("DELETE FROM convos WHERE id IS (:id)")
+    abstract suspend fun deleteById(id: Long): Int
+
     @Query("DELETE FROM convos WHERE rowid IN (:ids)")
     abstract suspend fun deleteByIds(ids: List<Int>): Int
 }

core/database/src/main/kotlin/dev/meloda/fast/database/dao/MessageDao.kt

@@ -10,15 +10,21 @@ abstract class MessageDao : EntityDao<VkMessageEntity> {
     @Query("SELECT * FROM messages")
     abstract suspend fun getAll(): List<VkMessageEntity>
 
-    @Query("SELECT * FROM messages WHERE peerId IS (:convoId)")
+    @Query("SELECT * FROM messages WHERE peerId IS (:convoId) ORDER BY date DESC, id DESC")
     abstract suspend fun getAll(convoId: Long): List<VkMessageEntity>
 
     @Query("SELECT * FROM messages WHERE id IN (:ids)")
-    abstract suspend fun getAllByIds(ids: List<Int>): List<VkMessageEntity>
+    abstract suspend fun getAllByIds(ids: List<Long>): List<VkMessageEntity>
 
     @Query("SELECT * FROM messages WHERE id IS (:messageId)")
     abstract suspend fun getById(messageId: Long): VkMessageEntity?
 
+    @Query("SELECT * FROM messages WHERE peerId IS (:convoId) AND cmId IS (:cmId)")
+    abstract suspend fun getByConvoMessageId(convoId: Long, cmId: Long): VkMessageEntity?
+
+    @Query("SELECT MAX(id) FROM messages")
+    abstract suspend fun getMaxId(): Long?
+
     @Query("DELETE FROM messages WHERE id IN (:ids)")
-    abstract suspend fun deleteByIds(ids: List<Int>): Int
+    abstract suspend fun deleteByIds(ids: List<Long>): Int
 }

core/datastore/src/main/kotlin/dev/meloda/fast/datastore/AppSettings.kt

@@ -4,13 +4,32 @@ import android.content.SharedPreferences
 import androidx.core.content.edit
 import dev.meloda.fast.common.model.DarkMode
 import dev.meloda.fast.common.model.LogLevel
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
 import kotlin.properties.Delegates
 import kotlin.reflect.KClass
 
+sealed class CaptchaTokenResult {
+    data object Initial : CaptchaTokenResult()
+    data object Null : CaptchaTokenResult()
+    data object Cancelled : CaptchaTokenResult()
+    data class Success(val token: String) : CaptchaTokenResult()
+}
+
 object AppSettings {
 
     private var preferences: SharedPreferences by Delegates.notNull()
 
+    private val captchaResult = MutableStateFlow<CaptchaTokenResult>(CaptchaTokenResult.Initial)
+    fun getCaptchaResultFlow(): StateFlow<CaptchaTokenResult> = captchaResult.asStateFlow()
+    fun setCaptchaResult(result: CaptchaTokenResult) = captchaResult.update { result }
+
+    private val captchaRedirectUri = MutableStateFlow<String?>(null)
+    fun getCaptchaRedirectUriFlow() = captchaRedirectUri.asStateFlow()
+    fun setCaptchaRedirectUri(redirectUri: String?) = captchaRedirectUri.update { redirectUri }
+
     fun init(preferences: SharedPreferences) {
         this.preferences = preferences
     }
@@ -211,6 +230,21 @@ object AppSettings {
             set(value) = put(SettingsKeys.KEY_MORE_ANIMATIONS, value)
     }
 
+    object LongPoll {
+        var ts: Int?
+            get() = get(SettingsKeys.KEY_LONG_POLL_TS, 0).takeIf { it > 0 }
+            set(value) = put(SettingsKeys.KEY_LONG_POLL_TS, value ?: 0)
+
+        var pts: Int?
+            get() = get(SettingsKeys.KEY_LONG_POLL_PTS, 0).takeIf { it > 0 }
+            set(value) = put(SettingsKeys.KEY_LONG_POLL_PTS, value ?: 0)
+
+        fun clear() {
+            ts = null
+            pts = null
+        }
+    }
+
     object Debug {
         var showAlertAfterCrash: Boolean
             get() = get(

core/datastore/src/main/kotlin/dev/meloda/fast/datastore/SettingsKeys.kt

@@ -39,6 +39,8 @@ object SettingsKeys {
     const val DEFAULT_VALUE_FEATURES_FAST_TEXT = "¯\\_(ツ)_/¯"
     const val KEY_LONG_POLL_IN_BACKGROUND = "lp_background"
     const val DEFAULT_LONG_POLL_IN_BACKGROUND = false
+    const val KEY_LONG_POLL_TS = "lp_ts"
+    const val KEY_LONG_POLL_PTS = "lp_pts"
 
     const val KEY_ACTIVITY_SEND_ONLINE_STATUS = "activity_send_online_status"
     const val DEFAULT_VALUE_KEY_ACTIVITY_SEND_ONLINE_STATUS = false

core/domain/src/main/kotlin/dev/meloda/fast/domain/ConvoUseCase.kt

@@ -8,6 +8,9 @@ import kotlinx.coroutines.flow.Flow
 interface ConvoUseCase : BaseUseCase {
 
     suspend fun storeConvos(convos: List<VkConvo>)
+    suspend fun getLocalConvos(): List<VkConvo>
+    suspend fun getLocalConvoById(peerId: Long): VkConvo?
+    suspend fun deleteLocalConvo(peerId: Long)
 
     fun getConvos(
         count: Int? = null,

core/domain/src/main/kotlin/dev/meloda/fast/domain/ConvoUseCaseImpl.kt

@@ -19,6 +19,18 @@ class ConvoUseCaseImpl(
         repository.storeConvos(convos)
     }
 
+    override suspend fun getLocalConvos(): List<VkConvo> = withContext(Dispatchers.IO) {
+        repository.getLocalConvos()
+    }
+
+    override suspend fun getLocalConvoById(peerId: Long): VkConvo? = withContext(Dispatchers.IO) {
+        repository.getLocalConvoById(peerId)
+    }
+
+    override suspend fun deleteLocalConvo(peerId: Long) = withContext(Dispatchers.IO) {
+        repository.deleteLocalConvo(peerId)
+    }
+
     override fun getConvos(
         count: Int?,
         offset: Int?,

core/domain/src/main/kotlin/dev/meloda/fast/domain/GetCurrentAccountUseCase.kt

@@ -6,10 +6,7 @@ import dev.meloda.fast.model.database.AccountEntity
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 
-class GetCurrentAccountUseCase(
-    private val accountsRepository: AccountsRepository
-) {
-
+class GetCurrentAccountUseCase(private val accountsRepository: AccountsRepository) {
     suspend operator fun invoke(): AccountEntity? = withContext(Dispatchers.IO) {
         accountsRepository.getAccountById(UserConfig.currentUserId)
     }

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollEventDispatcher.kt

@@ -0,0 +1,36 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.model.LongPollEvent
+import dev.meloda.fast.model.LongPollParsedEvent
+
+internal class LongPollEventDispatcher {
+    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
+        mutableMapOf()
+
+    @Suppress("UNCHECKED_CAST")
+    fun <T : LongPollParsedEvent> dispatch(eventType: LongPollEvent, event: T) {
+        listenersMap[eventType]?.forEach { callback ->
+            (callback as? VkEventCallback<T>)?.onEvent(event)
+        }
+    }
+
+    fun dispatchAll(eventType: LongPollEvent, events: List<LongPollParsedEvent>) {
+        events.forEach { event -> dispatch(eventType, event) }
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    fun <T : LongPollParsedEvent> registerListener(
+        eventType: LongPollEvent,
+        listener: VkEventCallback<T>
+    ) {
+        listenersMap[eventType] = (listenersMap[eventType] ?: mutableListOf())
+            .also { it.add(listener as VkEventCallback<LongPollParsedEvent>) }
+    }
+
+    fun <T : LongPollParsedEvent> registerListeners(
+        eventTypes: List<LongPollEvent>,
+        listener: VkEventCallback<T>
+    ) {
+        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
+    }
+}

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollEventParser.kt

@@ -0,0 +1,537 @@
+package dev.meloda.fast.domain
+
+import android.util.Log
+import dev.meloda.fast.common.VkConstants
+import dev.meloda.fast.common.extensions.asInt
+import dev.meloda.fast.common.extensions.asLong
+import dev.meloda.fast.common.extensions.listenValue
+import dev.meloda.fast.common.extensions.toList
+import dev.meloda.fast.data.UserConfig
+import dev.meloda.fast.data.processState
+import dev.meloda.fast.model.ApiEvent
+import dev.meloda.fast.model.ConvoFlags
+import dev.meloda.fast.model.InteractionType
+import dev.meloda.fast.model.LongPollEvent
+import dev.meloda.fast.model.LongPollParsedEvent
+import dev.meloda.fast.model.MessageFlags
+import dev.meloda.fast.model.api.domain.VkConvo
+import dev.meloda.fast.model.api.domain.VkMessage
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.async
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+internal class LongPollEventParser(
+    private val coroutineScope: CoroutineScope,
+    private val convoUseCase: ConvoUseCase,
+    private val messagesUseCase: MessagesUseCase,
+    private val dispatch: (LongPollEvent, LongPollParsedEvent) -> Unit,
+    private val dispatchAll: (LongPollEvent, List<LongPollParsedEvent>) -> Unit
+) {
+    fun parseNextUpdate(event: List<Any>) {
+        val eventId = event.first().asInt()
+
+        when (val eventType = ApiEvent.parseOrNull(eventId)) {
+            null -> Unit
+
+            ApiEvent.MESSAGE_SET_FLAGS -> parseMessageSetFlags(eventType, event)
+            ApiEvent.MESSAGE_CLEAR_FLAGS -> parseMessageClearFlags(eventType, event)
+            ApiEvent.MESSAGE_NEW -> parseMessageNew(eventType, event)
+            ApiEvent.MESSAGE_EDIT -> parseMessageEdit(eventType, event)
+            ApiEvent.MESSAGE_READ_INCOMING -> parseMessageReadIncoming(eventType, event)
+            ApiEvent.MESSAGE_READ_OUTGOING -> parseMessageReadOutgoing(eventType, event)
+            ApiEvent.CHAT_CLEAR_FLAGS -> parseChatClearFlags(eventType, event)
+            ApiEvent.CHAT_SET_FLAGS -> parseChatSetFlags(eventType, event)
+            ApiEvent.MESSAGES_DELETED -> parseMessagesDeleted(eventType, event)
+            ApiEvent.CHAT_MAJOR_CHANGED -> parseChatMajorChanged(eventType, event)
+            ApiEvent.CHAT_MINOR_CHANGED -> parseChatMinorChanged(eventType, event)
+
+            ApiEvent.TYPING,
+            ApiEvent.AUDIO_MESSAGE_RECORDING,
+            ApiEvent.PHOTO_UPLOADING,
+            ApiEvent.VIDEO_UPLOADING,
+            ApiEvent.FILE_UPLOADING -> parseInteraction(eventType, event)
+
+            ApiEvent.UNREAD_COUNT_UPDATE -> parseUnreadCounterUpdate(eventType, event)
+            ApiEvent.MESSAGE_UPDATED -> parseMessageUpdated(eventType, event)
+            ApiEvent.MESSAGE_CACHE_CLEAR -> parseMessageCacheClear(eventType, event)
+        }
+    }
+
+    private fun parseMessageSetFlags(eventType: ApiEvent, event: List<Any>) {
+        val cmId = event[1].asLong()
+        val flags = event[2].asInt()
+        val peerId = event[3].asLong()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = MessageFlags.parse(flags)
+        parsedFlags.forEach { flag ->
+            when (flag) {
+                MessageFlags.IMPORTANT -> {
+                    val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
+                        peerId = peerId,
+                        cmId = cmId,
+                        marked = true
+                    )
+                    eventsToSend += eventToSend
+                    dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
+                }
+
+                MessageFlags.SPAM -> {
+                    val eventToSend = LongPollParsedEvent.MessageMarkedAsSpam(
+                        peerId = peerId,
+                        cmId = cmId
+                    )
+                    eventsToSend += eventToSend
+                    dispatch(LongPollEvent.MARKED_AS_SPAM, eventToSend)
+                }
+
+                MessageFlags.DELETED -> {
+                    val eventToSend =
+                        if (parsedFlags.contains(MessageFlags.DELETED_FOR_ALL)) {
+                            LongPollParsedEvent.MessageDeleted(
+                                peerId = peerId,
+                                cmId = cmId,
+                                forAll = true
+                            )
+                        } else {
+                            LongPollParsedEvent.MessageDeleted(
+                                peerId = peerId,
+                                cmId = cmId,
+                                forAll = false
+                            )
+                        }
+                    eventsToSend += eventToSend
+                    dispatch(LongPollEvent.MESSAGE_DELETED, eventToSend)
+                }
+
+                MessageFlags.AUDIO_LISTENED -> {
+                    val eventToSend = LongPollParsedEvent.AudioMessageListened(
+                        peerId = peerId,
+                        cmId = cmId
+                    )
+                    eventsToSend += eventToSend
+                    dispatch(LongPollEvent.AUDIO_MESSAGE_LISTENED, eventToSend)
+                }
+
+                else -> Unit
+            }
+        }
+
+        dispatchAll(LongPollEvent.MESSAGE_SET_FLAGS, eventsToSend)
+    }
+
+    private fun parseMessageClearFlags(eventType: ApiEvent, event: List<Any>) {
+        val cmId = event[1].asLong()
+        val flags = event[2].asInt()
+        val peerId = event[3].asLong()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = MessageFlags.parse(flags)
+
+        coroutineScope.launch {
+            parsedFlags.forEach { flag ->
+                when (flag) {
+                    MessageFlags.IMPORTANT -> {
+                        val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
+                            peerId = peerId,
+                            cmId = cmId,
+                            marked = false
+                        )
+                        eventsToSend += eventToSend
+                        dispatch(LongPollEvent.MARKED_AS_IMPORTANT, eventToSend)
+                    }
+
+                    MessageFlags.SPAM -> {
+                        if (parsedFlags.contains(MessageFlags.CANCEL_SPAM)) {
+                            withContext(Dispatchers.IO) {
+                                val message = loadMessage(
+                                    peerId = peerId,
+                                    cmId = cmId
+                                )
+                                message?.let {
+                                    val eventToSend =
+                                        LongPollParsedEvent.MessageMarkedAsNotSpam(message = message)
+                                    eventsToSend += eventToSend
+                                    dispatch(LongPollEvent.MARKED_AS_NOT_SPAM, eventToSend)
+                                }
+                            }
+                        }
+                    }
+
+                    MessageFlags.DELETED -> {
+                        withContext(Dispatchers.IO) {
+                            val message = loadMessage(
+                                peerId = peerId,
+                                cmId = cmId
+                            )
+                            message?.let {
+                                val eventToSend =
+                                    LongPollParsedEvent.MessageRestored(message = message)
+                                eventsToSend += eventToSend
+                                dispatch(LongPollEvent.MESSAGE_RESTORED, eventToSend)
+                            }
+                        }
+                    }
+
+                    else -> Unit
+                }
+            }
+
+            dispatchAll(LongPollEvent.MESSAGE_CLEAR_FLAGS, eventsToSend)
+        }
+    }
+
+    private fun parseMessageNew(eventType: ApiEvent, event: List<Any>) {
+        val cmId = event[1].asLong()
+        val peerId = event[4].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            val message =
+                async { loadMessage(peerId = peerId, cmId = cmId) }.await()
+
+            val convo =
+                async {
+                    loadConvo(
+                        peerId = peerId,
+                        extended = true,
+                        fields = VkConstants.ALL_FIELDS
+                    )
+                }.await()
+
+            message?.let {
+                dispatch(
+                    LongPollEvent.MESSAGE_NEW,
+                    LongPollParsedEvent.NewMessage(
+                        message = message,
+                        inArchive = convo?.isArchived == true
+                    )
+                )
+            }
+        }
+    }
+
+    private fun parseMessageEdit(eventType: ApiEvent, event: List<Any>) {
+        val cmId = event[1].asLong()
+        val peerId = event[3].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            loadMessage(
+                peerId = peerId,
+                cmId = cmId
+            )?.let { message ->
+                dispatch(LongPollEvent.MESSAGE_EDITED, LongPollParsedEvent.MessageEdited(message))
+            }
+        }
+    }
+
+    private fun parseMessageReadIncoming(eventType: ApiEvent, event: List<Any>) {
+        dispatchMessageRead(
+            longPollEvent = LongPollEvent.INCOMING_MESSAGE_READ,
+            parsedEvent = LongPollParsedEvent.IncomingMessageRead(
+                peerId = event[1].asLong(),
+                cmId = event[2].asLong(),
+                unreadCount = event[3].asInt()
+            )
+        )
+    }
+
+    private fun parseMessageReadOutgoing(eventType: ApiEvent, event: List<Any>) {
+        dispatchMessageRead(
+            longPollEvent = LongPollEvent.OUTGOING_MESSAGE_READ,
+            parsedEvent = LongPollParsedEvent.OutgoingMessageRead(
+                peerId = event[1].asLong(),
+                cmId = event[2].asLong(),
+                unreadCount = event[3].asInt()
+            )
+        )
+    }
+
+    private fun parseChatClearFlags(eventType: ApiEvent, event: List<Any>) {
+        val peerId = event[1].asLong()
+        val flags = event[2].asInt()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = ConvoFlags.parse(flags)
+
+        coroutineScope.launch(Dispatchers.IO) {
+            parsedFlags.forEach { flag ->
+                when (flag) {
+                    ConvoFlags.ARCHIVED -> {
+                        handleArchivedChat(
+                            peerId = peerId,
+                            archived = false,
+                            eventsToSend = eventsToSend
+                        )
+                    }
+
+                    else -> Unit
+                }
+            }
+
+            dispatchAll(LongPollEvent.CHAT_CLEAR_FLAGS, eventsToSend)
+        }
+    }
+
+    private fun parseChatSetFlags(eventType: ApiEvent, event: List<Any>) {
+        val peerId = event[1].asLong()
+        val flags = event[2].asInt()
+
+        val eventsToSend = mutableListOf<LongPollParsedEvent>()
+
+        val parsedFlags = ConvoFlags.parse(flags)
+
+        coroutineScope.launch(Dispatchers.IO) {
+            parsedFlags.forEach { flag ->
+                when (flag) {
+                    ConvoFlags.ARCHIVED -> {
+                        handleArchivedChat(
+                            peerId = peerId,
+                            archived = true,
+                            eventsToSend = eventsToSend
+                        )
+                    }
+
+                    else -> Unit
+                }
+            }
+
+            dispatchAll(LongPollEvent.CHAT_SET_FLAGS, eventsToSend)
+        }
+    }
+
+    private fun parseMessagesDeleted(eventType: ApiEvent, event: List<Any>) {
+        val peerId = event[1].asLong()
+        val cmId = event[2].asLong()
+
+        dispatch(
+            LongPollEvent.CHAT_CLEARED,
+            LongPollParsedEvent.ChatCleared(
+                peerId = peerId,
+                toCmId = cmId
+            )
+        )
+    }
+
+    private fun parseChatMajorChanged(eventType: ApiEvent, event: List<Any>) {
+        val peerId = event[1].asLong()
+        val majorId = event[2].asInt()
+
+        dispatch(
+            LongPollEvent.CHAT_MAJOR_CHANGED,
+            LongPollParsedEvent.ChatMajorChanged(
+                peerId = peerId,
+                majorId = majorId,
+            )
+        )
+    }
+
+    private fun parseChatMinorChanged(eventType: ApiEvent, event: List<Any>) {
+        val peerId = event[1].asLong()
+        val minorId = event[2].asInt()
+
+        dispatch(
+            LongPollEvent.CHAT_MINOR_CHANGED,
+            LongPollParsedEvent.ChatMinorChanged(
+                peerId = peerId,
+                minorId = minorId,
+            )
+        )
+    }
+
+    private fun parseInteraction(eventType: ApiEvent, event: List<Any>) {
+        val interactionType = when (eventType) {
+            ApiEvent.TYPING -> InteractionType.Typing
+            ApiEvent.AUDIO_MESSAGE_RECORDING -> InteractionType.VoiceMessage
+            ApiEvent.PHOTO_UPLOADING -> InteractionType.Photo
+            ApiEvent.VIDEO_UPLOADING -> InteractionType.Video
+            ApiEvent.FILE_UPLOADING -> InteractionType.File
+            else -> return
+        }
+
+        val longPollEvent: LongPollEvent = when (eventType) {
+            ApiEvent.TYPING -> LongPollEvent.TYPING
+            ApiEvent.AUDIO_MESSAGE_RECORDING -> LongPollEvent.AUDIO_MESSAGE_RECORDING
+            ApiEvent.PHOTO_UPLOADING -> LongPollEvent.PHOTO_UPLOADING
+            ApiEvent.VIDEO_UPLOADING -> LongPollEvent.VIDEO_UPLOADING
+            ApiEvent.FILE_UPLOADING -> LongPollEvent.FILE_UPLOADING
+            else -> return
+        }
+
+        val peerId = event[1].asLong()
+        val userIds = event[2].toList(Any::asLong).filter { it != UserConfig.userId }
+        val totalCount = event[3].asInt()
+        val timestamp = event[4].asInt()
+
+        if (userIds.isEmpty()) return
+
+        dispatch(
+            longPollEvent,
+            LongPollParsedEvent.Interaction(
+                interactionType = interactionType,
+                peerId = peerId,
+                userIds = userIds,
+                totalCount = totalCount,
+                timestamp = timestamp
+            )
+        )
+    }
+
+    private fun parseUnreadCounterUpdate(eventType: ApiEvent, event: List<Any>) {
+        val unreadCount = event[1].asInt()
+        val unreadUnmutedCount = event[2].asInt()
+        val showOnlyMuted = event[3].asInt() == 1
+        val businessNotifyUnreadCount = event[4].asInt()
+        val archiveUnreadCount = event[7].asInt()
+        val archiveUnreadUnmutedCount = event[8].asInt()
+        val archiveMentionsCount = event[9].asInt()
+
+        dispatch(
+            LongPollEvent.UNREAD_COUNTER_UPDATE,
+            LongPollParsedEvent.UnreadCounter(
+                unread = unreadCount,
+                unreadUnmuted = unreadUnmutedCount,
+                showOnlyMuted = showOnlyMuted,
+                business = businessNotifyUnreadCount,
+                archive = archiveUnreadCount,
+                archiveUnmuted = archiveUnreadUnmutedCount,
+                archiveMentions = archiveMentionsCount
+            )
+        )
+    }
+
+    private fun parseMessageUpdated(eventType: ApiEvent, event: List<Any>) {
+        val cmId = event[1].asLong()
+        val peerId = event[4].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            loadMessage(
+                peerId = peerId,
+                cmId = cmId
+            )?.let { message ->
+                dispatch(LongPollEvent.MESSAGE_UPDATED, LongPollParsedEvent.MessageUpdated(message))
+            }
+        }
+    }
+
+    private fun parseMessageCacheClear(eventType: ApiEvent, event: List<Any>) {
+        val messageId = event[1].asLong()
+
+        coroutineScope.launch(Dispatchers.IO) {
+            loadMessage(messageId = messageId)?.let { message ->
+                dispatch(
+                    LongPollEvent.MESSAGE_CACHE_CLEAR,
+                    LongPollParsedEvent.MessageCacheClear(message)
+                )
+            }
+        }
+    }
+
+    private suspend fun loadMessage(
+        peerId: Long? = null,
+        cmId: Long? = null,
+        messageId: Long? = null
+    ): VkMessage? = suspendCancellableCoroutine { continuation ->
+        require((peerId != null && cmId != null) || messageId != null)
+
+        val job = coroutineScope.launch(Dispatchers.IO) {
+            messagesUseCase.getById(
+                peerCmIds = null,
+                peerId = peerId,
+                messageIds = messageId?.let(::listOf),
+                cmIds = cmId?.let(::listOf),
+                extended = true,
+                fields = VkConstants.ALL_FIELDS
+            ).listenValue(this) { state ->
+                state.processState(
+                    error = { error ->
+                        Log.e("LongPollEventParser", "loadMessage: error: $error")
+                        continuation.resume(null)
+                    },
+                    success = { response ->
+                        val message = response.singleOrNull() ?: run {
+                            continuation.resume(null)
+                            return@listenValue
+                        }
+
+                        continuation.resume(message)
+                    }
+                )
+            }
+        }
+
+        continuation.invokeOnCancellation {
+            job.cancel()
+        }
+    }
+
+    private suspend fun loadConvo(
+        peerId: Long,
+        extended: Boolean = false,
+        fields: String? = null
+    ): VkConvo? = suspendCancellableCoroutine { continuation ->
+        val job = coroutineScope.launch(Dispatchers.IO) {
+            convoUseCase.getById(
+                peerIds = listOf(peerId),
+                extended = extended,
+                fields = fields
+            ).listenValue(coroutineScope) { state ->
+                state.processState(
+                    error = { error ->
+                        Log.e("LongPollEventParser", "loadConvo: error: $error")
+                        continuation.resume(null)
+                    },
+                    success = { response ->
+                        val convo = response.singleOrNull() ?: run {
+                            continuation.resume(null)
+                            return@listenValue
+                        }
+
+                        continuation.resume(convo)
+                    }
+                )
+            }
+        }
+
+        continuation.invokeOnCancellation {
+            job.cancel()
+        }
+    }
+
+    private suspend fun handleArchivedChat(
+        peerId: Long,
+        archived: Boolean,
+        eventsToSend: MutableList<LongPollParsedEvent>
+    ) {
+        val convo = loadConvo(
+            peerId = peerId,
+            extended = true,
+            fields = VkConstants.ALL_FIELDS
+        ) ?: return
+
+        val message = loadMessage(
+            peerId = peerId,
+            cmId = convo.lastCmId
+        )
+
+        val eventToSend = LongPollParsedEvent.ChatArchived(
+            convo = convo.copy(lastMessage = message),
+            archived = archived
+        )
+        eventsToSend += eventToSend
+        dispatch(LongPollEvent.CHAT_ARCHIVED, eventToSend)
+    }
+
+    private fun dispatchMessageRead(
+        longPollEvent: LongPollEvent,
+        parsedEvent: LongPollParsedEvent
+    ) {
+        dispatch(longPollEvent, parsedEvent)
+    }
+}

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollUpdatesParser.kt

@@ -1,35 +1,17 @@
 package dev.meloda.fast.domain
 
 import android.util.Log
-import dev.meloda.fast.common.VkConstants
-import dev.meloda.fast.common.extensions.asInt
-import dev.meloda.fast.common.extensions.asLong
-import dev.meloda.fast.common.extensions.listenValue
-import dev.meloda.fast.common.extensions.toList
-import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.data.processState
-import dev.meloda.fast.model.ApiEvent
-import dev.meloda.fast.model.ConvoFlags
-import dev.meloda.fast.model.InteractionType
 import dev.meloda.fast.model.LongPollEvent
 import dev.meloda.fast.model.LongPollParsedEvent
-import dev.meloda.fast.model.MessageFlags
-import dev.meloda.fast.model.api.domain.VkConvo
-import dev.meloda.fast.model.api.domain.VkMessage
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
-import kotlinx.coroutines.async
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
 import kotlin.coroutines.CoroutineContext
-import kotlin.coroutines.resume
-import kotlin.coroutines.suspendCoroutine
 
 class LongPollUpdatesParser(
-    private val convoUseCase: ConvoUseCase,
-    private val messagesUseCase: MessagesUseCase
+    convoUseCase: ConvoUseCase,
+    messagesUseCase: MessagesUseCase
 ) {
     private val job = SupervisorJob()
 
@@ -43,747 +25,89 @@ class LongPollUpdatesParser(
         get() = Dispatchers.Default + job + exceptionHandler
 
     private val coroutineScope = CoroutineScope(coroutineContext)
-
-    private val listenersMap: MutableMap<LongPollEvent, MutableList<VkEventCallback<LongPollParsedEvent>>> =
-        mutableMapOf()
+    private val eventDispatcher = LongPollEventDispatcher()
+    private val eventParser = LongPollEventParser(
+        coroutineScope = coroutineScope,
+        convoUseCase = convoUseCase,
+        messagesUseCase = messagesUseCase,
+        dispatch = eventDispatcher::dispatch,
+        dispatchAll = eventDispatcher::dispatchAll
+    )
 
     fun parseNextUpdate(event: List<Any>) {
-        val eventId = event.first().asInt()
-
-        when (val eventType = ApiEvent.parseOrNull(eventId)) {
-            null -> Log.d("LongPollUpdatesParser", "parseNextUpdate: unknownEvent: $event")
-
-            ApiEvent.MESSAGE_SET_FLAGS -> parseMessageSetFlags(eventType, event)
-            ApiEvent.MESSAGE_CLEAR_FLAGS -> parseMessageClearFlags(eventType, event)
-            ApiEvent.MESSAGE_NEW -> parseMessageNew(eventType, event)
-            ApiEvent.MESSAGE_EDIT -> parseMessageEdit(eventType, event)
-            ApiEvent.MESSAGE_READ_INCOMING -> parseMessageReadIncoming(eventType, event)
-            ApiEvent.MESSAGE_READ_OUTGOING -> parseMessageReadOutgoing(eventType, event)
-            ApiEvent.CHAT_CLEAR_FLAGS -> parseChatClearFlags(eventType, event)
-            ApiEvent.CHAT_SET_FLAGS -> parseChatSetFlags(eventType, event)
-            ApiEvent.MESSAGES_DELETED -> parseMessagesDeleted(eventType, event)
-            ApiEvent.CHAT_MAJOR_CHANGED -> parseChatMajorChanged(eventType, event)
-            ApiEvent.CHAT_MINOR_CHANGED -> parseChatMinorChanged(eventType, event)
-
-            ApiEvent.TYPING,
-            ApiEvent.AUDIO_MESSAGE_RECORDING,
-            ApiEvent.PHOTO_UPLOADING,
-            ApiEvent.VIDEO_UPLOADING,
-            ApiEvent.FILE_UPLOADING -> parseInteraction(eventType, event)
-
-            ApiEvent.UNREAD_COUNT_UPDATE -> parseUnreadCounterUpdate(eventType, event)
-            ApiEvent.MESSAGE_UPDATED -> parseMessageUpdated(eventType, event)
-            ApiEvent.MESSAGE_CACHE_CLEAR -> parseMessageCacheClear(eventType, event)
-        }
-    }
-
-    private fun parseMessageSetFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val cmId = event[1].asLong()
-        val flags = event[2].asInt()
-        val peerId = event[3].asLong()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = MessageFlags.parse(flags)
-        parsedFlags.forEach { flag ->
-            when (flag) {
-                MessageFlags.IMPORTANT -> {
-                    val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
-                        peerId = peerId,
-                        cmId = cmId,
-                        marked = true
-                    )
-                    eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.MARKED_AS_IMPORTANT]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsImportant>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
-                }
-
-                MessageFlags.SPAM -> {
-                    val eventToSend = LongPollParsedEvent.MessageMarkedAsSpam(
-                        peerId = peerId,
-                        cmId = cmId
-                    )
-                    eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.MARKED_AS_SPAM]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsSpam>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
-                }
-
-                MessageFlags.DELETED -> {
-                    val eventToSend =
-                        if (parsedFlags.contains(MessageFlags.DELETED_FOR_ALL)) {
-                            LongPollParsedEvent.MessageDeleted(
-                                peerId = peerId,
-                                cmId = cmId,
-                                forAll = true
-                            )
-                        } else {
-                            LongPollParsedEvent.MessageDeleted(
-                                peerId = peerId,
-                                cmId = cmId,
-                                forAll = false
-                            )
-                        }
-                    eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.MESSAGE_DELETED]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageDeleted>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
-                }
-
-                MessageFlags.AUDIO_LISTENED -> {
-                    val eventToSend = LongPollParsedEvent.AudioMessageListened(
-                        peerId = peerId,
-                        cmId = cmId
-                    )
-                    eventsToSend += eventToSend
-
-                    listenersMap[LongPollEvent.AUDIO_MESSAGE_LISTENED]?.let { listeners ->
-                        listeners.map { vkEventCallback ->
-                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.AudioMessageListened>)
-                                ?.onEvent(eventToSend)
-                        }
-                    }
-                }
-
-                else -> Unit
-            }
-        }
-
-        eventsToSend.forEach { eventToSend ->
-            listenersMap[LongPollEvent.MESSAGE_SET_FLAGS]?.let { listeners ->
-                listeners.map { vkEventCallback ->
-                    (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(eventToSend)
-                }
-            }
-        }
-    }
-
-    private fun parseMessageClearFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val cmId = event[1].asLong()
-        val flags = event[2].asInt()
-        val peerId = event[3].asLong()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = MessageFlags.parse(flags)
-
-        coroutineScope.launch {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    MessageFlags.IMPORTANT -> {
-                        val eventToSend = LongPollParsedEvent.MessageMarkedAsImportant(
-                            peerId = peerId,
-                            cmId = cmId,
-                            marked = false
-                        )
-                        eventsToSend += eventToSend
-
-                        listenersMap[LongPollEvent.MARKED_AS_IMPORTANT]?.let { listeners ->
-                            listeners.map { vkEventCallback ->
-                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsImportant>)
-                                    ?.onEvent(eventToSend)
-                            }
-                        }
-                    }
-
-                    MessageFlags.SPAM -> {
-                        if (parsedFlags.contains(MessageFlags.CANCEL_SPAM)) {
-                            withContext(Dispatchers.IO) {
-                                val message = loadMessage(
-                                    peerId = peerId,
-                                    cmId = cmId
-                                )
-                                message?.let {
-                                    val eventToSend =
-                                        LongPollParsedEvent.MessageMarkedAsNotSpam(message = message)
-                                    eventsToSend += eventToSend
-
-                                    listenersMap[LongPollEvent.MARKED_AS_NOT_SPAM]?.let { listeners ->
-                                        listeners.map { vkEventCallback ->
-                                            (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageMarkedAsNotSpam>)
-                                                ?.onEvent(eventToSend)
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    MessageFlags.DELETED -> {
-                        withContext(Dispatchers.IO) {
-                            val message = loadMessage(
-                                peerId = peerId,
-                                cmId = cmId
-                            )
-                            message?.let {
-                                val eventToSend =
-                                    LongPollParsedEvent.MessageRestored(message = message)
-                                eventsToSend += eventToSend
-
-                                listenersMap[LongPollEvent.MESSAGE_RESTORED]?.let { listeners ->
-                                    listeners.map { vkEventCallback ->
-                                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent.MessageRestored>)
-                                            ?.onEvent(eventToSend)
-                                    }
-                                }
-                            }
-                        }
-                    }
-
-                    else -> Unit
-                }
-            }
-
-            eventsToSend.forEach { eventToSend ->
-                listenersMap[LongPollEvent.MESSAGE_CLEAR_FLAGS]?.let { listeners ->
-                    listeners.map { vkEventCallback ->
-                        vkEventCallback.onEvent(eventToSend)
-                    }
-                }
-            }
-        }
-    }
-
-    private fun parseMessageNew(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val cmId = event[1].asLong()
-        val peerId = event[4].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            val message =
-                async { loadMessage(peerId = peerId, cmId = cmId) }.await()
-
-            val convo =
-                async {
-                    loadConvo(
-                        peerId = peerId,
-                        extended = true,
-                        fields = VkConstants.ALL_FIELDS
-                    )
-                }.await()
-
-            message?.let {
-                listenersMap[LongPollEvent.MESSAGE_NEW]?.let {
-                    it.map { vkEventCallback ->
-                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.NewMessage>)
-                            .onEvent(
-                                LongPollParsedEvent.NewMessage(
-                                    message = message,
-                                    inArchive = convo?.isArchived == true
-                                    // TODO: 03-Apr-25, Danil Nikolaev:
-                                    // load user settings about restoring chats with
-                                    // enabled notifications from archive
-                                )
-                            )
-                    }
-                }
-            }
-        }
-    }
-
-    private fun parseMessageEdit(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val cmId = event[1].asLong()
-        val peerId = event[3].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            loadMessage(
-                peerId = peerId,
-                cmId = cmId
-            )?.let { message ->
-                listenersMap[LongPollEvent.MESSAGE_EDITED]?.let {
-                    it.map { vkEventCallback ->
-                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.MessageEdited>)
-                            .onEvent(LongPollParsedEvent.MessageEdited(message))
-                    }
-                }
-            }
-        }
-    }
-
-    private fun parseMessageReadIncoming(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-        val peerId = event[1].asLong()
-        val cmId = event[2].asLong()
-        val unreadCount = event[3].asInt()
-
-        listenersMap[LongPollEvent.INCOMING_MESSAGE_READ]?.let { listeners ->
-            listeners.map { vkEventCallback ->
-                (vkEventCallback as VkEventCallback<LongPollParsedEvent.IncomingMessageRead>)
-                    .onEvent(
-                        LongPollParsedEvent.IncomingMessageRead(
-                            peerId = peerId,
-                            cmId = cmId,
-                            unreadCount = unreadCount
-                        )
-                    )
-            }
-        }
-    }
-
-    private fun parseMessageReadOutgoing(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-        val peerId = event[1].asLong()
-        val cmId = event[2].asLong()
-        val unreadCount = event[3].asInt()
-
-        listenersMap[LongPollEvent.OUTGOING_MESSAGE_READ]?.let { listeners ->
-            listeners.map { vkEventCallback ->
-                (vkEventCallback as VkEventCallback<LongPollParsedEvent.OutgoingMessageRead>)
-                    .onEvent(
-                        LongPollParsedEvent.OutgoingMessageRead(
-                            peerId = peerId,
-                            cmId = cmId,
-                            unreadCount = unreadCount
-                        )
-                    )
-            }
-        }
-    }
-
-    private fun parseChatClearFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val peerId = event[1].asLong()
-        val flags = event[2].asInt()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = ConvoFlags.parse(flags)
-
-        coroutineScope.launch(Dispatchers.IO) {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    ConvoFlags.ARCHIVED -> {
-                        val convo = loadConvo(
-                            peerId = peerId,
-                            extended = true,
-                            fields = VkConstants.ALL_FIELDS
-                        ) ?: return@forEach
-
-                        val message = loadMessage(
-                            peerId = peerId,
-                            cmId = convo.lastCmId
-                        )
-
-                        val eventToSend = LongPollParsedEvent.ChatArchived(
-                            convo = convo.copy(lastMessage = message),
-                            archived = false
-                        )
-                        eventsToSend += eventToSend
-
-                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.let { listeners ->
-                            listeners.map { vkEventCallback ->
-                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.ChatArchived>)
-                                    ?.onEvent(eventToSend)
-                            }
-                        }
-                    }
-
-                    else -> Unit
-                }
-            }
-
-            eventsToSend.forEach { eventToSend ->
-                listenersMap[LongPollEvent.CHAT_CLEAR_FLAGS]?.let { listeners ->
-                    listeners.map { vkEventCallback ->
-                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(
-                            eventToSend
-                        )
-                    }
-                }
-            }
-        }
-    }
-
-    private fun parseChatSetFlags(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val peerId = event[1].asLong()
-        val flags = event[2].asInt()
-
-        val eventsToSend = mutableListOf<LongPollParsedEvent>()
-
-        val parsedFlags = ConvoFlags.parse(flags)
-
-        coroutineScope.launch(Dispatchers.IO) {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    ConvoFlags.ARCHIVED -> {
-                        val convo = loadConvo(
-                            peerId = peerId,
-                            extended = true,
-                            fields = VkConstants.ALL_FIELDS
-                        ) ?: return@forEach
-
-                        val message = loadMessage(
-                            peerId = peerId,
-                            cmId = convo.lastCmId
-                        )
-
-                        val eventToSend = LongPollParsedEvent.ChatArchived(
-                            convo = convo.copy(lastMessage = message),
-                            archived = true
-                        )
-                        eventsToSend += eventToSend
-
-                        listenersMap[LongPollEvent.CHAT_ARCHIVED]?.let { listeners ->
-                            listeners.map { vkEventCallback ->
-                                (vkEventCallback as? VkEventCallback<LongPollParsedEvent.ChatArchived>)
-                                    ?.onEvent(eventToSend)
-                            }
-                        }
-                    }
-
-                    else -> Unit
-                }
-            }
-
-            eventsToSend.forEach { eventToSend ->
-                listenersMap[LongPollEvent.CHAT_SET_FLAGS]?.let { listeners ->
-                    listeners.map { vkEventCallback ->
-                        (vkEventCallback as? VkEventCallback<LongPollParsedEvent>)?.onEvent(
-                            eventToSend
-                        )
-                    }
-                }
-            }
-        }
-    }
-
-    private fun parseMessagesDeleted(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val peerId = event[1].asLong()
-        val cmId = event[2].asLong()
-
-        listenersMap[LongPollEvent.CHAT_CLEARED]?.let { listeners ->
-            listeners.forEach { vkEventCallback ->
-                (vkEventCallback as VkEventCallback<LongPollParsedEvent.ChatCleared>)
-                    .onEvent(
-                        LongPollParsedEvent.ChatCleared(
-                            peerId = peerId,
-                            toCmId = cmId
-                        )
-                    )
-            }
-        }
-    }
-
-    private fun parseChatMajorChanged(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val peerId = event[1].asLong()
-        val majorId = event[2].asInt()
-
-        listenersMap[LongPollEvent.CHAT_MAJOR_CHANGED]?.let { listeners ->
-            listeners.forEach { vkEventCallback ->
-                (vkEventCallback as VkEventCallback<LongPollParsedEvent.ChatMajorChanged>)
-                    .onEvent(
-                        LongPollParsedEvent.ChatMajorChanged(
-                            peerId = peerId,
-                            majorId = majorId,
-                        )
-                    )
-            }
-        }
-    }
-
-    private fun parseChatMinorChanged(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val peerId = event[1].asLong()
-        val minorId = event[2].asInt()
-
-        listenersMap[LongPollEvent.CHAT_MINOR_CHANGED]?.let { listeners ->
-            listeners.forEach { vkEventCallback ->
-                (vkEventCallback as VkEventCallback<LongPollParsedEvent.ChatMinorChanged>)
-                    .onEvent(
-                        LongPollParsedEvent.ChatMinorChanged(
-                            peerId = peerId,
-                            minorId = minorId,
-                        )
-                    )
-            }
-        }
-    }
-
-    private fun parseInteraction(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType: $event")
-
-        val interactionType = when (eventType) {
-            ApiEvent.TYPING -> InteractionType.Typing
-            ApiEvent.AUDIO_MESSAGE_RECORDING -> InteractionType.VoiceMessage
-            ApiEvent.PHOTO_UPLOADING -> InteractionType.Photo
-            ApiEvent.VIDEO_UPLOADING -> InteractionType.Video
-            ApiEvent.FILE_UPLOADING -> InteractionType.File
-            else -> return
-        }
-
-        val longPollEvent: LongPollEvent = when (eventType) {
-            ApiEvent.TYPING -> LongPollEvent.TYPING
-            ApiEvent.AUDIO_MESSAGE_RECORDING -> LongPollEvent.AUDIO_MESSAGE_RECORDING
-            ApiEvent.PHOTO_UPLOADING -> LongPollEvent.PHOTO_UPLOADING
-            ApiEvent.VIDEO_UPLOADING -> LongPollEvent.VIDEO_UPLOADING
-            ApiEvent.FILE_UPLOADING -> LongPollEvent.FILE_UPLOADING
-            else -> return
-        }
-
-        val peerId = event[1].asLong()
-        val userIds = event[2].toList(Any::asLong).filter { it != UserConfig.userId }
-        val totalCount = event[3].asInt()
-        val timestamp = event[4].asInt()
-
-        // if userIds contains only account's id, then we don't need to show our status
-        if (userIds.isEmpty()) return
-
-        listenersMap[longPollEvent]?.let { listeners ->
-            listeners.forEach { vkEventCallback ->
-                (vkEventCallback as VkEventCallback<LongPollParsedEvent.Interaction>)
-                    .onEvent(
-                        LongPollParsedEvent.Interaction(
-                            interactionType = interactionType,
-                            peerId = peerId,
-                            userIds = userIds,
-                            totalCount = totalCount,
-                            timestamp = timestamp
-                        )
-                    )
-            }
-        }
-    }
-
-    private fun parseUnreadCounterUpdate(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType $event")
-
-        val unreadCount = event[1].asInt()
-        val unreadUnmutedCount = event[2].asInt()
-        val showOnlyMuted = event[3].asInt() == 1
-        val businessNotifyUnreadCount = event[4].asInt()
-        val archiveUnreadCount = event[7].asInt()
-        val archiveUnreadUnmutedCount = event[8].asInt()
-        val archiveMentionsCount = event[9].asInt()
-
-        listenersMap[LongPollEvent.UNREAD_COUNTER_UPDATE]?.let { listeners ->
-            listeners.forEach { vkEventCallback ->
-                (vkEventCallback as VkEventCallback<LongPollParsedEvent.UnreadCounter>)
-                    .onEvent(
-                        LongPollParsedEvent.UnreadCounter(
-                            unread = unreadCount,
-                            unreadUnmuted = unreadUnmutedCount,
-                            showOnlyMuted = showOnlyMuted,
-                            business = businessNotifyUnreadCount,
-                            archive = archiveUnreadCount,
-                            archiveUnmuted = archiveUnreadUnmutedCount,
-                            archiveMentions = archiveMentionsCount
-                        )
-                    )
-            }
-        }
-    }
-
-    private fun parseMessageUpdated(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType $event")
-
-        val cmId = event[1].asLong()
-        val peerId = event[4].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            loadMessage(
-                peerId = peerId,
-                cmId = cmId
-            )?.let { message ->
-                listenersMap[LongPollEvent.MESSAGE_UPDATED]?.let {
-                    it.map { vkEventCallback ->
-                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.MessageUpdated>)
-                            .onEvent(LongPollParsedEvent.MessageUpdated(message))
-                    }
-                }
-            }
-        }
-    }
-
-    private fun parseMessageCacheClear(eventType: ApiEvent, event: List<Any>) {
-        Log.d("LongPollUpdatesParser", "$eventType $event")
-
-        val messageId = event[1].asLong()
-
-        coroutineScope.launch(Dispatchers.IO) {
-            loadMessage(messageId = messageId)?.let { message ->
-                listenersMap[LongPollEvent.MESSAGE_CACHE_CLEAR]?.let {
-                    it.map { vkEventCallback ->
-                        (vkEventCallback as VkEventCallback<LongPollParsedEvent.MessageCacheClear>)
-                            .onEvent(LongPollParsedEvent.MessageCacheClear(message))
-                    }
-                }
-            }
-        }
-    }
-
-    private suspend fun loadMessage(
-        peerId: Long? = null,
-        cmId: Long? = null,
-        messageId: Long? = null
-    ): VkMessage? = suspendCoroutine { continuation ->
-        require((peerId != null && cmId != null) || messageId != null)
-
-        coroutineScope.launch(Dispatchers.IO) {
-            messagesUseCase.getById(
-                peerCmIds = null,
-                peerId = peerId,
-                messageIds = messageId?.let(::listOf),
-                cmIds = cmId?.let(::listOf),
-                extended = true,
-                fields = VkConstants.ALL_FIELDS
-            ).listenValue(this) { state ->
-                state.processState(
-                    error = { error ->
-                        Log.e("LongPollUpdatesParser", "loadMessage: error: $error")
-                        continuation.resume(null)
-                    },
-                    success = { response ->
-                        val message = response.singleOrNull() ?: run {
-                            continuation.resume(null)
-                            return@listenValue
-                        }
-
-                        continuation.resume(message)
-                    }
-                )
-            }
-        }
-    }
-
-    private suspend fun loadConvo(
-        peerId: Long,
-        extended: Boolean = false,
-        fields: String? = null
-    ): VkConvo? = suspendCoroutine { continuation ->
-        coroutineScope.launch(Dispatchers.IO) {
-            convoUseCase.getById(
-                peerIds = listOf(peerId),
-                extended = extended,
-                fields = fields
-            ).listenValue(coroutineScope) { state ->
-                state.processState(
-                    error = { error ->
-                        Log.e("LongPollUpdatesParser", "loadConvo: error: $error")
-                        continuation.resume(null)
-                    },
-                    success = { response ->
-                        val convo = response.singleOrNull() ?: run {
-                            continuation.resume(null)
-                            return@listenValue
-                        }
-
-                        continuation.resume(convo)
-                    }
-                )
-            }
-        }
-    }
-
-    @Suppress("UNCHECKED_CAST")
-    private fun <T : LongPollParsedEvent> registerListener(
-        eventType: LongPollEvent,
-        listener: VkEventCallback<T>
-    ) {
-        listenersMap.let { map ->
-            map[eventType] = (map[eventType] ?: mutableListOf())
-                .also {
-                    it.add(listener as VkEventCallback<LongPollParsedEvent>)
-                }
-        }
-    }
-
-    private fun <T : LongPollParsedEvent> registerListeners(
-        eventTypes: List<LongPollEvent>,
-        listener: VkEventCallback<T>
-    ) {
-        eventTypes.forEach { eventType -> registerListener(eventType, listener) }
+        eventParser.parseNextUpdate(event)
     }
 
     fun onMessageSetFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_SET_FLAGS, assembleEventCallback(block))
     }
 
     fun onMessageMarkedAsImportant(block: (LongPollParsedEvent.MessageMarkedAsImportant) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_IMPORTANT, assembleEventCallback(block))
     }
 
     fun onMessageMarkedAsSpam(block: (LongPollParsedEvent.MessageMarkedAsSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_SPAM, assembleEventCallback(block))
     }
 
     fun onMessageDeleted(block: (LongPollParsedEvent.MessageDeleted) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_DELETED, assembleEventCallback(block))
     }
 
     fun onMessageClearFlags(block: (LongPollParsedEvent) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_CLEAR_FLAGS, assembleEventCallback(block))
     }
 
     fun onMessageMarkedAsNotSpam(block: (LongPollParsedEvent.MessageMarkedAsNotSpam) -> Unit) {
-        registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MARKED_AS_NOT_SPAM, assembleEventCallback(block))
     }
 
     fun onMessageRestored(block: (LongPollParsedEvent.MessageRestored) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_RESTORED, assembleEventCallback(block))
+    }
+
+    fun onMessageUpdated(block: (LongPollParsedEvent.MessageUpdated) -> Unit) {
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_UPDATED, assembleEventCallback(block))
+    }
+
+    fun onMessageCacheClear(block: (LongPollParsedEvent.MessageCacheClear) -> Unit) {
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_CACHE_CLEAR, assembleEventCallback(block))
     }
 
     fun onNewMessage(block: (LongPollParsedEvent.NewMessage) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_NEW, assembleEventCallback(block))
     }
 
     fun onMessageEdited(block: (LongPollParsedEvent.MessageEdited) -> Unit) {
-        registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.MESSAGE_EDITED, assembleEventCallback(block))
     }
 
     fun onMessageIncomingRead(block: (LongPollParsedEvent.IncomingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.INCOMING_MESSAGE_READ, assembleEventCallback(block))
     }
 
     fun onMessageOutgoingRead(block: (LongPollParsedEvent.OutgoingMessageRead) -> Unit) {
-        registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.OUTGOING_MESSAGE_READ, assembleEventCallback(block))
     }
 
     fun onChatCleared(block: (LongPollParsedEvent.ChatCleared) -> Unit) {
-        registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_CLEARED, assembleEventCallback(block))
     }
 
     fun onChatMajorChanged(block: (LongPollParsedEvent.ChatMajorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_MAJOR_CHANGED, assembleEventCallback(block))
     }
 
     fun onChatMinorChanged(block: (LongPollParsedEvent.ChatMinorChanged) -> Unit) {
-        registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_MINOR_CHANGED, assembleEventCallback(block))
     }
 
     fun onChatArchived(block: (LongPollParsedEvent.ChatArchived) -> Unit) {
-        registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
+        eventDispatcher.registerListener(LongPollEvent.CHAT_ARCHIVED, assembleEventCallback(block))
     }
 
     fun onInteractions(block: (LongPollParsedEvent.Interaction) -> Unit) {
-        registerListeners(
+        eventDispatcher.registerListeners(
             eventTypes = listOf(
                 LongPollEvent.TYPING,
                 LongPollEvent.AUDIO_MESSAGE_RECORDING,

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollUpdatesReducer.kt

@@ -0,0 +1,213 @@
+package dev.meloda.fast.domain
+
+import android.util.Log
+import dev.meloda.fast.model.LongPollParsedEvent
+import dev.meloda.fast.model.api.domain.VkMessage
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.filterIsInstance
+import kotlinx.coroutines.launch
+
+class LongPollUpdatesReducer(
+    updatesParser: LongPollUpdatesParser,
+    private val messagesUseCase: MessagesUseCase,
+    private val convoUseCase: ConvoUseCase
+) {
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.Default)
+
+    private val _events = MutableSharedFlow<LongPollParsedEvent>(extraBufferCapacity = 256)
+    val events: SharedFlow<LongPollParsedEvent> = _events.asSharedFlow()
+
+    val newMessages = events.filterIsInstance<LongPollParsedEvent.NewMessage>()
+    val messageEdited = events.filterIsInstance<LongPollParsedEvent.MessageEdited>()
+    val messageIncomingRead = events.filterIsInstance<LongPollParsedEvent.IncomingMessageRead>()
+    val messageOutgoingRead = events.filterIsInstance<LongPollParsedEvent.OutgoingMessageRead>()
+    val messageDeleted = events.filterIsInstance<LongPollParsedEvent.MessageDeleted>()
+    val messageRestored = events.filterIsInstance<LongPollParsedEvent.MessageRestored>()
+    val messageMarkedAsImportant = events.filterIsInstance<LongPollParsedEvent.MessageMarkedAsImportant>()
+    val messageMarkedAsSpam = events.filterIsInstance<LongPollParsedEvent.MessageMarkedAsSpam>()
+    val messageMarkedAsNotSpam = events.filterIsInstance<LongPollParsedEvent.MessageMarkedAsNotSpam>()
+    val interactions = events.filterIsInstance<LongPollParsedEvent.Interaction>()
+    val chatMajorChanged = events.filterIsInstance<LongPollParsedEvent.ChatMajorChanged>()
+    val chatMinorChanged = events.filterIsInstance<LongPollParsedEvent.ChatMinorChanged>()
+    val chatCleared = events.filterIsInstance<LongPollParsedEvent.ChatCleared>()
+    val chatArchived = events.filterIsInstance<LongPollParsedEvent.ChatArchived>()
+    val messageUpdated = events.filterIsInstance<LongPollParsedEvent.MessageUpdated>()
+    val messageCacheClear = events.filterIsInstance<LongPollParsedEvent.MessageCacheClear>()
+
+    init {
+        updatesParser.onNewMessage { publish(it) }
+        updatesParser.onMessageEdited { publish(it) }
+        updatesParser.onMessageIncomingRead { publish(it) }
+        updatesParser.onMessageOutgoingRead { publish(it) }
+        updatesParser.onMessageDeleted { publish(it) }
+        updatesParser.onMessageRestored { publish(it) }
+        updatesParser.onMessageUpdated { publish(it) }
+        updatesParser.onMessageCacheClear { publish(it) }
+        updatesParser.onMessageMarkedAsImportant { publish(it) }
+        updatesParser.onMessageMarkedAsSpam { publish(it) }
+        updatesParser.onMessageMarkedAsNotSpam { publish(it) }
+        updatesParser.onInteractions { publish(it) }
+        updatesParser.onChatMajorChanged { publish(it) }
+        updatesParser.onChatMinorChanged { publish(it) }
+        updatesParser.onChatCleared { publish(it) }
+        updatesParser.onChatArchived { publish(it) }
+    }
+
+    private fun publish(event: LongPollParsedEvent) {
+        scope.launch {
+            runCatching { applyCommon(event) }
+                .onFailure { throwable ->
+                    Log.e("LongPollUpdatesReducer", "applyCommon failed: $event", throwable)
+                }
+            _events.emit(event)
+        }
+    }
+
+    private suspend fun applyCommon(event: LongPollParsedEvent) {
+        when (event) {
+            is LongPollParsedEvent.NewMessage -> {
+                messagesUseCase.storeMessages(listOf(event.message))
+                updateConvoForMessage(event.message, unreadIncrement = if (event.message.isOut) 0 else 1)
+            }
+
+            is LongPollParsedEvent.MessageEdited -> {
+                messagesUseCase.storeMessage(event.message)
+            }
+
+            is LongPollParsedEvent.MessageUpdated -> {
+                messagesUseCase.storeMessage(event.message)
+            }
+
+            is LongPollParsedEvent.MessageCacheClear -> {
+                messagesUseCase.storeMessage(event.message)
+            }
+
+            is LongPollParsedEvent.IncomingMessageRead -> {
+                updateConvoReadState(
+                    peerId = event.peerId,
+                    inReadCmId = event.cmId,
+                    unreadCount = event.unreadCount
+                )
+            }
+
+            is LongPollParsedEvent.OutgoingMessageRead -> {
+                updateConvoReadState(
+                    peerId = event.peerId,
+                    outReadCmId = event.cmId,
+                    unreadCount = event.unreadCount
+                )
+            }
+
+            is LongPollParsedEvent.MessageDeleted -> {
+                val message = messagesUseCase.getLocalMessageByConvoMessageId(
+                    convoId = event.peerId,
+                    cmId = event.cmId
+                )
+                if (message != null) {
+                    messagesUseCase.deleteLocalMessages(listOf(message.id))
+                }
+            }
+
+            is LongPollParsedEvent.MessageRestored -> {
+                messagesUseCase.storeMessage(event.message)
+            }
+
+            is LongPollParsedEvent.MessageMarkedAsImportant -> {
+                val message = messagesUseCase.getLocalMessageByConvoMessageId(
+                    convoId = event.peerId,
+                    cmId = event.cmId
+                ) ?: return
+
+                messagesUseCase.storeMessage(message.copy(isImportant = event.marked))
+            }
+
+            is LongPollParsedEvent.MessageMarkedAsSpam -> {
+                val message = messagesUseCase.getLocalMessageByConvoMessageId(
+                    convoId = event.peerId,
+                    cmId = event.cmId
+                )
+                if (message != null) {
+                    messagesUseCase.deleteLocalMessages(listOf(message.id))
+                }
+            }
+
+            is LongPollParsedEvent.MessageMarkedAsNotSpam -> {
+                messagesUseCase.storeMessage(event.message)
+            }
+
+            is LongPollParsedEvent.ChatMajorChanged -> {
+                updateConvoSortState(event.peerId, majorId = event.majorId)
+            }
+
+            is LongPollParsedEvent.ChatMinorChanged -> {
+                updateConvoSortState(event.peerId, minorId = event.minorId)
+            }
+
+            is LongPollParsedEvent.ChatCleared -> {
+                convoUseCase.deleteLocalConvo(event.peerId)
+            }
+
+            is LongPollParsedEvent.ChatArchived -> {
+                event.convo.lastMessage?.let(messagesUseCase::storeMessage)
+                convoUseCase.storeConvos(listOf(event.convo.copy(isArchived = event.archived)))
+            }
+
+            is LongPollParsedEvent.Interaction -> Unit
+        }
+    }
+
+    private suspend fun updateConvoReadState(
+        peerId: Long,
+        inReadCmId: Long? = null,
+        outReadCmId: Long? = null,
+        unreadCount: Int
+    ) {
+        val convo = convoUseCase.getLocalConvoById(peerId) ?: return
+        convoUseCase.storeConvos(
+            listOf(
+                convo.copy(
+                    inReadCmId = inReadCmId ?: convo.inReadCmId,
+                    outReadCmId = outReadCmId ?: convo.outReadCmId,
+                    unreadCount = unreadCount
+                )
+            )
+        )
+    }
+
+    private suspend fun updateConvoSortState(
+        peerId: Long,
+        majorId: Int? = null,
+        minorId: Int? = null
+    ) {
+        val convo = convoUseCase.getLocalConvoById(peerId) ?: return
+        convoUseCase.storeConvos(
+            listOf(
+                convo.copy(
+                    majorId = majorId ?: convo.majorId,
+                    minorId = minorId ?: convo.minorId
+                )
+            )
+        )
+    }
+
+    private suspend fun updateConvoForMessage(
+        message: VkMessage,
+        unreadIncrement: Int
+    ) {
+        val convo = convoUseCase.getLocalConvoById(message.peerId) ?: return
+        convoUseCase.storeConvos(
+            listOf(
+                convo.copy(
+                    lastMessageId = message.id,
+                    lastCmId = message.cmId,
+                    unreadCount = convo.unreadCount + unreadIncrement
+                )
+            )
+        )
+    }
+}

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollUseCase.kt

@@ -1,6 +1,7 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
+import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.LongPollUpdates
 import dev.meloda.fast.model.api.data.VkLongPollData
 import kotlinx.coroutines.flow.Flow
@@ -21,4 +22,14 @@ interface LongPollUseCase {
         mode: Int,
         version: Int
     ): Flow<State<LongPollUpdates>>
+
+    fun getLongPollHistory(
+        ts: Int,
+        pts: Int,
+        lpVersion: Int,
+        lastN: Int? = null,
+        maxMsgId: Long? = null,
+        eventsLimit: Int? = null,
+        msgsLimit: Int? = null
+    ): Flow<State<LongPollHistoryResponse>>
 }

core/domain/src/main/kotlin/dev/meloda/fast/domain/LongPollUseCaseImpl.kt

@@ -3,6 +3,7 @@ package dev.meloda.fast.domain
 import dev.meloda.fast.data.State
 import dev.meloda.fast.data.api.longpoll.LongPollRepository
 import dev.meloda.fast.data.mapToState
+import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.LongPollUpdates
 import dev.meloda.fast.model.api.data.VkLongPollData
 import kotlinx.coroutines.flow.Flow
@@ -48,4 +49,27 @@ class LongPollUseCaseImpl(
         ).mapToState()
         emit(newState)
     }
+
+    override fun getLongPollHistory(
+        ts: Int,
+        pts: Int,
+        lpVersion: Int,
+        lastN: Int?,
+        maxMsgId: Long?,
+        eventsLimit: Int?,
+        msgsLimit: Int?
+    ): Flow<State<LongPollHistoryResponse>> = flow {
+        emit(State.Loading)
+
+        val newState = repository.getLongPollHistory(
+            ts = ts,
+            pts = pts,
+            lpVersion = lpVersion,
+            lastN = lastN,
+            maxMsgId = maxMsgId,
+            eventsLimit = eventsLimit,
+            msgsLimit = msgsLimit
+        ).mapToState()
+        emit(newState)
+    }
 }

core/domain/src/main/kotlin/dev/meloda/fast/domain/MessagesUseCase.kt

@@ -12,6 +12,11 @@ interface MessagesUseCase : BaseUseCase {
 
     suspend fun storeMessage(message: VkMessage)
     suspend fun storeMessages(messages: List<VkMessage>)
+    suspend fun getLocalMessages(convoId: Long): List<VkMessage>
+    suspend fun getLocalMessageById(messageId: Long): VkMessage?
+    suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage?
+    suspend fun getLocalMaxMessageId(): Long?
+    suspend fun deleteLocalMessages(messageIds: List<Long>)
 
     fun getMessagesHistory(
         convoId: Long,

core/domain/src/main/kotlin/dev/meloda/fast/domain/MessagesUseCaseImpl.kt

@@ -22,6 +22,26 @@ class MessagesUseCaseImpl(
         repository.storeMessages(messages)
     }
 
+    override suspend fun getLocalMessages(convoId: Long): List<VkMessage> {
+        return repository.getLocalMessages(convoId)
+    }
+
+    override suspend fun getLocalMessageById(messageId: Long): VkMessage? {
+        return repository.getLocalMessageById(messageId)
+    }
+
+    override suspend fun getLocalMessageByConvoMessageId(convoId: Long, cmId: Long): VkMessage? {
+        return repository.getLocalMessageByConvoMessageId(convoId, cmId)
+    }
+
+    override suspend fun getLocalMaxMessageId(): Long? {
+        return repository.getLocalMaxMessageId()
+    }
+
+    override suspend fun deleteLocalMessages(messageIds: List<Long>) {
+        repository.deleteLocalMessages(messageIds)
+    }
+
     override fun getMessagesHistory(
         convoId: Long,
         count: Int?,

core/domain/src/main/kotlin/dev/meloda/fast/domain/OAuthUseCase.kt

@@ -21,7 +21,8 @@ interface OAuthUseCase {
         password: String,
         forceSms: Boolean,
         validationCode: String?,
-        captchaSid: String?,
-        captchaKey: String?
+        captchaSid: String? = null,
+        captchaKey: String? = null,
+        successToken: String? = null
     ): Flow<State<GetSilentTokenResponse>>
 }

core/domain/src/main/kotlin/dev/meloda/fast/domain/OAuthUseCaseImpl.kt

@@ -22,22 +22,35 @@ class OAuthUseCaseImpl(
     ): Flow<State<AuthInfo>> = flow {
         emit(State.Loading)
 
-        val newState = oAuthRepository.auth(
+        val newState = when (val authResult = oAuthRepository.auth(
             login = login,
             password = password,
             forceSms = forceSms,
             validationCode = validationCode,
             captchaSid = captchaSid,
             captchaKey = captchaKey
-        ).asState(
-            successMapper = {
+        )) {
+            is com.slack.eithernet.ApiResult.Success -> {
+                val value = authResult.value
+                val userId = value.userId
+                val accessToken = value.accessToken
+                val validationHash = value.validationHash
+
+                if (userId == null || accessToken == null || validationHash == null) {
+                    State.Error.InternalError
+                } else {
+                    State.Success(
                         AuthInfo(
-                    userId = it.userId!!,
-                    accessToken = it.accessToken!!,
-                    validationHash = it.validationHash!!
+                            userId = userId,
+                            accessToken = accessToken,
+                            validationHash = validationHash
+                        )
                     )
                 }
-        )
+            }
+
+            else -> authResult.asState()
+        }
 
         emit(newState)
     }
@@ -48,7 +61,8 @@ class OAuthUseCaseImpl(
         forceSms: Boolean,
         validationCode: String?,
         captchaSid: String?,
-        captchaKey: String?
+        captchaKey: String?,
+        successToken: String?
     ): Flow<State<GetSilentTokenResponse>> = flow {
         emit(State.Loading)
 
@@ -58,7 +72,8 @@ class OAuthUseCaseImpl(
             forceSms = forceSms,
             validationCode = validationCode,
             captchaSid = captchaSid,
-            captchaKey = captchaKey
+            captchaKey = captchaKey,
+            successToken = successToken
         ).asState()
 
         emit(newState)

core/domain/src/main/kotlin/dev/meloda/fast/domain/util/ConvoUiMapper.kt

@@ -27,6 +27,8 @@ fun VkConvo.asPresentation(
         monthShort = { resources.getString(R.string.month_short) },
         weekShort = { resources.getString(R.string.week_short) },
         dayShort = { resources.getString(R.string.day_short) },
+        minuteShort = { resources.getString(R.string.minute_short) },
+        secondShort = { resources.getString(R.string.second_short) },
         now = { resources.getString(R.string.time_now) },
     ),
     message = extractMessage(resources, lastMessage, id, peerType),

core/model/src/main/kotlin/dev/meloda/fast/model/api/data/LongPollHistoryResponse.kt

@@ -0,0 +1,24 @@
+package dev.meloda.fast.model.api.data
+
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
+
+@JsonClass(generateAdapter = true)
+data class LongPollHistoryResponse(
+    @Json(name = "history") val history: List<List<Any>>? = null,
+    @Json(name = "messages") val messages: Messages? = null,
+    @Json(name = "profiles") val profiles: List<VkUserData>? = null,
+    @Json(name = "groups") val groups: List<VkGroupData>? = null,
+    @Json(name = "new_pts") val newPts: Int? = null,
+    @Json(name = "from_pts") val fromPts: Int? = null,
+    @Json(name = "ts") val ts: Int? = null,
+    @Json(name = "pts") val pts: Int? = null,
+    @Json(name = "more") val more: Int? = null,
+    @Json(name = "conversations") val conversations: List<VkConvoData>? = null
+) {
+    @JsonClass(generateAdapter = true)
+    data class Messages(
+        @Json(name = "count") val count: Int? = null,
+        @Json(name = "items") val items: List<VkMessageData>? = null
+    )
+}

core/model/src/main/kotlin/dev/meloda/fast/model/api/data/VkWidgetData.kt

@@ -5,7 +5,7 @@ import com.squareup.moshi.JsonClass
 
 @JsonClass(generateAdapter = true)
 data class VkWidgetData(
-    val id: Long
+    val id: Long?
 ) : VkAttachmentData {
 
     fun toDomain() = VkWidgetDomain(id)

core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkAttachment.kt

@@ -1,7 +1,9 @@
 package dev.meloda.fast.model.api.domain
 
+import androidx.compose.runtime.Immutable
 import dev.meloda.fast.model.api.data.AttachmentType
 
+@Immutable
 interface VkAttachment {
     val type: AttachmentType
 }

core/model/src/main/kotlin/dev/meloda/fast/model/api/domain/VkWidgetDomain.kt

@@ -3,7 +3,7 @@ package dev.meloda.fast.model.api.domain
 import dev.meloda.fast.model.api.data.AttachmentType
 
 data class VkWidgetDomain(
-    val id: Long
+    val id: Long?
 ) : VkAttachment {
 
     override val type: AttachmentType = AttachmentType.WIDGET

core/model/src/main/kotlin/dev/meloda/fast/model/api/requests/LongPollRequests.kt

@@ -19,3 +19,27 @@ data class LongPollGetUpdatesRequest(
             "version" to version.toString()
         )
 }
+
+data class LongPollGetHistoryRequest(
+    val ts: Int,
+    val pts: Int,
+    val lpVersion: Int,
+    val lastN: Int? = null,
+    val maxMsgId: Long? = null,
+    val eventsLimit: Int? = null,
+    val msgsLimit: Int? = null,
+    val extended: Boolean = true,
+) {
+    val map: Map<String, String>
+        get() = mutableMapOf(
+            "ts" to ts.toString(),
+            "pts" to pts.toString(),
+            "lp_version" to lpVersion.toString(),
+            "extended" to if (extended) "1" else "0",
+        ).apply {
+            lastN?.let { this["last_n"] = it.toString() }
+            maxMsgId?.let { this["max_msg_id"] = it.toString() }
+            eventsLimit?.let { this["events_limit"] = it.toString() }
+            msgsLimit?.let { this["msgs_limit"] = it.toString() }
+        }
+}

core/model/src/main/kotlin/dev/meloda/fast/model/api/requests/OAuthRequest.kt

@@ -12,7 +12,8 @@ data class AuthDirectRequest(
     val validationCode: String? = null,
     val captchaSid: String? = null,
     val captchaKey: String? = null,
-    val trustedHash: String? = null
+    val trustedHash: String? = null,
+    val successToken: String? = null
 ) {
 
     val map
@@ -31,6 +32,7 @@ data class AuthDirectRequest(
                 captchaSid?.let { this["captcha_sid"] = it }
                 captchaKey?.let { this["captcha_key"] = it }
                 trustedHash?.let { this["trusted_hash"] = it }
+                successToken?.let { this["success_token"] = it }
             }
 }
 

core/network/src/main/kotlin/dev/meloda/fast/network/OAuthErrorDomain.kt

@@ -16,7 +16,8 @@ sealed class OAuthErrorDomain {
 
     data class CaptchaRequiredError(
         val captchaSid: String,
-        val captchaImageUrl: String
+        val captchaImageUrl: String,
+        val redirectUri: String?
     ) : OAuthErrorDomain()
 
     data class UserBannedError(

core/network/src/main/kotlin/dev/meloda/fast/network/ResponseConverterFactory.kt

@@ -53,6 +53,7 @@ class ResponseConverterFactory(private val converter: JsonConverter) : Converter
                 },
                 onFailure = { failure ->
                     if (failure is JsonDataException) {
+                        Log.d("ResponseBodyConverter", "convertJsonDataException: $failure")
                         throw ApiException(
                             RestApiError(
                                 errorCode = -1,

core/network/src/main/kotlin/dev/meloda/fast/network/ValidationType.kt

@@ -2,7 +2,8 @@ package dev.meloda.fast.network
 
 enum class ValidationType(val value: String) {
     APP("2fa_app"),
-    SMS("2fa_sms");
+    SMS("sms"),
+    SMS2("2fa_sms");
 
     companion object {
         fun parse(value: String): ValidationType =

core/network/src/main/kotlin/dev/meloda/fast/network/di/NetworkModule.kt

@@ -11,6 +11,7 @@ import dev.meloda.fast.network.JsonConverter
 import dev.meloda.fast.network.MoshiConverter
 import dev.meloda.fast.network.OAuthResultCallFactory
 import dev.meloda.fast.network.ResponseConverterFactory
+import dev.meloda.fast.network.interceptor.Error14HandlingInterceptor
 import dev.meloda.fast.network.interceptor.LanguageInterceptor
 import dev.meloda.fast.network.interceptor.VersionInterceptor
 import dev.meloda.fast.network.service.account.AccountService
@@ -45,6 +46,7 @@ val networkModule = module {
     single { ChuckerInterceptor.Builder(get()).collector(get()).build() }
     singleOf(::VersionInterceptor)
     singleOf(::LanguageInterceptor)
+    singleOf(::Error14HandlingInterceptor)
 
     single<OkHttpClient>(named("auth")) {
         buildHttpClient(true)
@@ -101,6 +103,7 @@ private fun Scope.buildHttpClient(forAuth: Boolean): OkHttpClient {
                 addInterceptor(get(named("token_interceptor")) as Interceptor)
             }
         }
+        .addInterceptor(get<Error14HandlingInterceptor>())
         .addInterceptor(get<VersionInterceptor>())
         .addInterceptor(get<LanguageInterceptor>())
         .addInterceptor(get<ChuckerInterceptor>())

core/network/src/main/kotlin/dev/meloda/fast/network/interceptor/Error14HandlingInterceptor.kt

@@ -0,0 +1,114 @@
+package dev.meloda.fast.network.interceptor
+
+import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.datastore.CaptchaTokenResult
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+import kotlinx.coroutines.withTimeout
+import okhttp3.Interceptor
+import okhttp3.Request
+import okhttp3.Response
+import org.json.JSONObject
+import java.io.IOException
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.time.Duration.Companion.minutes
+
+class Error14HandlingInterceptor : Interceptor {
+
+    private val cookie = AtomicReference<String?>(null)
+    private val captchaMutex = Mutex()
+
+    override fun intercept(chain: Interceptor.Chain): Response {
+        val request = chain.request().withCookie()
+        val response = chain.proceed(request)
+        response.parseCookie()
+
+        if (request.shouldSkipCaptcha()) return response
+
+        val redirectUri = response.getRedirectUri() ?: return response
+        val token = awaitCaptchaToken(redirectUri)
+
+        return chain.proceed(chain.request().withCookie().withSuccessToken(token))
+    }
+
+    private fun awaitCaptchaToken(redirectUri: String): String = runBlocking(Dispatchers.IO) {
+        captchaMutex.withLock {
+            AppSettings.setCaptchaResult(CaptchaTokenResult.Initial)
+            AppSettings.setCaptchaRedirectUri(redirectUri)
+
+            try {
+                withTimeout(CAPTCHA_TIMEOUT) {
+                    AppSettings.getCaptchaResultFlow()
+                        .first { it != CaptchaTokenResult.Initial }
+                        .toToken()
+                }
+            } finally {
+                AppSettings.setCaptchaResult(CaptchaTokenResult.Initial)
+                AppSettings.setCaptchaRedirectUri(null)
+            }
+        }
+    }
+
+    private fun CaptchaTokenResult.toToken(): String = when (this) {
+        is CaptchaTokenResult.Success -> token
+        CaptchaTokenResult.Cancelled -> throw IOException("Captcha cancelled")
+        CaptchaTokenResult.Null -> throw IOException("Captcha result is empty")
+        CaptchaTokenResult.Initial -> throw IllegalStateException("Captcha result not ready")
+    }
+
+    private fun Request.withSuccessToken(token: String): Request {
+        return newBuilder()
+            .url(url.newBuilder().addQueryParameter("success_token", token).build())
+            .build()
+    }
+
+    private fun Response.getRedirectUri(): String? {
+        val responseBody = JSONObject(peekBody(Long.MAX_VALUE).string())
+        return if (responseBody.has("error")) {
+            val stringError = try {
+                responseBody.getString("error")
+            } catch (ignored: Exception) {
+                null
+            }
+
+            if (stringError != null) {
+                if (stringError == CAPTCHA_ERROR_KIND && responseBody.has("redirect_uri")) {
+                    responseBody.getString("redirect_uri")
+                } else {
+                    null
+                }
+            } else {
+                val error = responseBody.getJSONObject("error")
+                if (error.getInt("error_code") == CAPTCHA_ERROR_CODE) {
+                    error.getString("redirect_uri")
+                } else {
+                    null
+                }
+            }
+        } else {
+            null
+        }
+    }
+
+    private fun Request.shouldSkipCaptcha(): Boolean {
+        return false
+//        return !domains.contains(url.toUrl().host) && domains.isNotEmpty()
+    }
+
+    private fun Response.parseCookie() {
+        headers("Set-Cookie").firstOrNull { it.contains("remixstlid") }?.let(cookie::set)
+    }
+
+    private fun Request.withCookie(): Request {
+        return newBuilder().apply { cookie.get()?.let { addHeader("Cookie", it) } }.build()
+    }
+
+    private companion object {
+        private const val CAPTCHA_ERROR_CODE = 14
+        private const val CAPTCHA_ERROR_KIND = "need_captcha"
+        private val CAPTCHA_TIMEOUT = 10.minutes
+    }
+}

core/network/src/main/kotlin/dev/meloda/fast/network/service/messages/MessagesService.kt

@@ -2,6 +2,7 @@ package dev.meloda.fast.network.service.messages
 
 import com.slack.eithernet.ApiResult
 import dev.meloda.fast.model.api.data.VkChatData
+import dev.meloda.fast.model.api.data.LongPollHistoryResponse
 import dev.meloda.fast.model.api.data.VkLongPollData
 import dev.meloda.fast.model.api.data.VkMessageData
 import dev.meloda.fast.model.api.responses.MessagesCreateChatResponse
@@ -44,6 +45,12 @@ interface MessagesService {
         @FieldMap params: Map<String, String>
     ): ApiResult<ApiResponse<VkLongPollData>, RestApiError>
 
+    @FormUrlEncoded
+    @POST(MessagesUrls.GET_LONG_POLL_HISTORY)
+    suspend fun getLongPollHistory(
+        @FieldMap params: Map<String, String>
+    ): ApiResult<ApiResponse<LongPollHistoryResponse>, RestApiError>
+
     @FormUrlEncoded
     @POST(MessagesUrls.MARK_AS_READ)
     suspend fun markAsRead(

core/ui/src/main/kotlin/dev/meloda/fast/ui/common/FastPreview.kt

@@ -0,0 +1,48 @@
+package dev.meloda.fast.ui.common
+
+import androidx.compose.ui.tooling.preview.AndroidUiModes.UI_MODE_NIGHT_YES
+import androidx.compose.ui.tooling.preview.AndroidUiModes.UI_MODE_TYPE_NORMAL
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.Wallpapers.BLUE_DOMINATED_EXAMPLE
+import androidx.compose.ui.tooling.preview.Wallpapers.GREEN_DOMINATED_EXAMPLE
+import androidx.compose.ui.tooling.preview.Wallpapers.RED_DOMINATED_EXAMPLE
+import androidx.compose.ui.tooling.preview.Wallpapers.YELLOW_DOMINATED_EXAMPLE
+
+@Preview(name = "70%", fontScale = 0.70f)
+@Preview(name = "85%", fontScale = 0.85f)
+@Preview(name = "100%", fontScale = 1.0f)
+@Preview(name = "115%", fontScale = 1.15f)
+@Preview(name = "130%", fontScale = 1.3f)
+@Preview(name = "150%", fontScale = 1.5f)
+@Preview(name = "180%", fontScale = 1.8f)
+@Preview(name = "200%", fontScale = 2f)
+
+@Preview(name = "Light")
+@Preview(name = "Red", wallpaper = RED_DOMINATED_EXAMPLE)
+@Preview(name = "Blue", wallpaper = BLUE_DOMINATED_EXAMPLE)
+@Preview(name = "Green", wallpaper = GREEN_DOMINATED_EXAMPLE)
+@Preview(name = "Yellow", wallpaper = YELLOW_DOMINATED_EXAMPLE)
+
+@Preview(name = "Dark", uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL)
+@Preview(
+    name = "Dark Red",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = RED_DOMINATED_EXAMPLE
+)
+@Preview(
+    name = "Dark Blue",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = BLUE_DOMINATED_EXAMPLE
+)
+@Preview(
+    name = "Dark Green",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = GREEN_DOMINATED_EXAMPLE
+)
+@Preview(
+    name = "Dark Yellow",
+    uiMode = UI_MODE_NIGHT_YES or UI_MODE_TYPE_NORMAL,
+    wallpaper = YELLOW_DOMINATED_EXAMPLE
+)
+
+annotation class FastPreview

core/ui/src/main/kotlin/dev/meloda/fast/ui/components/MaterialDialog.kt

@@ -2,6 +2,7 @@ package dev.meloda.fast.ui.components
 
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.ColumnScope
@@ -46,9 +47,14 @@ import androidx.compose.ui.layout.onPlaced
 import androidx.compose.ui.res.vectorResource
 import androidx.compose.ui.text.style.TextAlign
 import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewDynamicColors
+import androidx.compose.ui.tooling.preview.PreviewFontScale
+import androidx.compose.ui.tooling.preview.PreviewLightDark
+import androidx.compose.ui.tooling.preview.PreviewScreenSizes
 import androidx.compose.ui.unit.dp
 import androidx.compose.ui.window.DialogProperties
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.FastPreview
 import dev.meloda.fast.ui.theme.AppTheme
 import dev.meloda.fast.ui.util.ImmutableList
 import dev.meloda.fast.ui.util.ImmutableList.Companion.toImmutableList
@@ -361,10 +367,10 @@ sealed class SelectionType {
     data object None : SelectionType()
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogPreview() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(
             onDismissRequest = {},
             title = "Material Dialog",
@@ -376,10 +382,10 @@ private fun MaterialDialogPreview() {
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogWithListPreview() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(
             onDismissRequest = {},
             title = "Material Dialog",
@@ -393,10 +399,10 @@ private fun MaterialDialogWithListPreview() {
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogWithCustomContent() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(
             onDismissRequest = {},
             title = "Material Dialog",
@@ -425,10 +431,10 @@ private fun MaterialDialogWithCustomContent() {
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun MaterialDialogWithOnlyCustomContent() {
-    AppTheme {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         MaterialDialog(onDismissRequest = {}) {
             Row(
                 modifier = Modifier

core/ui/src/main/kotlin/dev/meloda/fast/ui/components/NoItemsView.kt

@@ -1,5 +1,6 @@
 package dev.meloda.fast.ui.components
 
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Spacer
@@ -8,15 +9,17 @@ import androidx.compose.foundation.layout.height
 import androidx.compose.foundation.layout.padding
 import androidx.compose.material3.Button
 import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.FastPreview
+import dev.meloda.fast.ui.theme.AppTheme
 
 @Composable
 fun NoItemsView(
@@ -49,11 +52,15 @@ fun NoItemsView(
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun NoItemsViewPreview() {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
+        Surface {
             NoItemsView(
                 customText = "Nothing here...",
                 buttonText = "Refresh"
             )
         }
+    }
+}

core/ui/src/main/kotlin/dev/meloda/fast/ui/extensions/SharedViewModel.kt

@@ -9,6 +9,7 @@ import org.koin.androidx.compose.koinViewModel
 import org.koin.core.parameter.ParametersDefinition
 import org.koin.core.qualifier.Qualifier
 
+@Suppress("ParamsComparedByRef")
 @Composable
 inline fun <reified T : ViewModel> NavBackStackEntry.sharedViewModel(
     navController: NavController,

core/ui/src/main/kotlin/dev/meloda/fast/ui/util/ImmutableList.kt

@@ -9,10 +9,6 @@ class ImmutableList<T>(val values: List<T>) : Collection<T> {
 
     operator fun get(index: Int): T = values[index]
 
-    inline fun forEach(action: (T) -> Unit) {
-        for (element in values) action(element)
-    }
-
     inline fun <R> map(transform: (T) -> R): ImmutableList<R> {
         return values.map(transform).toImmutableList()
     }
@@ -49,6 +45,8 @@ class ImmutableList<T>(val values: List<T>) : Collection<T> {
             if (elements.isNotEmpty()) copyOf(elements.asList()) else empty()
 
         fun <T> of(element: T) = ImmutableList(listOf(element))
+
+        fun <T> ImmutableList<T>?.orEmpty(): ImmutableList<T> = this ?: emptyImmutableList()
     }
 
     override fun iterator(): Iterator<T> = values.listIterator()
@@ -59,5 +57,3 @@ class ImmutableList<T>(val values: List<T>) : Collection<T> {
 fun <T> emptyImmutableList(): ImmutableList<T> = ImmutableList(emptyList())
 
 fun <T> immutableListOf(vararg elements: T) = ImmutableList(listOf(elements = elements))
-
-fun <T> ImmutableList<T>?.orEmpty(): ImmutableList<T> = this ?: emptyImmutableList()

core/ui/src/main/res/values-ru/strings.xml

@@ -232,8 +232,10 @@
     <string name="month_short">М</string>
     <string name="week_short">Н</string>
     <string name="day_short">Д</string>
+    <string name="second_short">С</string>
     <string name="time_now">Сейчас</string>
 
     <string name="confirm_chat_create_with_title">Вы действительно хотите создать чат «%s»?</string>
     <string name="confirm_chat_create_empty_with_title">Вы действительно хотите создать чат «%s» только с собой?</string>
+    <string name="minute_short">М</string>
 </resources>

core/ui/src/main/res/values/strings.xml

@@ -1,4 +1,4 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
+<resources>
     <string name="app_name" translatable="false">Fast</string>
     <string name="fast_messenger" translatable="false">Fast Messenger</string>
 
@@ -297,8 +297,12 @@
     <string name="month_short">M</string>
     <string name="week_short">W</string>
     <string name="day_short">D</string>
+    <string name="minute_short">M</string>
+    <string name="second_short">S</string>
     <string name="time_now">Now</string>
 
     <string name="confirm_chat_create_with_title">Are you sure you want to create chat «%s»?</string>
     <string name="confirm_chat_create_empty_with_title">Are you sure you want to create chat «%s» only with yourself?</string>
+
+    <string name="title_edit_message">Edit message</string>
 </resources>

feature/auth/src/androidTest/kotlin/dev/meloda/fast/auth/login/LogoScreenTest.kt

@@ -3,7 +3,6 @@ package dev.meloda.fast.auth.login
 import androidx.compose.ui.test.assertHasClickAction
 import androidx.compose.ui.test.junit4.createComposeRule
 import androidx.compose.ui.test.onNodeWithTag
-import dev.meloda.fast.auth.login.presentation.LogoScreen
 import org.junit.Rule
 import org.junit.Test
 
@@ -15,7 +14,7 @@ class LogoScreenTest {
     @Test
     fun goNextButton_isClickable() {
         composeTestRule.setContent {
-            LogoScreen()
+
         }
 
         composeTestRule.onNodeWithTag(testTag = "go_next_fab").assertHasClickAction()

feature/auth/src/main/kotlin/dev/meloda/fast/auth/AuthGraph.kt

@@ -3,9 +3,6 @@ package dev.meloda.fast.auth
 import androidx.navigation.NavController
 import androidx.navigation.NavGraphBuilder
 import androidx.navigation.navigation
-import dev.meloda.fast.auth.captcha.navigation.captchaScreen
-import dev.meloda.fast.auth.captcha.navigation.navigateToCaptcha
-import dev.meloda.fast.auth.captcha.navigation.setCaptchaResult
 import dev.meloda.fast.auth.login.navigation.Login
 import dev.meloda.fast.auth.login.navigation.loginScreen
 import dev.meloda.fast.auth.userbanned.model.UserBannedArguments
@@ -28,11 +25,6 @@ fun NavGraphBuilder.authNavGraph(
 ) {
     navigation<AuthGraph>(startDestination = Login) {
         loginScreen(
-            onNavigateToCaptcha = { arguments ->
-                navController.navigateToCaptcha(
-                    captchaImageUrl = URLEncoder.encode(arguments.captchaImageUrl, "utf-8")
-                )
-            },
             onNavigateToValidation = { arguments ->
                 navController.navigateToValidation(
                     ValidationArguments(
@@ -70,17 +62,6 @@ fun NavGraphBuilder.authNavGraph(
             }
         )
 
-        captchaScreen(
-            onBack = {
-                navController.setCaptchaResult(null)
-                navController.navigateUp()
-            },
-            onResult = { code ->
-                navController.setCaptchaResult(code)
-                navController.popBackStack()
-            }
-        )
-
         userBannedRoute(onBack = navController::navigateUp)
     }
 }

feature/auth/src/main/kotlin/dev/meloda/fast/auth/AuthModule.kt

@@ -1,6 +1,5 @@
 package dev.meloda.fast.auth
 
-import dev.meloda.fast.auth.captcha.di.captchaModule
 import dev.meloda.fast.auth.validation.di.validationModule
 import dev.meloda.fast.auth.login.di.loginModule
 import org.koin.dsl.module
@@ -9,6 +8,5 @@ val authModule = module {
     includes(
         loginModule,
         validationModule,
-        captchaModule,
     )
 }

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/CaptchaViewModel.kt

@@ -1,69 +0,0 @@
-package dev.meloda.fast.auth.captcha
-
-import androidx.lifecycle.SavedStateHandle
-import androidx.lifecycle.ViewModel
-import dev.meloda.fast.auth.captcha.model.CaptchaScreenState
-import dev.meloda.fast.auth.captcha.navigation.Captcha
-import dev.meloda.fast.auth.captcha.validation.CaptchaValidator
-import dev.meloda.fast.common.extensions.setValue
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.update
-import java.net.URLDecoder
-
-interface CaptchaViewModel {
-    val screenState: StateFlow<CaptchaScreenState>
-    val isNeedToOpenLogin: StateFlow<Boolean>
-
-    fun onCodeInputChanged(newCode: String)
-
-    fun onTextFieldDoneAction()
-    fun onDoneButtonClicked()
-
-    fun onNavigatedToLogin()
-}
-
-class CaptchaViewModelImpl(
-    private val validator: CaptchaValidator,
-    savedStateHandle: SavedStateHandle
-) : CaptchaViewModel, ViewModel() {
-
-    override val screenState = MutableStateFlow(CaptchaScreenState.EMPTY)
-    override val isNeedToOpenLogin = MutableStateFlow(false)
-
-
-    init {
-        val captchaImage = Captcha.from(savedStateHandle).captchaImageUrl
-
-        screenState.setValue { old ->
-            old.copy(captchaImageUrl = URLDecoder.decode(captchaImage, "utf-8"))
-        }
-    }
-
-    override fun onCodeInputChanged(newCode: String) {
-        val newState = screenState.value.copy(code = newCode.trim())
-        screenState.update { newState }
-        processValidation()
-    }
-
-    override fun onTextFieldDoneAction() {
-        onDoneButtonClicked()
-    }
-
-    override fun onDoneButtonClicked() {
-        if (!processValidation()) return
-
-        isNeedToOpenLogin.update { true }
-    }
-
-    override fun onNavigatedToLogin() {
-        screenState.update { CaptchaScreenState.EMPTY }
-        isNeedToOpenLogin.update { false }
-    }
-
-    private fun processValidation(): Boolean {
-        val isValid = validator.validate(screenState.value).isValid()
-        screenState.setValue { old -> old.copy(codeError = !isValid) }
-        return isValid
-    }
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/di/CaptchaDI.kt

@@ -1,14 +0,0 @@
-package dev.meloda.fast.auth.captcha.di
-
-import dev.meloda.fast.auth.captcha.CaptchaViewModel
-import dev.meloda.fast.auth.captcha.CaptchaViewModelImpl
-import dev.meloda.fast.auth.captcha.validation.CaptchaValidator
-import org.koin.core.module.dsl.singleOf
-import org.koin.core.module.dsl.viewModelOf
-import org.koin.dsl.bind
-import org.koin.dsl.module
-
-val captchaModule = module {
-    singleOf(::CaptchaValidator)
-    viewModelOf(::CaptchaViewModelImpl) bind CaptchaViewModel::class
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/model/CaptchaScreenState.kt

@@ -1,16 +0,0 @@
-package dev.meloda.fast.auth.captcha.model
-
-data class CaptchaScreenState(
-    val captchaImageUrl: String,
-    val code: String,
-    val codeError: Boolean
-) {
-
-    companion object {
-        val EMPTY = CaptchaScreenState(
-            captchaImageUrl = "",
-            code = "",
-            codeError = false
-        )
-    }
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/model/CaptchaValidationResult.kt

@@ -1,8 +0,0 @@
-package dev.meloda.fast.auth.captcha.model
-
-sealed class CaptchaValidationResult {
-    data object Empty : CaptchaValidationResult()
-    data object Valid : CaptchaValidationResult()
-
-    fun isValid() = this == Valid
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/navigation/CaptchaNavigation.kt

@@ -1,40 +0,0 @@
-package dev.meloda.fast.auth.captcha.navigation
-
-import androidx.lifecycle.SavedStateHandle
-import androidx.navigation.NavController
-import androidx.navigation.NavGraphBuilder
-import androidx.navigation.compose.composable
-import androidx.navigation.toRoute
-import dev.meloda.fast.auth.captcha.presentation.CaptchaRoute
-import kotlinx.serialization.Serializable
-
-@Serializable
-data class Captcha(val captchaImageUrl: String) {
-
-    companion object {
-        fun from(savedStateHandle: SavedStateHandle) = savedStateHandle.toRoute<Captcha>()
-    }
-}
-
-
-fun NavGraphBuilder.captchaScreen(
-    onBack: () -> Unit,
-    onResult: (String) -> Unit
-) {
-    composable<Captcha> {
-        CaptchaRoute(
-            onBack = onBack,
-            onResult = onResult
-        )
-    }
-}
-
-fun NavController.navigateToCaptcha(captchaImageUrl: String) {
-    this.navigate(Captcha(captchaImageUrl))
-}
-
-fun NavController.setCaptchaResult(code: String?) {
-    this.previousBackStackEntry
-        ?.savedStateHandle
-        ?.set("captcha_code", code)
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/presentation/CaptchaScreen.kt

@@ -1,32 +1,22 @@
 package dev.meloda.fast.auth.captcha.presentation
 
+import android.graphics.Bitmap
+import android.util.Log
+import android.webkit.JavascriptInterface
+import android.webkit.WebResourceRequest
+import android.webkit.WebView
+import android.webkit.WebViewClient
 import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.border
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.WindowInsets
+import androidx.compose.animation.fadeIn
+import androidx.compose.animation.fadeOut
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Box
 import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.ime
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.union
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.KeyboardActions
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.material3.ExtendedFloatingActionButton
-import androidx.compose.material3.FloatingActionButton
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.ScaffoldDefaults
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
+import androidx.compose.foundation.layout.navigationBarsPadding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.CircularProgressIndicator
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
@@ -36,62 +26,34 @@ import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.platform.LocalView
-import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
 import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.input.ImeAction
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
-import coil.compose.AsyncImage
-import dev.meloda.fast.auth.captcha.CaptchaViewModel
-import dev.meloda.fast.auth.captcha.CaptchaViewModelImpl
-import dev.meloda.fast.auth.captcha.model.CaptchaScreenState
+import androidx.compose.ui.viewinterop.AndroidView
 import dev.meloda.fast.ui.R
 import dev.meloda.fast.ui.components.ActionInvokeDismiss
+import dev.meloda.fast.ui.components.FullScreenDialog
 import dev.meloda.fast.ui.components.MaterialDialog
-import dev.meloda.fast.ui.components.TextFieldErrorText
-import org.koin.androidx.compose.koinViewModel
+import org.json.JSONObject
 
-@Composable
-fun CaptchaRoute(
-    onBack: () -> Unit,
-    onResult: (String) -> Unit,
-    viewModel: CaptchaViewModel = koinViewModel<CaptchaViewModelImpl>()
-) {
-    LocalViewModelStoreOwner.current
-    val screenState by viewModel.screenState.collectAsStateWithLifecycle()
-    val isNeedToOpenLogin by viewModel.isNeedToOpenLogin.collectAsStateWithLifecycle()
-
-    LaunchedEffect(isNeedToOpenLogin) {
-        if (isNeedToOpenLogin) {
-            viewModel.onNavigatedToLogin()
-            onResult(screenState.code)
-        }
-    }
-
-    CaptchaScreen(
-        screenState = screenState,
-        onBack = onBack,
-        onCodeInputChanged = viewModel::onCodeInputChanged,
-        onTextFieldDoneAction = viewModel::onTextFieldDoneAction,
-        onDoneButtonClicked = viewModel::onDoneButtonClicked
-    )
-}
+private const val TAG = "CaptchaScreen"
 
 @Composable
 fun CaptchaScreen(
-    screenState: CaptchaScreenState = CaptchaScreenState.EMPTY,
+    captchaRedirectUri: String?,
     onBack: () -> Unit = {},
-    onCodeInputChanged: (String) -> Unit = {},
-    onTextFieldDoneAction: () -> Unit = {},
-    onDoneButtonClicked: () -> Unit = {}
+    onResult: (String) -> Unit = {}
 ) {
+    if (captchaRedirectUri != null) {
+        val focusManager = LocalFocusManager.current
+        val keyboardController = LocalSoftwareKeyboardController.current
+        LaunchedEffect(true) {
+            focusManager.clearFocus(true)
+            keyboardController?.hide()
+        }
+
         var confirmedExit by remember {
             mutableStateOf(false)
         }
@@ -100,6 +62,10 @@ fun CaptchaScreen(
             mutableStateOf(false)
         }
 
+        var isWebViewLoading by remember {
+            mutableStateOf(true)
+        }
+
         LaunchedEffect(confirmedExit) {
             if (confirmedExit) {
                 onBack()
@@ -112,6 +78,7 @@ fun CaptchaScreen(
             }
         }
 
+        FullScreenDialog(onDismiss = { showExitAlert = true }) {
             if (showExitAlert) {
                 MaterialDialog(
                     onDismissRequest = { showExitAlert = false },
@@ -124,146 +91,104 @@ fun CaptchaScreen(
                 )
             }
 
-    val focusManager = LocalFocusManager.current
-
-    Scaffold(
-        contentWindowInsets = ScaffoldDefaults.contentWindowInsets.union(WindowInsets.ime)
-    ) { padding ->
-        Column(
+            Box(
                 modifier = Modifier
                     .fillMaxSize()
-                .padding(padding)
-                .padding(30.dp),
-            verticalArrangement = Arrangement.SpaceBetween
+                    .navigationBarsPadding()
+                    .clickable(
+                        interactionSource = remember { MutableInteractionSource() },
+                        indication = null,
+                        onClick = { showExitAlert = true }
+                    )
             ) {
-            ExtendedFloatingActionButton(
-                onClick = onBack,
-                text = {
-                    Text(
-                        text = "Cancel",
-                        color = MaterialTheme.colorScheme.onPrimaryContainer
-                    )
-                },
-                icon = {
-                    Icon(
-                        painter = painterResource(R.drawable.ic_close_round_24),
-                        contentDescription = "Close icon",
-                        tint = MaterialTheme.colorScheme.onPrimaryContainer,
-                    )
-                }
-            )
-
-            Column(
-                modifier = Modifier.fillMaxWidth(),
-            ) {
-                Text(
-                    text = "Captcha",
-                    style = MaterialTheme.typography.displayMedium,
-                    color = MaterialTheme.colorScheme.onBackground
-                )
-                Spacer(modifier = Modifier.height(38.dp))
-                Row(
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    Text(
-                        text = "To proceed with your action, enter a code from the picture",
-                        style = MaterialTheme.typography.bodyLarge,
-                        color = MaterialTheme.colorScheme.onBackground,
-                        modifier = Modifier.weight(0.5f)
-                    )
-                    Spacer(modifier = Modifier.width(24.dp))
-
-                    val imageModifier = Modifier
-                        .border(
-                            2.dp,
-                            MaterialTheme.colorScheme.primary,
-                            shape = RoundedCornerShape(10.dp)
-                        )
-                        .clip(RoundedCornerShape(10.dp))
-                        .height(48.dp)
-                        .width(130.dp)
-
-                    if (LocalView.current.isInEditMode) {
-                        Image(
-                            painter = painterResource(id = R.drawable.img_test_captcha),
-                            contentDescription = "Captcha image",
-                            modifier = imageModifier
-                        )
-                    } else {
-                        AsyncImage(
-                            model = screenState.captchaImageUrl,
-                            contentDescription = "Captcha image",
-                            contentScale = ContentScale.FillBounds,
-                            modifier = imageModifier
-                        )
-                    }
-                }
-
-                Spacer(modifier = Modifier.height(30.dp))
-
-                var code by remember { mutableStateOf(TextFieldValue(screenState.code)) }
-                val showError = screenState.codeError
-
-                TextField(
-                    value = code,
-                    onValueChange = { newText ->
-                        code = newText
-                        onCodeInputChanged(newText.text)
-                    },
-                    label = { Text(text = "Code") },
-                    placeholder = { Text(text = "Code") },
+                AndroidView(
                     modifier = Modifier
-                        .fillMaxWidth()
-                        .clip(RoundedCornerShape(10.dp)),
-                    leadingIcon = {
-                        Icon(
-                            painter = painterResource(id = R.drawable.ic_qr_code_round_24),
-                            contentDescription = "QR code icon",
-                            tint = if (showError) {
-                                MaterialTheme.colorScheme.error
-                            } else {
-                                MaterialTheme.colorScheme.primary
-                            }
-                        )
-                    },
-                    shape = RoundedCornerShape(10.dp),
-                    keyboardOptions = KeyboardOptions.Default.copy(imeAction = ImeAction.Done),
-                    keyboardActions = KeyboardActions(
-                        onDone = {
-                            focusManager.clearFocus()
-                            onTextFieldDoneAction()
-                        }
-                    ),
-                    isError = showError
-                )
-
-                AnimatedVisibility(visible = showError) {
-                    TextFieldErrorText(text = "Field must not be empty")
-                }
+                        .fillMaxSize()
+                        .align(Alignment.BottomCenter),
+                    factory = { context ->
+                        val webview = WebView(context)
+                        webview.setBackgroundColor(0)
+                        webview.settings.javaScriptEnabled = true
+                        webview.webViewClient = object : WebViewClient() {
+                            override fun shouldOverrideUrlLoading(
+                                view: WebView?,
+                                request: WebResourceRequest?
+                            ): Boolean {
+                                Log.i(TAG, "shouldOverrideUrlLoading: $request")
+                                return false
                             }
 
-            FloatingActionButton(
-                onClick = onDoneButtonClicked,
-                containerColor = MaterialTheme.colorScheme.secondaryContainer,
-                modifier = Modifier.align(Alignment.CenterHorizontally)
+                            override fun onPageStarted(
+                                view: WebView?,
+                                url: String?,
+                                favicon: Bitmap?
                             ) {
-                Icon(
-                    painter = painterResource(R.drawable.ic_check_round_24),
-                    contentDescription = "Done icon",
-                    tint = MaterialTheme.colorScheme.onSecondaryContainer
+                                super.onPageStarted(view, url, favicon)
+                                isWebViewLoading = true
+                            }
+
+                            override fun onPageFinished(view: WebView?, url: String?) {
+                                super.onPageFinished(view, url)
+                                isWebViewLoading = false
+                            }
+                        }
+                        webview.addJavascriptInterface(
+                            WebCaptchaListener(
+                                onSuccessTokenReceived = {
+                                    val response: String? = try {
+                                        JSONObject(it).getString("token")
+                                    } catch (e: Exception) {
+                                        e.printStackTrace()
+                                        null
+                                    }
+
+                                    if (response != null) {
+                                        onResult(response)
+                                    } else {
+                                        // TODO: 03/05/2026, Danil Nikolaev: show error
+                                    }
+                                },
+                                onCloseRequested = { showExitAlert = true }
+                            ),
+                            "AndroidBridge"
                         )
+//                        webview.loadUrl("https://id.vk.ru/not_robot_captcha?variant=block&session_token=test&domain=test.com")
+                        webview.loadUrl(captchaRedirectUri)
+                        webview
+                    }
+                )
+
+                AnimatedVisibility(
+                    visible = isWebViewLoading,
+                    enter = fadeIn(),
+                    exit = fadeOut(),
+                    modifier = Modifier.align(Alignment.Center)
+                ) {
+                    CircularProgressIndicator(
+                        modifier = Modifier.size(50.dp),
+                        color = Color.White.copy(alpha = 0.85f)
+                    )
+                }
             }
         }
     }
 }
 
-@Preview
-@Composable
-private fun CaptchaScreenPreview() {
-    CaptchaScreen(
-        screenState = CaptchaScreenState.EMPTY.copy(
-            code = "zcuecz"
-        )
-    )
+class WebCaptchaListener(
+    private val onSuccessTokenReceived: (String) -> Unit,
+    private val onCloseRequested: (String) -> Unit
+) {
+    private val tag = "WebCaptchaListener"
+
+    @JavascriptInterface
+    fun VKCaptchaGetResult(arg: String) {
+        onSuccessTokenReceived(arg)
+        Log.i(tag, "VKCaptchaGetResult($arg)")
+    }
+
+    @JavascriptInterface
+    fun VKCaptchaCloseCaptcha(arg: String) {
+        onCloseRequested(arg)
+        Log.i(tag, "VKCaptchaCloseCaptcha($arg)")
+    }
 }

feature/auth/src/main/kotlin/dev/meloda/fast/auth/captcha/validation/CaptchaValidator.kt

@@ -1,14 +0,0 @@
-package dev.meloda.fast.auth.captcha.validation
-
-import dev.meloda.fast.auth.captcha.model.CaptchaScreenState
-import dev.meloda.fast.auth.captcha.model.CaptchaValidationResult
-
-class CaptchaValidator {
-
-    fun validate(screenState: CaptchaScreenState): CaptchaValidationResult {
-        return when {
-            screenState.code.trim().isEmpty() -> CaptchaValidationResult.Empty
-            else -> CaptchaValidationResult.Valid
-        }
-    }
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/login/LoginViewModel.kt

@@ -59,18 +59,12 @@ class LoginViewModel(
     private val _validationArguments = MutableStateFlow<LoginValidationArguments?>(null)
     val validationArguments = _validationArguments.asStateFlow()
 
-    private val _captchaArguments = MutableStateFlow<CaptchaArguments?>(null)
-    val captchaArguments = _captchaArguments.asStateFlow()
-
     private val _userBannedArguments = MutableStateFlow<LoginUserBannedArguments?>(null)
     val userBannedArguments = _userBannedArguments.asStateFlow()
 
     private val _isNeedToOpenMain = MutableStateFlow(false)
     val isNeedToOpenMain = _isNeedToOpenMain.asStateFlow()
 
-    private val _isNeedToClearCaptchaCode = MutableStateFlow(false)
-    val isNeedToClearCaptchaCode = _isNeedToClearCaptchaCode.asStateFlow()
-
     private val _isNeedToClearValidationCode = MutableStateFlow(false)
     val isNeedToClearValidationCode = _isNeedToClearValidationCode.asStateFlow()
 
@@ -78,17 +72,10 @@ class LoginViewModel(
         screenState.map(loginValidator::validate)
             .stateIn(viewModelScope, SharingStarted.Eagerly, listOf(LoginValidationResult.Empty))
 
-    private val captchaSid = MutableStateFlow<String?>(null)
-    private val captchaCode = MutableStateFlow<String?>(null)
     private val validationSid = MutableStateFlow<String?>(null)
     private val validationCode = MutableStateFlow<String?>(null)
 
     init {
-        captchaCode.listenValue(viewModelScope) {
-            if (it != null) {
-                login()
-            }
-        }
         validationCode.listenValue(viewModelScope) {
             if (it != null) {
                 login()
@@ -165,10 +152,6 @@ class LoginViewModel(
         _userBannedArguments.update { null }
     }
 
-    fun onNavigatedToCaptcha() {
-        _captchaArguments.update { null }
-    }
-
     fun onNavigatedToValidation() {
         _validationArguments.update { null }
     }
@@ -181,25 +164,9 @@ class LoginViewModel(
         _isNeedToClearValidationCode.update { false }
     }
 
-    fun onCaptchaCodeReceived(code: String?) {
-        captchaCode.update { code }
-    }
-
-    fun onCaptchaCodeCleared() {
-        _isNeedToClearCaptchaCode.update { false }
-    }
-
     private fun login(forceSms: Boolean = false) {
         val currentState = screenState.value.copy()
 
-        Log.d(
-            "LoginViewModel",
-            "auth: login: ${currentState.login}; " +
-                    "password: ${currentState.password}; " +
-                    "2fa code: ${validationCode.value}; " +
-                    "captcha code: ${captchaCode.value}"
-        )
-
         processValidation()
         if (!validationState.value.contains(LoginValidationResult.Valid)) return
 
@@ -207,23 +174,18 @@ class LoginViewModel(
 
         val currentValidationSid = validationSid.value
         val currentValidationCode = validationCode.value?.takeIf { currentValidationSid != null }
-        val currentCaptchaSid = captchaSid.value
-        val currentCaptchaCode = captchaCode.value?.takeIf { currentCaptchaSid != null }
 
         oAuthUseCase.getSilentToken(
             login = currentState.login,
             password = currentState.password,
             forceSms = forceSms,
             validationCode = currentValidationCode,
-            captchaSid = currentCaptchaSid,
-            captchaKey = currentCaptchaCode
         ).listenValue(viewModelScope) { state ->
             state.processState(
                 error = { error ->
                     Log.d("LoginViewModelImpl", "login: error: $error")
 
                     _screenState.updateValue { copy(isLoading = false) }
-                    captchaSid.setValue { null }
 
                     parseError(error)
                 },
@@ -286,7 +248,6 @@ class LoginViewModel(
 
                         startLongPoll()
 
-                        captchaSid.update { null }
                         validationSid.update { null }
 
                         loadUserByIdUseCase(
@@ -333,11 +294,8 @@ class LoginViewModel(
 
                     is OAuthErrorDomain.CaptchaRequiredError -> {
                         val arguments = CaptchaArguments(
-                            captchaSid = error.captchaSid,
-                            captchaImageUrl = error.captchaImageUrl
+                            redirectUri = error.redirectUri
                         )
-                        _captchaArguments.update { arguments }
-                        captchaSid.update { error.captchaSid }
                     }
 
                     OAuthErrorDomain.InvalidCredentialsError -> {

feature/auth/src/main/kotlin/dev/meloda/fast/auth/login/model/CaptchaArguments.kt

@@ -7,6 +7,5 @@ import kotlinx.serialization.Serializable
 @Serializable
 @Parcelize
 data class CaptchaArguments(
-    val captchaSid: String,
-    val captchaImageUrl: String
+    val redirectUri: String?
 ) : Parcelable

feature/auth/src/main/kotlin/dev/meloda/fast/auth/login/navigation/LoginNavigation.kt

@@ -3,13 +3,11 @@ package dev.meloda.fast.auth.login.navigation
 import androidx.compose.runtime.LaunchedEffect
 import androidx.compose.runtime.getValue
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import androidx.lifecycle.viewmodel.compose.LocalViewModelStoreOwner
 import androidx.navigation.NavBackStackEntry
 import androidx.navigation.NavController
 import androidx.navigation.NavGraphBuilder
 import androidx.navigation.compose.composable
 import dev.meloda.fast.auth.login.LoginViewModel
-import dev.meloda.fast.auth.login.model.CaptchaArguments
 import dev.meloda.fast.auth.login.model.LoginUserBannedArguments
 import dev.meloda.fast.auth.login.model.LoginValidationArguments
 import dev.meloda.fast.auth.login.presentation.LoginRoute
@@ -20,7 +18,6 @@ import kotlinx.serialization.Serializable
 object Login
 
 fun NavGraphBuilder.loginScreen(
-    onNavigateToCaptcha: (CaptchaArguments) -> Unit,
     onNavigateToValidation: (LoginValidationArguments) -> Unit,
     onNavigateToMain: () -> Unit,
     onNavigateToUserBanned: (LoginUserBannedArguments) -> Unit,
@@ -32,7 +29,6 @@ fun NavGraphBuilder.loginScreen(
             backStackEntry.sharedViewModel<LoginViewModel>(navController = navController)
 
         val clearValidationCode by viewModel.isNeedToClearValidationCode.collectAsStateWithLifecycle()
-        val clearCaptchaCode by viewModel.isNeedToClearCaptchaCode.collectAsStateWithLifecycle()
 
         LaunchedEffect(clearValidationCode) {
             if (clearValidationCode) {
@@ -41,24 +37,14 @@ fun NavGraphBuilder.loginScreen(
             }
         }
 
-        LaunchedEffect(clearCaptchaCode) {
-            if (clearCaptchaCode) {
-                backStackEntry.savedStateHandle["captcha_code"] = null
-                viewModel.onCaptchaCodeCleared()
-            }
-        }
-
         val validationCode = backStackEntry.getValidationResult()
-        val captchaCode = backStackEntry.getCaptchaResult()
 
         LoginRoute(
             onNavigateToUserBanned = onNavigateToUserBanned,
             onNavigateToMain = onNavigateToMain,
-            onNavigateToCaptcha = onNavigateToCaptcha,
             onNavigateToValidation = onNavigateToValidation,
             onNavigateToSettings = onNavigateToSettings,
             validationCode = validationCode,
-            captchaCode = captchaCode,
             viewModel = viewModel
         )
     }
@@ -67,7 +53,3 @@ fun NavGraphBuilder.loginScreen(
 fun NavBackStackEntry.getValidationResult(): String? {
     return savedStateHandle["validation_code"]
 }
-
-fun NavBackStackEntry.getCaptchaResult(): String? {
-    return savedStateHandle["captcha_code"]
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/login/presentation/LoginScreen.kt

@@ -75,17 +75,14 @@ import org.koin.androidx.compose.koinViewModel
 fun LoginRoute(
     onNavigateToUserBanned: (LoginUserBannedArguments) -> Unit,
     onNavigateToMain: () -> Unit,
-    onNavigateToCaptcha: (CaptchaArguments) -> Unit,
     onNavigateToValidation: (LoginValidationArguments) -> Unit,
     onNavigateToSettings: () -> Unit,
     validationCode: String?,
-    captchaCode: String?,
     viewModel: LoginViewModel = koinViewModel()
 ) {
     val screenState by viewModel.screenState.collectAsStateWithLifecycle()
     val isNeedToOpenMain by viewModel.isNeedToOpenMain.collectAsStateWithLifecycle()
     val userBannedArguments by viewModel.userBannedArguments.collectAsStateWithLifecycle()
-    val captchaArguments by viewModel.captchaArguments.collectAsStateWithLifecycle()
     val validationArguments by viewModel.validationArguments.collectAsStateWithLifecycle()
     val loginDialog by viewModel.loginDialog.collectAsStateWithLifecycle()
 
@@ -107,12 +104,6 @@ fun LoginRoute(
             onNavigateToUserBanned(arguments)
         }
     }
-    LaunchedEffect(captchaArguments) {
-        captchaArguments?.let { arguments ->
-            viewModel.onNavigatedToCaptcha()
-            onNavigateToCaptcha(arguments)
-        }
-    }
     LaunchedEffect(validationArguments) {
         validationArguments?.let { arguments ->
             viewModel.onNavigatedToValidation()
@@ -122,9 +113,6 @@ fun LoginRoute(
     LaunchedEffect(validationCode) {
         viewModel.onValidationCodeReceived(validationCode)
     }
-    LaunchedEffect(captchaCode) {
-        viewModel.onCaptchaCodeReceived(captchaCode)
-    }
 
     LoginScreen(
         screenState = screenState,

feature/auth/src/main/kotlin/dev/meloda/fast/auth/validation/ValidationViewModel.kt

@@ -4,7 +4,6 @@ import androidx.lifecycle.SavedStateHandle
 import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dev.meloda.fast.auth.validation.model.ValidationScreenState
-import dev.meloda.fast.auth.validation.model.ValidationType
 import dev.meloda.fast.auth.validation.navigation.Validation
 import dev.meloda.fast.auth.validation.validation.ValidationValidator
 import dev.meloda.fast.common.extensions.createTimerFlow
@@ -12,6 +11,7 @@ import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.domain.AuthUseCase
+import dev.meloda.fast.network.ValidationType
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow

feature/auth/src/main/kotlin/dev/meloda/fast/auth/validation/model/ValidationType.kt

@@ -1,10 +0,0 @@
-package dev.meloda.fast.auth.validation.model
-
-enum class ValidationType(val value: String) {
-    SMS("sms"), APP("2fa_app");
-
-    companion object {
-        fun parse(value: String): ValidationType = entries.firstOrNull { it.value == value }
-            ?: throw IllegalArgumentException("Unknown validation type with value: $value")
-    }
-}

feature/auth/src/main/kotlin/dev/meloda/fast/auth/validation/presentation/ValidationScreen.kt

@@ -3,6 +3,7 @@ package dev.meloda.fast.auth.validation.presentation
 import androidx.activity.compose.BackHandler
 import androidx.compose.animation.AnimatedVisibility
 import androidx.compose.animation.shrinkHorizontally
+import androidx.compose.foundation.isSystemInDarkTheme
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.Row
@@ -46,17 +47,18 @@ import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.text.input.ImeAction
 import androidx.compose.ui.text.input.KeyboardType
 import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.tooling.preview.Preview
 import androidx.compose.ui.unit.dp
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import dev.meloda.fast.auth.validation.ValidationViewModel
 import dev.meloda.fast.auth.validation.ValidationViewModelImpl
 import dev.meloda.fast.auth.validation.model.ValidationScreenState
-import dev.meloda.fast.auth.validation.model.ValidationType
+import dev.meloda.fast.network.ValidationType
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.FastPreview
 import dev.meloda.fast.ui.components.ActionInvokeDismiss
 import dev.meloda.fast.ui.components.MaterialDialog
 import dev.meloda.fast.ui.components.TextFieldErrorText
+import dev.meloda.fast.ui.theme.AppTheme
 import org.koin.androidx.compose.koinViewModel
 
 @Composable
@@ -116,7 +118,7 @@ fun ValidationScreen(
     val validationText by remember(validationType) {
         mutableStateOf(
             when (validationType) {
-                ValidationType.SMS -> "SMS with the code is sent to ${screenState.phoneMask}"
+                ValidationType.SMS, ValidationType.SMS2 -> "SMS with the code is sent to ${screenState.phoneMask}"
                 ValidationType.APP -> "Enter the code from the code generator application"
 
                 null -> ""
@@ -301,9 +303,10 @@ fun ValidationScreen(
     }
 }
 
-@Preview
+@FastPreview
 @Composable
 private fun ValidationScreenPreview() {
+    AppTheme(useDarkTheme = isSystemInDarkTheme(), useDynamicColors = true) {
         ValidationScreen(
             screenState = ValidationScreenState.EMPTY.copy(
                 phoneMask = "+7 (***) ***-**-21",
@@ -312,3 +315,4 @@ private fun ValidationScreenPreview() {
             validationType = ValidationType.SMS
         )
     }
+}

feature/chatmaterials/src/main/kotlin/dev/meloda/fast/chatmaterials/ChatMaterialsViewModel.kt

@@ -9,12 +9,16 @@ import dev.meloda.fast.chatmaterials.navigation.ChatMaterials
 import dev.meloda.fast.chatmaterials.util.asPresentation
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
+import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
+import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
+import dev.meloda.fast.common.paging.loadingFlags
+import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.data.State
+import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.domain.MessagesUseCase
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
-import dev.meloda.fast.network.VkErrorCode
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 
@@ -89,11 +93,14 @@ class ChatMaterialsViewModelImpl(
             state.processState(
                 error = ::handleError,
                 success = { response ->
-                    val itemsCountSufficient = response.size == LOAD_COUNT
+                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
                     canPaginate.setValue { itemsCountSufficient }
 
-                    val paginationExhausted = !itemsCountSufficient
-                            && screenState.value.materials.isNotEmpty()
+                    val paginationExhausted = isPaginationExhaustedPage(
+                        pageSize = LOAD_COUNT,
+                        loadedCount = response.size,
+                        hasExistingItems = screenState.value.materials.isNotEmpty()
+                    )
 
                     val loadedMaterials = response.mapNotNull(VkAttachmentHistoryMessage::asPresentation)
 
@@ -107,64 +114,27 @@ class ChatMaterialsViewModelImpl(
                         }
                     )
 
-                    if (offset == 0) {
-                        screenState.setValue {
-                            newState.copy(materials = loadedMaterials)
-                        }
-                    } else {
                     screenState.setValue {
                         newState.copy(
-                                materials = newState.materials.plus(loadedMaterials)
+                            materials = mergePage(newState.materials, loadedMaterials, offset)
                         )
                     }
                 }
-                }
             )
 
+            val flags = loadingFlags(offset, state.isLoading())
             screenState.setValue { old ->
                 old.copy(
-                    isLoading = offset == 0 && state.isLoading(),
-                    isPaginating = offset > 0 && state.isLoading()
+                    isLoading = flags.isLoading,
+                    isPaginating = flags.isPaginating
                 )
             }
         }
     }
 
     private fun handleError(error: State.Error) {
-        when (error) {
-            is State.Error.ApiError -> {
-                when (error.errorCode) {
-                    VkErrorCode.USER_AUTHORIZATION_FAILED -> {
-                        baseError.setValue { BaseError.SessionExpired }
-                    }
-
-                    else -> {
-                        baseError.setValue {
-                            BaseError.SimpleError(message = error.errorMessage)
-                        }
-                    }
-                }
-            }
-
-            State.Error.ConnectionError -> {
-                baseError.setValue {
-                    BaseError.SimpleError(message = "Connection error")
-                }
-            }
-
-            State.Error.InternalError -> {
-                baseError.setValue {
-                    BaseError.SimpleError(message = "Internal error")
-                }
-            }
-
-            State.Error.UnknownError -> {
-                baseError.setValue {
-                    BaseError.SimpleError(message = "Unknown error")
-                }
-            }
-
-            else -> Unit
+        VkUtils.parseError(error)?.let { newBaseError ->
+            baseError.setValue { newBaseError }
         }
     }
 

feature/convos/src/main/kotlin/dev/meloda/fast/convos/ConvosViewModel.kt

@@ -8,12 +8,16 @@ import androidx.lifecycle.viewModelScope
 import coil.ImageLoader
 import coil.request.ImageRequest
 import com.conena.nanokt.collections.indexOfFirstOrNull
-import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.common.extensions.createTimerFlow
 import dev.meloda.fast.common.extensions.findWithIndex
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
+import dev.meloda.fast.common.extensions.launchDbRefresh
 import dev.meloda.fast.common.extensions.updateValue
+import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
+import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
+import dev.meloda.fast.common.paging.loadingFlags
+import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.convos.model.ConvoDialog
 import dev.meloda.fast.convos.model.ConvoNavigation
 import dev.meloda.fast.convos.model.ConvosScreenState
@@ -23,8 +27,7 @@ import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.ConvoUseCase
-import dev.meloda.fast.domain.LoadConvosByIdUseCase
-import dev.meloda.fast.domain.LongPollUpdatesParser
+import dev.meloda.fast.domain.LongPollUpdatesReducer
 import dev.meloda.fast.domain.MessagesUseCase
 import dev.meloda.fast.domain.util.asPresentation
 import dev.meloda.fast.domain.util.extractAvatar
@@ -40,20 +43,21 @@ import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.SharingStarted
 import kotlinx.coroutines.flow.asStateFlow
 import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.stateIn
 import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
 
 class ConvosViewModel(
-    updatesParser: LongPollUpdatesParser,
+    updatesReducer: LongPollUpdatesReducer,
     private val filter: ConvosFilter,
     private val convoUseCase: ConvoUseCase,
     private val messagesUseCase: MessagesUseCase,
     private val resources: Resources,
     private val userSettings: UserSettings,
     private val imageLoader: ImageLoader,
-    private val applicationContext: Context,
-    private val loadConvosByIdUseCase: LoadConvosByIdUseCase
+    private val applicationContext: Context
 ) : ViewModel() {
     private val _screenState = MutableStateFlow(ConvosScreenState.EMPTY)
     val screenState = _screenState.asStateFlow()
@@ -94,15 +98,15 @@ class ConvosViewModel(
 
         loadConvos()
 
-        updatesParser.onNewMessage(::handleNewMessage)
-        updatesParser.onMessageEdited(::handleEditedMessage)
-        updatesParser.onMessageIncomingRead(::handleReadIncomingMessage)
-        updatesParser.onMessageOutgoingRead(::handleReadOutgoingMessage)
-        updatesParser.onInteractions(::handleInteraction)
-        updatesParser.onChatMajorChanged(::handleChatMajorChanged)
-        updatesParser.onChatMinorChanged(::handleChatMinorChanged)
-        updatesParser.onChatCleared(::handleChatClearing)
-        updatesParser.onChatArchived(::handleChatArchived)
+        updatesReducer.newMessages.onEach(::handleNewMessage).launchIn(viewModelScope)
+        updatesReducer.messageEdited.onEach(::handleEditedMessage).launchIn(viewModelScope)
+        updatesReducer.messageIncomingRead.onEach(::handleReadIncomingMessage).launchIn(viewModelScope)
+        updatesReducer.messageOutgoingRead.onEach(::handleReadOutgoingMessage).launchIn(viewModelScope)
+        updatesReducer.interactions.onEach(::handleInteraction).launchIn(viewModelScope)
+        updatesReducer.chatMajorChanged.onEach(::handleChatMajorChanged).launchIn(viewModelScope)
+        updatesReducer.chatMinorChanged.onEach(::handleChatMinorChanged).launchIn(viewModelScope)
+        updatesReducer.chatCleared.onEach(::handleChatClearing).launchIn(viewModelScope)
+        updatesReducer.chatArchived.onEach(::handleChatArchived).launchIn(viewModelScope)
 
         userSettings.useContactNames.listenValue(viewModelScope) {
             syncUiConvos()
@@ -253,6 +257,10 @@ class ConvosViewModel(
     private fun loadConvos(
         offset: Int = currentOffset.value
     ) {
+        if (offset == 0) {
+            refreshConvosFromDb()
+        }
+
         convoUseCase.getConvos(
             count = LOAD_COUNT,
             offset = offset,
@@ -264,17 +272,12 @@ class ConvosViewModel(
                     _baseError.update { newBaseError }
                 },
                 success = { response ->
-                    val convos = response
-                    val fullConvos = if (offset == 0) {
-                        convos
-                    } else {
-                        this.convos.value.plus(convos)
-                    }
-
-                    val itemsCountSufficient = response.size == LOAD_COUNT
-
-                    val paginationExhausted = !itemsCountSufficient &&
-                            this.convos.value.isNotEmpty()
+                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
+                    val paginationExhausted = isPaginationExhaustedPage(
+                        pageSize = LOAD_COUNT,
+                        loadedCount = response.size,
+                        hasExistingItems = this.convos.value.isNotEmpty()
+                    )
 
                     _screenState.updateValue {
                         copy(isPaginationExhausted = paginationExhausted)
@@ -293,16 +296,17 @@ class ConvosViewModel(
 
                     convoUseCase.storeConvos(response)
 
-                    _convos.emit(fullConvos)
+                    _convos.emit(mergePage(this.convos.value, response, offset))
                     syncUiConvos()
                     _canPaginate.setValue { itemsCountSufficient }
                 }
             )
 
+            val flags = loadingFlags(offset, state.isLoading())
             _screenState.setValue { old ->
                 old.copy(
-                    isLoading = offset == 0 && state.isLoading(),
-                    isPaginating = offset > 0 && state.isLoading()
+                    isLoading = flags.isLoading,
+                    isPaginating = flags.isPaginating
                 )
             }
         }
@@ -313,14 +317,10 @@ class ConvosViewModel(
             state.processState(
                 error = {},
                 success = {
-                    val newConvos = convos.value.toMutableList()
-                    val convoIndex =
-                        newConvos.indexOfFirstOrNull { it.id == peerId }
-                            ?: return@processState
-
-                    newConvos.removeAt(convoIndex)
-                    _convos.update { newConvos.sorted() }
-                    syncUiConvos()
+                    viewModelScope.launch {
+                        convoUseCase.deleteLocalConvo(peerId)
+                        refreshConvosFromDb()
+                    }
                 }
             )
             _screenState.emit(screenState.value.copy(isLoading = state.isLoading()))
@@ -333,9 +333,11 @@ class ConvosViewModel(
                 state.processState(
                     error = {},
                     success = {
-                        handleChatMajorChanged(
-                            LongPollParsedEvent.ChatMajorChanged(
-                                peerId = peerId,
+                        viewModelScope.launch {
+                            convoUseCase.getLocalConvoById(peerId)?.let { convo ->
+                                convoUseCase.storeConvos(
+                                    listOf(
+                                        convo.copy(
                                             majorId = if (pin) {
                                                 pinnedConvosCount.value.plus(1) * 16
                                             } else {
@@ -343,6 +345,10 @@ class ConvosViewModel(
                                             }
                                         )
                                     )
+                                )
+                            }
+                            refreshConvosFromDb()
+                        }
                     }
                 )
 
@@ -356,145 +362,35 @@ class ConvosViewModel(
                 state.processState(
                     error = {},
                     success = {
-                        convos.value.find { it.id == peerId }?.let { convo ->
-                            handleChatArchived(
-                                LongPollParsedEvent.ChatArchived(
-                                    convo = convo,
-                                    archived = archive
+                        viewModelScope.launch {
+                            convoUseCase.getLocalConvoById(peerId)?.let { convo ->
+                                convoUseCase.storeConvos(
+                                    listOf(
+                                        convo.copy(isArchived = archive)
                                     )
                                 )
                             }
+                            refreshConvosFromDb()
+                        }
                     }
                 )
             }
     }
 
-    // TODO: 03-Apr-25, Danil Nikolaev: handle business messages
     private fun handleNewMessage(event: LongPollParsedEvent.NewMessage) {
-        val message = event.message
-
-        val newConvos = convos.value.toMutableList()
-        val convoIndex =
-            newConvos.indexOfFirstOrNull { it.id == message.peerId }
-
-        if (convoIndex == null) {
-            if (event.inArchive != (filter == ConvosFilter.ARCHIVE)) return
-
-            loadConvosByIdUseCase(
-                peerIds = listOf(message.peerId),
-                extended = true,
-                fields = VkConstants.ALL_FIELDS
-            ).listenValue(viewModelScope) { state ->
-                state.processState(
-                    error = {},
-                    success = { response ->
-                        val convo = (response.firstOrNull() ?: return@listenValue)
-                            .copy(lastMessage = message)
-
-                        newConvos.add(pinnedConvosCount.value, convo)
-                        _convos.update { newConvos.sorted() }
-                        syncUiConvos()
-                    }
-                )
-            }
-        } else {
-            val convo = newConvos[convoIndex]
-            var newConvo = convo.copy(
-                lastMessage = message,
-                lastMessageId = message.id,
-                lastCmId = message.cmId,
-                unreadCount = if (message.isOut) convo.unreadCount
-                else convo.unreadCount + 1
-            )
-
-            interactionsTimers[convo.id]?.let { job ->
-                if (job.interactionType == InteractionType.Typing
-                    && message.fromId in convo.interactionIds
-                ) {
-                    val newInteractionIds = newConvo.interactionIds.filter { id ->
-                        id != message.fromId
-                    }
-
-                    newConvo = newConvo.copy(
-                        interactionType = if (newInteractionIds.isEmpty()) -1 else {
-                            newConvo.interactionType
-                        },
-                        interactionIds = newInteractionIds
-                    )
-                }
-            }
-
-            if (convo.isPinned()) {
-                newConvos[convoIndex] = newConvo
-            } else {
-                newConvos.removeAt(convoIndex)
-
-                val toPosition = pinnedConvosCount.value
-                newConvos.add(toPosition, newConvo)
-            }
-
-            _convos.update { newConvos.sorted() }
-            syncUiConvos()
-        }
+        refreshConvosFromDb()
     }
 
     private fun handleEditedMessage(event: LongPollParsedEvent.MessageEdited) {
-        val message = event.message
-        val newConvos = convos.value.toMutableList()
-
-        val convoIndex = newConvos.indexOfFirstOrNull { it.id == message.peerId }
-        if (convoIndex == null) { // диалога нет в списке
-            //  pizdets
-        } else {
-            val convo = newConvos[convoIndex]
-            newConvos[convoIndex] = convo.copy(
-                lastMessage = message,
-                lastMessageId = message.id,
-                lastCmId = message.cmId
-            )
-            _convos.update { newConvos }
-            syncUiConvos()
-        }
+        refreshConvosFromDb()
     }
 
     private fun handleReadIncomingMessage(event: LongPollParsedEvent.IncomingMessageRead) {
-        val newConvos = convos.value.toMutableList()
-
-        val convoIndex =
-            newConvos.indexOfFirstOrNull { it.id == event.peerId }
-
-        if (convoIndex == null) { // диалога нет в списке
-            // pizdets
-        } else {
-            newConvos[convoIndex] =
-                newConvos[convoIndex].copy(
-                    inReadCmId = event.cmId,
-                    unreadCount = event.unreadCount
-                )
-
-            _convos.update { newConvos }
-            syncUiConvos()
-        }
+        refreshConvosFromDb()
     }
 
     private fun handleReadOutgoingMessage(event: LongPollParsedEvent.OutgoingMessageRead) {
-        val newConvos = convos.value.toMutableList()
-
-        val convoIndex =
-            newConvos.indexOfFirstOrNull { it.id == event.peerId }
-
-        if (convoIndex == null) { // диалога нет в списке
-            // pizdets
-        } else {
-            newConvos[convoIndex] =
-                newConvos[convoIndex].copy(
-                    outReadCmId = event.cmId,
-                    unreadCount = event.unreadCount
-                )
-
-            _convos.update { newConvos }
-            syncUiConvos()
-        }
+        refreshConvosFromDb()
     }
 
     private fun handleInteraction(event: LongPollParsedEvent.Interaction) {
@@ -563,88 +459,19 @@ class ConvosViewModel(
     }
 
     private fun handleChatMajorChanged(event: LongPollParsedEvent.ChatMajorChanged) {
-        val newConvos = convos.value.toMutableList()
-        val convoIndex =
-            newConvos.indexOfFirstOrNull { it.id == event.peerId }
-
-        if (convoIndex == null) { // диалога нет в списке
-            // pizdets
-        } else {
-            newConvos[convoIndex] =
-                newConvos[convoIndex].copy(majorId = event.majorId)
-
-            _convos.setValue { newConvos.sorted() }
-            syncUiConvos()
-        }
+        refreshConvosFromDb()
     }
 
     private fun handleChatMinorChanged(event: LongPollParsedEvent.ChatMinorChanged) {
-        val newConvos = convos.value.toMutableList()
-        val convoIndex =
-            newConvos.indexOfFirstOrNull { it.id == event.peerId }
-
-        if (convoIndex == null) { // диалога нет в списке
-            // pizdets
-        } else {
-            newConvos[convoIndex] =
-                newConvos[convoIndex].copy(minorId = event.minorId)
-
-            _convos.setValue { newConvos.sorted() }
-            syncUiConvos()
-        }
+        refreshConvosFromDb()
     }
 
     private fun handleChatClearing(event: LongPollParsedEvent.ChatCleared) {
-        val newConvos = convos.value.toMutableList()
-
-        val convoIndex = newConvos.indexOfFirstOrNull { it.id == event.peerId }
-
-        if (convoIndex == null) { // диалога нет в списке
-            // pizdets
-        } else {
-            newConvos.removeAt(convoIndex)
-
-            _convos.setValue { newConvos.sorted() }
-            syncUiConvos()
-        }
+        refreshConvosFromDb()
     }
 
     private fun handleChatArchived(event: LongPollParsedEvent.ChatArchived) {
-        val convo = event.convo
-
-        val newConvos = convos.value.toMutableList()
-
-        when (filter) {
-            ConvosFilter.BUSINESS_NOTIFY -> Unit
-
-            ConvosFilter.ARCHIVE -> {
-                if (event.archived) {
-                    newConvos.add(0, convo)
-                } else {
-                    val index = newConvos.indexOfFirstOrNull { it.id == convo.id }
-                    if (index == null) return
-
-                    newConvos.removeAt(index)
-                }
-
-                _convos.update { newConvos }
-                syncUiConvos()
-            }
-
-            else -> {
-                if (event.archived) {
-                    val index = newConvos.indexOfFirstOrNull { it.id == convo.id }
-                    if (index == null) return
-
-                    newConvos.removeAt(index)
-                } else {
-                    newConvos.add(pinnedConvosCount.value, convo)
-                }
-
-                _convos.update { newConvos.sorted() }
-                syncUiConvos()
-            }
-        }
+        refreshConvosFromDb()
     }
 
     private fun readConvo(peerId: Long, startMessageId: Long) {
@@ -655,21 +482,42 @@ class ConvosViewModel(
             state.processState(
                 error = {},
                 success = {
-                    val newConvos = convos.value.toMutableList()
-                    val convoIndex =
-                        newConvos.indexOfFirstOrNull { it.id == peerId }
-                            ?: return@listenValue
-
-                    newConvos[convoIndex] =
-                        newConvos[convoIndex].copy(inRead = startMessageId)
-
-                    _convos.update { newConvos }
-                    syncUiConvos()
+                    viewModelScope.launch {
+                        convoUseCase.getLocalConvoById(peerId)?.let { convo ->
+                            convoUseCase.storeConvos(
+                                listOf(
+                                    convo.copy(
+                                        inRead = startMessageId,
+                                        unreadCount = 0
+                                    )
+                                )
+                            )
+                        }
+                        refreshConvosFromDb()
+                    }
                 }
             )
         }
     }
 
+    private fun refreshConvosFromDb() {
+        viewModelScope.launchDbRefresh(
+            load = {
+            val localConvos = convoUseCase.getLocalConvos()
+
+            val filteredConvos = when (filter) {
+                ConvosFilter.ARCHIVE -> localConvos.filter(VkConvo::isArchived)
+                ConvosFilter.UNREAD -> localConvos.filter { !it.isArchived && it.unreadCount > 0 }
+                ConvosFilter.ALL -> localConvos.filterNot(VkConvo::isArchived)
+                ConvosFilter.BUSINESS_NOTIFY -> localConvos
+            }
+
+            _convos.emit(filteredConvos)
+        },
+            after = ::syncUiConvos
+        )
+    }
+
     private fun List<VkConvo>.sorted(): List<VkConvo> {
         val newConvos = toMutableList()
 

feature/convos/src/main/kotlin/dev/meloda/fast/convos/di/ConvosModule.kt

@@ -31,7 +31,6 @@ private fun Scope.createConvosViewModel(filter: ConvosFilter): ConvosViewModel {
         resources = get(),
         userSettings = get(),
         imageLoader = get(),
-        applicationContext = get(),
-        loadConvosByIdUseCase = get()
+        applicationContext = get()
     )
 }

feature/convos/src/main/kotlin/dev/meloda/fast/convos/presentation/ConvosScreen.kt

@@ -53,6 +53,7 @@ import androidx.compose.ui.unit.DpOffset
 import androidx.compose.ui.unit.IntOffset
 import androidx.compose.ui.unit.LayoutDirection
 import androidx.compose.ui.unit.dp
+import com.skydoves.compose.stability.runtime.TraceRecomposition
 import dev.chrisbanes.haze.hazeEffect
 import dev.chrisbanes.haze.hazeSource
 import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi

feature/createchat/src/main/kotlin/dev/meloda/fast/convos/CreateChatViewModel.kt

@@ -7,9 +7,14 @@ import coil.ImageLoader
 import coil.request.ImageRequest
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
+import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
+import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
+import dev.meloda.fast.common.paging.loadingFlags
+import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.convos.model.CreateChatScreenState
 import dev.meloda.fast.data.State
 import dev.meloda.fast.data.UserConfig
+import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.FriendsUseCase
@@ -18,7 +23,6 @@ import dev.meloda.fast.domain.MessagesUseCase
 import dev.meloda.fast.domain.util.asPresentation
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.api.domain.VkUser
-import dev.meloda.fast.network.VkErrorCode
 import dev.meloda.fast.ui.model.vk.UiFriend
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.MutableStateFlow
@@ -156,11 +160,14 @@ class CreateChatViewModel(
                 state.processState(
                 error = ::handleError,
                 success = { response ->
-                        val itemsCountSufficient = response.size == LOAD_COUNT
+                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
                     _canPaginate.setValue { itemsCountSufficient }
 
-                        val paginationExhausted = !itemsCountSufficient &&
-                                screenState.value.friends.isNotEmpty()
+                    val paginationExhausted = isPaginationExhaustedPage(
+                        pageSize = LOAD_COUNT,
+                        loadedCount = response.size,
+                        hasExistingItems = screenState.value.friends.isNotEmpty()
+                    )
 
                         val imagesToPreload =
                             response.mapNotNull { it.photo100.takeIf { p -> !p.isNullOrEmpty() } }
@@ -182,24 +189,19 @@ class CreateChatViewModel(
                         val newState = screenState.value.copy(
                             isPaginationExhausted = paginationExhausted
                         )
-                        if (offset == 0) {
-                            _screenState.setValue {
-                                newState.copy(friends = loadedFriends)
-                            }
-                        } else {
                         _screenState.setValue {
                             newState.copy(
-                                    friends = newState.friends.plus(loadedFriends)
+                                friends = mergePage(newState.friends, loadedFriends, offset)
                             )
                         }
                     }
-                    }
                 )
 
+                val flags = loadingFlags(offset, state.isLoading())
                 _screenState.setValue { old ->
                     old.copy(
-                        isLoading = offset == 0 && state.isLoading(),
-                        isPaginating = offset > 0 && state.isLoading()
+                        isLoading = flags.isLoading,
+                        isPaginating = flags.isPaginating
                     )
                 }
             }
@@ -228,40 +230,8 @@ class CreateChatViewModel(
     }
 
     private fun handleError(error: State.Error) {
-        when (error) {
-            is State.Error.ApiError -> {
-                when (error.errorCode) {
-                    VkErrorCode.USER_AUTHORIZATION_FAILED -> {
-                        _baseError.setValue { BaseError.SessionExpired }
-                    }
-
-                    else -> {
-                        _baseError.setValue {
-                            BaseError.SimpleError(message = error.errorMessage)
-                        }
-                    }
-                }
-            }
-
-            State.Error.ConnectionError -> {
-                _baseError.setValue {
-                    BaseError.SimpleError(message = "Connection error")
-                }
-            }
-
-            State.Error.InternalError -> {
-                _baseError.setValue {
-                    BaseError.SimpleError(message = "Internal error")
-                }
-            }
-
-            State.Error.UnknownError -> {
-                _baseError.setValue {
-                    BaseError.SimpleError(message = "Unknown error")
-                }
-            }
-
-            else -> Unit
+        VkUtils.parseError(error)?.let { newBaseError ->
+            _baseError.setValue { newBaseError }
         }
     }
 

feature/friends/src/main/kotlin/dev/meloda/fast/friends/FriendsViewModel.kt

@@ -4,7 +4,12 @@ import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import dev.meloda.fast.common.extensions.listenValue
 import dev.meloda.fast.common.extensions.setValue
+import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
+import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
+import dev.meloda.fast.common.paging.loadingFlags
+import dev.meloda.fast.common.paging.mergePage
 import dev.meloda.fast.data.State
+import dev.meloda.fast.data.VkUtils
 import dev.meloda.fast.data.processState
 import dev.meloda.fast.datastore.UserSettings
 import dev.meloda.fast.domain.FriendsUseCase
@@ -13,7 +18,6 @@ import dev.meloda.fast.domain.util.asPresentation
 import dev.meloda.fast.friends.model.FriendsScreenState
 import dev.meloda.fast.model.BaseError
 import dev.meloda.fast.model.api.domain.VkUser
-import dev.meloda.fast.network.VkErrorCode
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.flow.update
@@ -80,40 +84,8 @@ abstract class BaseFriendsViewModelImpl : ViewModel(), FriendsViewModel {
     abstract fun loadFriends(offset: Int = currentOffset.value)
 
     protected fun handleError(error: State.Error) {
-        when (error) {
-            is State.Error.ApiError -> {
-                when (error.errorCode) {
-                    VkErrorCode.USER_AUTHORIZATION_FAILED -> {
-                        baseError.setValue { BaseError.SessionExpired }
-                    }
-
-                    else -> {
-                        baseError.setValue {
-                            BaseError.SimpleError(message = error.errorMessage)
-                        }
-                    }
-                }
-            }
-
-            State.Error.ConnectionError -> {
-                baseError.setValue {
-                    BaseError.SimpleError(message = "Connection error")
-                }
-            }
-
-            State.Error.InternalError -> {
-                baseError.setValue {
-                    BaseError.SimpleError(message = "Internal error")
-                }
-            }
-
-            State.Error.UnknownError -> {
-                baseError.setValue {
-                    BaseError.SimpleError(message = "Unknown error")
-                }
-            }
-
-            else -> Unit
+        VkUtils.parseError(error)?.let { newBaseError ->
+            baseError.setValue { newBaseError }
         }
     }
 
@@ -154,11 +126,14 @@ class FriendsViewModelImpl(
             state.processState(
                 error = ::handleError,
                 success = { response ->
-                    val itemsCountSufficient = response.size == LOAD_COUNT
+                    val itemsCountSufficient = canPaginatePage(LOAD_COUNT, response.size)
                     canPaginate.setValue { itemsCountSufficient }
 
-                    val paginationExhausted = !itemsCountSufficient
-                            && screenState.value.friends.isNotEmpty()
+                    val paginationExhausted = isPaginationExhaustedPage(
+                        pageSize = LOAD_COUNT,
+                        loadedCount = response.size,
+                        hasExistingItems = screenState.value.friends.isNotEmpty()
+                    )
 
                     imagesToPreload.setValue {
                         response.mapNotNull(VkUser::photo100)
@@ -174,24 +149,20 @@ class FriendsViewModelImpl(
                         isPaginationExhausted = paginationExhausted
                     )
 
-                    if (offset == 0) {
-                        friends.emit(response)
+                    friends.emit(mergePage(friends.value, response, offset))
                     screenState.setValue {
-                            newState.copy(friends = loadedFriends)
-                        }
-                    } else {
-                        friends.emit(friends.value.plus(response))
-                        screenState.setValue {
-                            newState.copy(friends = newState.friends.plus(loadedFriends))
-                        }
+                        newState.copy(
+                            friends = mergePage(newState.friends, loadedFriends, offset)
+                        )
                     }
                 }
             )
 
+            val flags = loadingFlags(offset, state.isLoading())
             screenState.setValue { old ->
                 old.copy(
-                    isLoading = offset == 0 && state.isLoading(),
-                    isPaginating = offset > 0 && state.isLoading()
+                    isLoading = flags.isLoading,
+                    isPaginating = flags.isPaginating
                 )
             }
         }
@@ -229,10 +200,14 @@ class OnlineFriendsViewModelImpl(
                                 }
                             )
 
+                            val flags = loadingFlags(
+                                offset = offset,
+                                isLoading = onlineState.isLoading() || state.isLoading()
+                            )
                             screenState.setValue { old ->
                                 old.copy(
-                                    isLoading = offset == 0 && (onlineState.isLoading() || state.isLoading()),
-                                    isPaginating = offset > 0 && (onlineState.isLoading() || state.isLoading())
+                                    isLoading = flags.isLoading,
+                                    isPaginating = flags.isPaginating
                                 )
                             }
                         }

feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/MessagesHistoryInteractionHandler.kt

@@ -0,0 +1,267 @@
+package dev.meloda.fast.messageshistory
+
+import android.os.Bundle
+import com.conena.nanokt.collections.indexOfFirstOrNull
+import dev.meloda.fast.common.extensions.getParcelableCompat
+import dev.meloda.fast.common.extensions.setValue
+import dev.meloda.fast.messageshistory.model.MessageDialog
+import dev.meloda.fast.messageshistory.model.MessageOption
+import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
+import dev.meloda.fast.model.api.domain.VkMessage
+import dev.meloda.fast.ui.model.vk.MessageUiItem
+import kotlinx.coroutines.flow.MutableStateFlow
+
+internal class MessagesHistoryInteractionHandler(
+    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
+    private val messages: MutableStateFlow<List<VkMessage>>,
+    private val dialog: MutableStateFlow<MessageDialog?>,
+    private val selectedMessages: MutableStateFlow<List<VkMessage>>,
+    private val uiMessages: MutableStateFlow<List<MessageUiItem>>,
+    private val isNeedToScrollToIndex: MutableStateFlow<Int?>,
+    private val messageActions: MessagesHistoryMessageActions,
+    private val messageTransportActions: MessagesHistoryMessageTransportActions,
+    private val syncUiMessages: () -> Unit
+) {
+    fun onDialogConfirmed(dialog: MessageDialog, bundle: Bundle) {
+        onDialogDismissed(dialog)
+
+        when (dialog) {
+            is MessageDialog.MessageOptions -> Unit
+
+            is MessageDialog.MessageDelete -> {
+                val deleteForEveryone = bundle.getBoolean("everyone")
+
+                if (dialog.message.id <= 0) {
+                    val newMessages = messages.value.toMutableList()
+                    newMessages.remove(dialog.message)
+                    messages.setValue { newMessages }
+                    syncUiMessages()
+                    return
+                }
+
+                messageTransportActions.deleteMessage(
+                    messageIds = listOf(dialog.message.id),
+                    deleteForAll = deleteForEveryone
+                )
+            }
+
+            is MessageDialog.MessagesDelete -> {
+                val deleteForEveryone = bundle.getBoolean("everyone")
+
+                val failedMessages = dialog.messages.filter { it.id <= 0 }
+                val messageIdsToDelete =
+                    dialog.messages
+                        .filter { it.id > 0 }
+                        .map(VkMessage::id)
+
+                messageTransportActions.deleteMessage(
+                    messageIds = messageIdsToDelete,
+                    deleteForAll = deleteForEveryone,
+                    onSuccess = {
+                        val newMessages = messages.value.toMutableList()
+                        newMessages.removeAll(failedMessages)
+                        messages.setValue { newMessages }
+                        selectedMessages.setValue { emptyList() }
+                        syncUiMessages()
+                    }
+                )
+            }
+
+            is MessageDialog.MessagePin -> {
+                messageTransportActions.pinMessage(dialog.messageId)
+            }
+
+            is MessageDialog.MessageUnpin -> {
+                messageTransportActions.unpinMessage(dialog.messageId)
+            }
+
+            is MessageDialog.MessageMarkImportance -> {
+                messageTransportActions.markAsImportant(
+                    messageIds = listOf(dialog.message.id),
+                    important = dialog.isImportant
+                )
+            }
+
+            is MessageDialog.MessageSpam -> {
+                if (dialog.isSpam) {
+                    messageTransportActions.deleteMessage(
+                        messageIds = listOf(dialog.message.id),
+                        spam = true
+                    )
+                } else {
+                    // TODO: 29-Mar-25, Danil Nikolaev: report as not spam
+                }
+            }
+        }
+    }
+
+    fun onDialogDismissed(dialog: MessageDialog) {
+        this.dialog.setValue { null }
+    }
+
+    fun onDialogItemPicked(dialog: MessageDialog, bundle: Bundle) {
+        when (dialog) {
+            is MessageDialog.MessageOptions -> {
+                val cmId = bundle.getLong("cmId")
+
+                when (val option = bundle.getParcelableCompat("option", MessageOption::class)) {
+                    null -> Unit
+
+                    MessageOption.Retry -> {
+                        // TODO: 28-Mar-25, Danil Nikolaev: retry sending
+                    }
+
+                    MessageOption.Reply -> messageActions.replyToMessage(cmId)
+
+                    MessageOption.ForwardHere -> {
+
+                    }
+
+                    MessageOption.Forward -> {
+
+                    }
+
+                    MessageOption.Pin -> {
+                        this.dialog.setValue {
+                            MessageDialog.MessagePin(dialog.message.id)
+                        }
+                    }
+
+                    MessageOption.Unpin -> {
+                        this.dialog.setValue {
+                            MessageDialog.MessageUnpin(dialog.message.id)
+                        }
+                    }
+
+                    MessageOption.Read -> {
+                        messageTransportActions.readMessage(dialog.message)
+                    }
+
+                    MessageOption.Copy -> {
+                        messageTransportActions.copyMessage(dialog.message)
+                    }
+
+                    MessageOption.MarkAsImportant,
+                    MessageOption.UnmarkAsImportant -> {
+                        this.dialog.setValue {
+                            MessageDialog.MessageMarkImportance(
+                                message = dialog.message,
+                                isImportant = option is MessageOption.MarkAsImportant
+                            )
+                        }
+                    }
+
+                    MessageOption.MarkAsSpam,
+                    MessageOption.UnmarkAsSpam -> {
+                        this.dialog.setValue {
+                            MessageDialog.MessageSpam(
+                                message = dialog.message,
+                                isSpam = option is MessageOption.MarkAsSpam
+                            )
+                        }
+                    }
+
+                    MessageOption.Edit -> {
+                        messageActions.editMessage(cmId)
+                        syncUiMessages()
+                    }
+
+                    MessageOption.Delete -> {
+                        this.dialog.setValue {
+                            MessageDialog.MessageDelete(dialog.message)
+                        }
+                    }
+                }
+            }
+
+            is MessageDialog.MessageDelete -> Unit
+            is MessageDialog.MessageUnpin -> Unit
+            is MessageDialog.MessageMarkImportance -> Unit
+            is MessageDialog.MessageSpam -> Unit
+            is MessageDialog.MessagePin -> Unit
+            is MessageDialog.MessagesDelete -> Unit
+        }
+    }
+
+    fun onCloseButtonClicked() {
+        if (selectedMessages.value.isNotEmpty()) {
+            selectedMessages.setValue { emptyList() }
+        }
+
+        if (screenState.value.editCmId != null) {
+            messageActions.stopEditMessage()
+        }
+
+        syncUiMessages()
+    }
+
+    fun onMessageClicked(messageId: Long) {
+        val currentMessage = messages.value.firstOrNull { it.id == messageId } ?: return
+
+        if (selectedMessages.value.isNotEmpty()) {
+            val isSelected = selectedMessages.value.contains(currentMessage)
+
+            selectedMessages.setValue { old ->
+                old.toMutableList().also {
+                    if (isSelected) {
+                        it.remove(currentMessage)
+                    } else {
+                        it.add(currentMessage)
+                    }
+                }
+            }
+            syncUiMessages()
+        } else {
+            dialog.setValue {
+                MessageDialog.MessageOptions(currentMessage)
+            }
+        }
+    }
+
+    fun onMessageLongClicked(messageId: Long) {
+        val currentMessage = messages.value.firstOrNull { it.id == messageId } ?: return
+
+        val isSelected = selectedMessages.value.contains(currentMessage)
+        if (isSelected) return
+
+        selectedMessages.setValue { old ->
+            old.toMutableList().also {
+                it.add(currentMessage)
+            }
+        }
+        syncUiMessages()
+    }
+
+    fun onEditSelectedMessageClicked() {
+        val cmId = selectedMessages.value.firstOrNull()?.cmId ?: return
+
+        selectedMessages.setValue { emptyList() }
+
+        messageActions.editMessage(cmId)
+
+        syncUiMessages()
+    }
+
+    fun onDeleteSelectedMessagesClicked() {
+        dialog.setValue {
+            MessageDialog.MessagesDelete(selectedMessages.value)
+        }
+    }
+
+    fun onPinnedMessageClicked(messageId: Long) {
+        val messageIndex = uiMessages.value.indexOfFirstOrNull {
+            it is MessageUiItem.Message && it.id == messageId
+        }
+
+        if (messageIndex != null) {
+            isNeedToScrollToIndex.setValue { messageIndex }
+        }
+    }
+
+    fun onUnpinMessageClicked() {
+        val pinnedMessageId = screenState.value.pinnedMessage?.id ?: return
+        dialog.setValue {
+            MessageDialog.MessageUnpin(pinnedMessageId)
+        }
+    }
+}

feature/messageshistory/src/main/kotlin/dev/meloda/fast/messageshistory/MessagesHistoryLoaders.kt

@@ -0,0 +1,179 @@
+package dev.meloda.fast.messageshistory
+
+import android.util.Log
+import dev.meloda.fast.common.VkConstants
+import dev.meloda.fast.common.extensions.listenValue
+import dev.meloda.fast.common.extensions.launchDbRefresh
+import dev.meloda.fast.common.extensions.setValue
+import dev.meloda.fast.common.paging.canPaginate as canPaginatePage
+import dev.meloda.fast.common.paging.isPaginationExhausted as isPaginationExhaustedPage
+import dev.meloda.fast.common.paging.loadingFlags
+import dev.meloda.fast.common.paging.mergePage
+import dev.meloda.fast.common.provider.ResourceProvider
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.VkUtils
+import dev.meloda.fast.data.processState
+import dev.meloda.fast.datastore.AppSettings
+import dev.meloda.fast.domain.ConvoUseCase
+import dev.meloda.fast.domain.MessagesUseCase
+import dev.meloda.fast.domain.util.extractAvatar
+import dev.meloda.fast.domain.util.extractTitle
+import dev.meloda.fast.messageshistory.model.MessagesHistoryScreenState
+import dev.meloda.fast.model.BaseError
+import dev.meloda.fast.model.api.domain.VkMessage
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+
+internal class MessagesHistoryLoaders(
+    private val convoUseCase: ConvoUseCase,
+    private val messagesUseCase: MessagesUseCase,
+    private val resourceProvider: ResourceProvider,
+    private val screenState: MutableStateFlow<MessagesHistoryScreenState>,
+    private val messages: MutableStateFlow<List<VkMessage>>,
+    private val imagesToPreload: MutableStateFlow<List<String>>,
+    private val canPaginate: MutableStateFlow<Boolean>,
+    private val baseError: MutableStateFlow<BaseError?>,
+    private val scope: CoroutineScope,
+    private val syncUiMessages: () -> Unit,
+    private val onPinnedMessage: (VkMessage?) -> Unit,
+) {
+    fun loadConvo() {
+        Log.d("MessagesHistoryViewModelImpl", "loadConvo()")
+
+        scope.launchDbRefresh(
+            load = {
+                convoUseCase.getLocalConvoById(screenState.value.convoId)?.let { convo ->
+                    val title = convo.extractTitle(
+                        useContactName = AppSettings.General.useContactNames,
+                        resources = resourceProvider.resources
+                    )
+                    val avatar = convo.extractAvatar()
+
+                    screenState.setValue { old ->
+                        old.copy(
+                            convo = convo,
+                            title = title,
+                            avatar = avatar
+                        )
+                    }
+
+                    onPinnedMessage(convo.pinnedMessage)
+                }
+            },
+            after = {}
+        )
+
+        convoUseCase.getById(
+            peerIds = listOf(screenState.value.convoId),
+            extended = true,
+            fields = VkConstants.ALL_FIELDS
+        ).listenValue(scope) { state ->
+            state.processState(
+                error = ::handleError,
+                success = { response ->
+                    val convo = response.firstOrNull() ?: return@listenValue
+                    val title = convo.extractTitle(
+                        useContactName = AppSettings.General.useContactNames,
+                        resources = resourceProvider.resources
+                    )
+                    val avatar = convo.extractAvatar()
+
+                    screenState.setValue { old ->
+                        old.copy(
+                            convo = convo,
+                            title = title,
+                            avatar = avatar
+                        )
+                    }
+
+                    onPinnedMessage(convo.pinnedMessage)
+                }
+            )
+        }
+    }
+
+    fun loadMessagesHistory(offset: Int) {
+        Log.d("MessagesHistoryViewModel", "loadMessagesHistory: $offset")
+
+        if (offset == 0) {
+            scope.launchDbRefresh(
+                load = {
+                    val cachedMessages = messagesUseCase.getLocalMessages(screenState.value.convoId)
+                    if (cachedMessages.isNotEmpty()) {
+                        messages.emit(cachedMessages.sorted())
+                    }
+                },
+                after = {
+                    if (messages.value.isNotEmpty()) {
+                        syncUiMessages()
+                    }
+                }
+            )
+        }
+
+        messagesUseCase.getMessagesHistory(
+            convoId = screenState.value.convoId,
+            count = MessagesHistoryViewModelImpl.MESSAGES_LOAD_COUNT,
+            offset = offset,
+        ).listenValue(scope) { state ->
+            state.processState(
+                error = ::handleError,
+                success = { response ->
+                    val messages = response.messages
+                    val fullMessages = mergePage(this.messages.value, messages, offset)
+                        .sorted()
+
+                    imagesToPreload.setValue {
+                        messages.mapNotNull { it.extractAvatar().extractUrl() }
+                    }
+
+                    messagesUseCase.storeMessages(messages)
+                    convoUseCase.storeConvos(response.convos)
+
+                    val itemsCountSufficient = canPaginatePage(
+                        MessagesHistoryViewModelImpl.MESSAGES_LOAD_COUNT,
+                        messages.size
+                    )
+                    val paginationExhausted = isPaginationExhaustedPage(
+                        pageSize = MessagesHistoryViewModelImpl.MESSAGES_LOAD_COUNT,
+                        loadedCount = messages.size,
+                        hasExistingItems = this.messages.value.isNotEmpty()
+                    )
+                    screenState.setValue { old ->
+                        old.copy(isPaginationExhausted = paginationExhausted)
+                    }
+
+                    this.messages.emit(fullMessages)
+                    syncUiMessages()
+                    canPaginate.setValue { itemsCountSufficient }
+                }
+            )
+
+            val flags = loadingFlags(offset, state.isLoading())
+            screenState.setValue { old ->
+                old.copy(
+                    isLoading = flags.isLoading,
+                    isPaginating = flags.isPaginating
+                )
+            }
+        }
+    }
+
+    private fun handleError(error: State.Error) {
+        VkUtils.parseError(error)?.let { newBaseError ->
+            baseError.setValue { newBaseError }
+        }
+    }
+
+    private fun List<VkMessage>.sorted(): List<VkMessage> {
+        return sortedWith { m1, m2 ->
+            val dateDiff = m2.date - m1.date
+            if (dateDiff != 0) {
+                dateDiff
+            } else {
+                val idDiff = m2.id - m1.id
+                idDiff.toInt()
+            }
+        }
+    }
+}