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

@@ -1,10 +1,10 @@
 name: Android CI Build
 
 on:
-  push:
-    branches: [ "master", "hotfix/*", "feature/*" ]
-  pull_request:
-    branches: [ "master", "hotfix/*", "feature/*" ]
+  workflow_dispatch:
+
+permissions:
+  contents: read
 
 env:
   KEYSTORE_PASSWORD: ${{ secrets.KEYSTORE_PASSWORD }}
@@ -17,10 +17,10 @@ jobs:
     name: Build artifacts
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: '21'
           distribution: 'temurin'
@@ -32,17 +32,31 @@ jobs:
       - name: Build and sign release APK
         run: ./gradlew assembleRelease
 
-      - name: Upload release APK
-        uses: actions/upload-artifact@v4
+      - name: Find generated release APK name
+        id: find_apk_release
+        run: |
+          APK_PATH=$(find app/build/outputs/apk/release -name "*.apk" | head -n 1)
+          echo "APK_PATH=$APK_PATH" >> $GITHUB_ENV
+          echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
+
+      - name: Upload APK with original name
+        uses: actions/upload-artifact@v7
         with:
-          name: app-release.apk
-          path: app/build/outputs/apk/release/app-release.apk
+          name: ${{ env.APK_NAME }}
+          path: ${{ env.APK_PATH }}
 
       - name: Build and sign debug APK
         run: ./gradlew assembleDebug
 
-      - name: Upload debug APK
-        uses: actions/upload-artifact@v4
+      - name: Find generated debug APK name
+        id: find_apk_debug
+        run: |
+            APK_PATH=$(find app/build/outputs/apk/debug -name "*.apk" | head -n 1)
+            echo "APK_PATH=$APK_PATH" >> $GITHUB_ENV
+            echo "APK_NAME=$(basename $APK_PATH)" >> $GITHUB_ENV
+
+      - name: Upload APK with original name
+        uses: actions/upload-artifact@v7
         with:
-          name: app-debug.apk
-          path: app/build/outputs/apk/debug/app-debug.apk
+          name: ${{ env.APK_NAME }}
+          path: ${{ env.APK_PATH }}

.github/workflows/create_release.yml

@@ -1,6 +1,9 @@
 name: Android CI Release
+permissions:
+  contents: read
 
 on:
+  workflow_dispatch:
   push:
     branches: [ "release/*"]
 
@@ -15,10 +18,10 @@ jobs:
     name: Build artifacts
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
 
       - name: set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/setup-java@v5
         with:
           java-version: '21'
           distribution: 'temurin'
@@ -31,7 +34,7 @@ jobs:
         run: ./gradlew assembleRelease
 
       - name: Upload release APK
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.apk
           path: app/build/outputs/apk/release/app-release.apk
@@ -40,7 +43,7 @@ jobs:
         run: ./gradlew bundleRelease
 
       - name: Upload release Bundle
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v7
         with:
           name: app-release.aab
           path: app/build/outputs/bundle/release/app-release.aab

README.md

@@ -7,15 +7,17 @@ Unofficial messenger for russian social network VKontakte
     - [x] 2FA support
         - [x] Resend otp
     - [x] Captcha support
-    - [ ] Support for new authorization with service and refresh tokens
+    - [x] Support for new authorization with service and refresh tokens
+    - [ ] Handle token expiration
+    - [x] Ability to export/import tokens
 - [x] Conversations list
     - [x] Pagination
     - [x] Manual refresh
     - [x] Pin & unpin conversations
     - [x] Delete conversations
-    - [ ] Archive
-        - [ ] View archived conversations
-        - [ ] Archive & unarchive conversations
+    - [x] Archive
+        - [x] View archived conversations
+        - [x] Archive & unarchive conversations
 - [x] Friends list
     - [x] Sort alphabetically, by priority or random
     - [x] Separate tab with only friends who are online
@@ -30,17 +32,24 @@ Unofficial messenger for russian social network VKontakte
         - [x] Read status
         - [x] Edit status
         - [x] Sending status
-        - [ ] Message's attachments
-            - [ ] Photo
-            - [ ] Video
-            - [ ] Audio
-            - [ ] File
-            - [ ] Link
+        - [x] Message's attachments
+            - [x] Photo
+            - [x] Video
+            - [x] Audio
+            - [x] File
+            - [x] Link
+            - [x] Sticker
+            - [x] Reply
+            - [ ] Forwarded messages
+            - [ ] Wall post
+            - [ ] Comment in wall post
+            - [ ] Poll
             - [ ] TODO
     - [x] Send messages
     - [x] Pinned message
     - [x] Pin & unpin messages
-    - [ ] Reply to message
+    - [x] Reply to message
+    - [x] Swipe to reply to message
     - [x] Delete message
     - [x] Select multiple messages
         - [x] Delete
@@ -55,7 +64,7 @@ Unofficial messenger for russian social network VKontakte
     - [x] View attachments
         - [x] Open photo
             - [x] Internal viewer
-            - [ ] External viewer
+            - [x] External viewer
         - [ ] Open video in external player
         - [ ] TODO
 - [ ] Caching

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

@@ -1,3 +1,4 @@
+import com.android.build.gradle.internal.api.BaseVariantOutputImpl
 import java.util.Properties
 
 plugins {
@@ -12,8 +13,8 @@ android {
     defaultConfig {
         applicationId = "dev.meloda.fastvk"
 
-        versionCode = libs.versions.versionCode.get().toInt()
-        versionName = libs.versions.versionName.get()
+        versionCode = 11
+        versionName = "0.2.3"
     }
 
     signingConfigs {
@@ -58,6 +59,18 @@ android {
         }
     }
 
+//    applicationVariants.all {
+//        outputs.all {
+//            val date = System.currentTimeMillis() / 1000
+//            val buildType = buildType.name
+//            val appVersion = versionName
+//            val appVersionCode = versionCode
+//
+//            val newApkName = "app-$buildType-v$appVersion($appVersionCode)-$date.apk"
+//            (this as? BaseVariantOutputImpl)?.outputFileName = newApkName
+//        }
+//    }
+
     packaging {
         resources {
             excludes += "/META-INF/{AL2.0,LGPL2.1}"
@@ -66,10 +79,13 @@ android {
 }
 
 dependencies {
+    implementation(libs.acra.email)
+    implementation(libs.acra.dialog)
+
     implementation(projects.feature.auth)
 
     implementation(projects.feature.chatmaterials)
-    implementation(projects.feature.conversations)
+    implementation(projects.feature.convos)
     implementation(projects.feature.languagepicker)
     implementation(projects.feature.messageshistory)
     implementation(projects.feature.photoviewer)

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

@@ -5,18 +5,17 @@ import android.content.res.Resources
 import android.os.PowerManager
 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
 import dev.meloda.fast.common.provider.Provider
 import dev.meloda.fast.common.provider.ResourceProvider
 import dev.meloda.fast.common.provider.ResourceProviderImpl
-import dev.meloda.fast.conversations.di.conversationsModule
-import dev.meloda.fast.conversations.di.createChatModule
+import dev.meloda.fast.convos.di.convosModule
+import dev.meloda.fast.convos.di.createChatModule
 import dev.meloda.fast.domain.di.domainModule
 import dev.meloda.fast.friends.di.friendsModule
 import dev.meloda.fast.languagepicker.di.languagePickerModule
@@ -33,13 +32,12 @@ import org.koin.core.qualifier.qualifier
 import org.koin.dsl.bind
 import org.koin.dsl.module
 
+@OptIn(ExperimentalCoilApi::class)
 val applicationModule = module {
     includes(domainModule)
     includes(
-        loginModule,
-        validationModule,
-        captchaModule,
-        conversationsModule,
+        authModule,
+        convosModule,
         settingsModule,
         messagesHistoryModule,
         photoViewModule,
@@ -66,6 +64,7 @@ val applicationModule = module {
         ImageLoader.Builder(get())
             .crossfade(true)
             .build()
+            .also { it.diskCache?.directory?.toFile()?.listFiles() }
     }
 
     singleOf(::LongPollControllerImpl) bind LongPollController::class

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

@@ -2,15 +2,15 @@ package dev.meloda.fast.navigation
 
 import androidx.navigation.NavGraphBuilder
 import androidx.navigation.compose.composable
-import dev.meloda.fast.conversations.navigation.ConversationsGraph
+import dev.meloda.fast.convos.navigation.ConvoGraph
 import dev.meloda.fast.friends.navigation.Friends
 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 as UiR
 
 @Serializable
 object MainGraph
@@ -21,28 +21,28 @@ object Main
 fun NavGraphBuilder.mainScreen(
     onError: (BaseError) -> Unit,
     onSettingsButtonClicked: () -> Unit,
-    onNavigateToMessagesHistory: (conversationId: Long) -> Unit,
+    onNavigateToMessagesHistory: (convoId: Long) -> Unit,
     onPhotoClicked: (url: String) -> Unit,
     onMessageClicked: (userid: Long) -> Unit,
     onNavigateToCreateChat: () -> Unit
 ) {
     val navigationItems = ImmutableList.of(
         BottomNavigationItem(
-            titleResId = UiR.string.title_friends,
-            selectedIconResId = UiR.drawable.baseline_people_alt_24,
-            unselectedIconResId = UiR.drawable.outline_people_alt_24,
+            titleResId = R.string.title_friends,
+            selectedIconResId = R.drawable.ic_group_fill_round_24,
+            unselectedIconResId = R.drawable.ic_group_round_24,
             route = Friends,
         ),
         BottomNavigationItem(
-            titleResId = UiR.string.title_conversations,
-            selectedIconResId = UiR.drawable.baseline_chat_24,
-            unselectedIconResId = UiR.drawable.outline_chat_24,
-            route = ConversationsGraph
+            titleResId = R.string.title_convos,
+            selectedIconResId = R.drawable.ic_mail_fill_round_24,
+            unselectedIconResId = R.drawable.ic_mail_round_24,
+            route = ConvoGraph
         ),
         BottomNavigationItem(
-            titleResId = UiR.string.title_profile,
-            selectedIconResId = UiR.drawable.baseline_account_circle_24,
-            unselectedIconResId = UiR.drawable.outline_account_circle_24,
+            titleResId = R.string.title_profile,
+            selectedIconResId = R.drawable.ic_account_circle_fill_round_24,
+            unselectedIconResId = R.drawable.ic_account_circle_round_24,
             route = Profile
         )
     )

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

@@ -4,55 +4,29 @@ import android.Manifest
 import android.annotation.SuppressLint
 import android.app.NotificationChannel
 import android.app.NotificationManager
-import android.content.Context
 import android.content.Intent
 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
 import androidx.appcompat.app.AppCompatActivity
-import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.platform.LocalContext
 import androidx.core.content.ContextCompat
 import androidx.lifecycle.compose.LifecycleResumeEffect
-import androidx.lifecycle.compose.collectAsStateWithLifecycle
-import com.conena.nanokt.android.content.pxToDp
 import com.google.accompanist.permissions.ExperimentalPermissionsApi
-import com.google.accompanist.permissions.isGranted
-import com.google.accompanist.permissions.rememberPermissionState
 import dev.meloda.fast.MainViewModel
 import dev.meloda.fast.MainViewModelImpl
 import dev.meloda.fast.common.AppConstants
-import dev.meloda.fast.common.LongPollController
-import dev.meloda.fast.common.model.LongPollState
 import dev.meloda.fast.datastore.AppSettings
-import dev.meloda.fast.datastore.UserSettings
-import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.service.OnlineService
 import dev.meloda.fast.service.longpolling.LongPollingService
-import dev.meloda.fast.ui.model.DeviceSize
-import dev.meloda.fast.ui.model.SizeConfig
-import dev.meloda.fast.ui.model.ThemeConfig
-import dev.meloda.fast.ui.theme.AppTheme
-import dev.meloda.fast.ui.theme.LocalSizeConfig
-import dev.meloda.fast.ui.theme.LocalThemeConfig
-import dev.meloda.fast.ui.theme.LocalUser
-import dev.meloda.fast.ui.util.isNeedToEnableDarkMode
+import dev.meloda.fast.ui.R
 import org.koin.androidx.compose.koinViewModel
-import org.koin.compose.KoinContext
-import org.koin.compose.koinInject
-import dev.meloda.fast.ui.R as UiR
 
 class MainActivity : AppCompatActivity() {
 
@@ -89,177 +63,30 @@ class MainActivity : AppCompatActivity() {
         requestNotificationPermissions()
 
         setContent {
-            KoinContext {
-                val context = LocalContext.current
-
-                val userSettings: UserSettings = koinInject()
-                val longPollController: LongPollController = koinInject()
-
-                val longPollCurrentState by longPollController.currentState.collectAsStateWithLifecycle()
-                val longPollStateToApply by longPollController.stateToApply.collectAsStateWithLifecycle()
-
             val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
 
-                val currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
-
             LifecycleResumeEffect(true) {
                 viewModel.onAppResumed(intent)
                 onPauseOrDispose {}
             }
 
-                val permissionState =
-                    rememberPermissionState(permission = Manifest.permission.POST_NOTIFICATIONS)
-
-                val isNeedToCheckPermission by viewModel.isNeedToCheckNotificationsPermission.collectAsStateWithLifecycle()
-                val isNeedToRequestPermission by viewModel.isNeedToRequestNotifications.collectAsStateWithLifecycle()
-
-                LaunchedEffect(isNeedToCheckPermission) {
-                    if (isNeedToCheckPermission) {
-                        viewModel.onPermissionCheckStatus(permissionState.status)
-
-                        if (permissionState.status.isGranted) {
-                            if (longPollCurrentState == LongPollState.InApp) {
-                                toggleLongPollService(false)
-                            }
-
+            RootScreen(
+                toggleLongPollService = { enable, inBackground ->
                     toggleLongPollService(
-                                enable = true,
-                                inBackground = true
+                        enable = enable,
+                        inBackground = inBackground ?: AppSettings.Experimental.longPollInBackground
                     )
-                        }
-                    }
-                }
-
-                LaunchedEffect(isNeedToRequestPermission) {
-                    if (isNeedToRequestPermission) {
-                        viewModel.onPermissionsRequested()
-                        permissionState.launchPermissionRequest()
-                    }
-                }
-
-                LifecycleResumeEffect(longPollStateToApply) {
-                    Log.d("LongPollMainActivity", "longPollStateToApply: $longPollStateToApply")
-                    if (longPollStateToApply != LongPollState.Background) {
-                        if (longPollStateToApply.isLaunched() && longPollCurrentState.isLaunched()
-                            && longPollCurrentState != longPollStateToApply
-                        ) {
-                            toggleLongPollService(false)
-                            Log.d("LongPoll", "recreate()")
-                        }
-
-                        toggleLongPollService(
-                            enable = longPollStateToApply.isLaunched(),
-                            inBackground = longPollStateToApply == LongPollState.Background
+                },
+                toggleOnlineService = ::toggleOnlineService
             )
         }
-
-                    onPauseOrDispose {}
-                }
-
-                val sendOnline by userSettings.sendOnlineStatus.collectAsStateWithLifecycle()
-                LifecycleResumeEffect(sendOnline) {
-                    toggleOnlineService(sendOnline)
-
-                    onPauseOrDispose {
-                        toggleOnlineService(false)
-                    }
-                }
-
-                val deviceWidthDp = remember(true) {
-                    context.resources.displayMetrics.widthPixels.pxToDp()
-                }
-                val deviceHeightDp = remember(true) {
-                    context.resources.displayMetrics.heightPixels.pxToDp()
-                }
-
-                val deviceWidthSize by remember(deviceWidthDp) {
-                    derivedStateOf {
-                        when {
-                            deviceWidthDp <= 360 -> DeviceSize.Small
-                            deviceWidthDp <= 600 -> DeviceSize.Compact
-                            deviceWidthDp <= 840 -> DeviceSize.Medium
-                            else -> DeviceSize.Expanded
-                        }
-                    }
-                }
-
-                val deviceHeightSize by remember(deviceHeightDp) {
-                    derivedStateOf {
-                        when {
-                            deviceHeightDp <= 480 -> DeviceSize.Small
-                            deviceHeightDp <= 700 -> DeviceSize.Compact
-                            deviceHeightDp <= 900 -> DeviceSize.Medium
-                            else -> DeviceSize.Expanded
-                        }
-                    }
-                }
-
-                val sizeConfig by remember(deviceWidthSize, deviceHeightSize) {
-                    mutableStateOf(
-                        SizeConfig(
-                            widthSize = deviceWidthSize,
-                            heightSize = deviceHeightSize
-                        )
-                    )
-                }
-
-                val darkMode by userSettings.darkMode.collectAsStateWithLifecycle()
-                val dynamicColors by userSettings.enableDynamicColors.collectAsStateWithLifecycle()
-                val amoledDark by userSettings.enableAmoledDark.collectAsStateWithLifecycle()
-                val enableBlur by userSettings.useBlur.collectAsStateWithLifecycle()
-                val enableMultiline by userSettings.enableMultiline.collectAsStateWithLifecycle()
-                val useSystemFont by userSettings.useSystemFont.collectAsStateWithLifecycle()
-                val enableAnimations by userSettings.enableAnimations.collectAsStateWithLifecycle()
-
-                val setDarkMode = isNeedToEnableDarkMode(darkMode = darkMode)
-
-                val themeConfig by remember(
-                    darkMode,
-                    dynamicColors,
-                    amoledDark,
-                    enableBlur,
-                    enableMultiline,
-                    setDarkMode,
-                    useSystemFont
-                ) {
-                    derivedStateOf {
-                        ThemeConfig(
-                            darkMode = setDarkMode,
-                            dynamicColors = dynamicColors,
-                            selectedColorScheme = 0,
-                            amoledDark = amoledDark,
-                            enableBlur = enableBlur,
-                            enableMultiline = enableMultiline,
-                            useSystemFont = useSystemFont,
-                            enableAnimations = enableAnimations
-                        )
-                    }
-                }
-
-                CompositionLocalProvider(
-                    LocalThemeConfig provides themeConfig,
-                    LocalSizeConfig provides sizeConfig,
-                    LocalUser provides currentUser
-                ) {
-                    AppTheme(
-                        useDarkTheme = themeConfig.darkMode,
-                        useDynamicColors = themeConfig.dynamicColors,
-                        selectedColorScheme = themeConfig.selectedColorScheme,
-                        useAmoledBackground = themeConfig.amoledDark,
-                        useSystemFont = themeConfig.useSystemFont
-                    ) {
-                        RootScreen(viewModel = viewModel)
-                    }
-                }
-            }
-        }
     }
 
     private fun createNotificationChannels() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val noCategoryName = getString(UiR.string.notification_channel_no_category_name)
+            val noCategoryName = getString(R.string.notification_channel_no_category_name)
             val noCategoryDescriptionText =
-                getString(UiR.string.notification_channel_no_category_description)
+                getString(R.string.notification_channel_no_category_description)
             val noCategoryChannel =
                 NotificationChannel(
                     AppConstants.NOTIFICATION_CHANNEL_UNCATEGORIZED,
@@ -269,9 +96,9 @@ class MainActivity : AppCompatActivity() {
                     description = noCategoryDescriptionText
                 }
 
-            val longPollName = getString(UiR.string.notification_channel_long_polling_service_name)
+            val longPollName = getString(R.string.notification_channel_long_polling_service_name)
             val longPollDescriptionText =
-                getString(UiR.string.notification_channel_long_polling_service_description)
+                getString(R.string.notification_channel_long_polling_service_description)
             val longPollChannel =
                 NotificationChannel(
                     AppConstants.NOTIFICATION_CHANNEL_LONG_POLLING,
@@ -282,7 +109,7 @@ class MainActivity : AppCompatActivity() {
                 }
 
             val notificationManager: NotificationManager =
-                getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+                getSystemService(NOTIFICATION_SERVICE) as NotificationManager
 
             notificationManager.createNotificationChannels(
                 listOf(

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

@@ -1,6 +1,8 @@
 package dev.meloda.fast.presentation
 
 import androidx.activity.compose.BackHandler
+import androidx.activity.compose.LocalActivity
+import androidx.appcompat.app.AppCompatActivity
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
@@ -16,7 +18,6 @@ import androidx.compose.material3.NavigationBarItem
 import androidx.compose.material3.Scaffold
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableIntStateOf
 import androidx.compose.runtime.mutableStateOf
@@ -37,14 +38,14 @@ import dev.chrisbanes.haze.HazeState
 import dev.chrisbanes.haze.hazeEffect
 import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
 import dev.chrisbanes.haze.materials.HazeMaterials
-import dev.meloda.fast.conversations.navigation.Conversations
-import dev.meloda.fast.conversations.navigation.ConversationsGraph
-import dev.meloda.fast.conversations.navigation.conversationsGraph
+import dev.meloda.fast.convos.navigation.ConvoGraph
+import dev.meloda.fast.convos.navigation.convosGraph
 import dev.meloda.fast.friends.navigation.Friends
 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
@@ -60,42 +61,38 @@ fun MainScreen(
     navigationItems: ImmutableList<BottomNavigationItem>,
     onError: (BaseError) -> Unit = {},
     onSettingsButtonClicked: () -> Unit = {},
-    onNavigateToMessagesHistory: (conversationId: Long) -> Unit = {},
+    onNavigateToMessagesHistory: (convoId: Long) -> Unit = {},
     onPhotoClicked: (url: String) -> Unit = {},
     onMessageClicked: (userid: Long) -> Unit = {},
     onNavigateToCreateChat: () -> Unit = {}
 ) {
+    val activity = LocalActivity.current as? AppCompatActivity ?: return
     val theme = LocalThemeConfig.current
-    val hazeState = remember { HazeState() }
+    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) {
-        val index = 1
+    var selectedItemIndex by rememberSaveable {
+        mutableIntStateOf(defaultTabIndex)
+    }
+
+    BackHandler(enabled = selectedItemIndex != defaultTabIndex) {
         val currentRoute = navigationItems[selectedItemIndex].route
 
-        selectedItemIndex = 1
-        navController.navigate(navigationItems[index].route) {
+        selectedItemIndex = defaultTabIndex
+        navController.navigate(navigationItems[selectedItemIndex].route) {
             popUpTo(route = currentRoute) {
                 inclusive = true
             }
         }
     }
 
-    val user = LocalUser.current
-    val profileImageUrl by remember(user) {
-        derivedStateOf { user?.photo100 }
-    }
+    val profileImageUrl = LocalUser.current?.photo100
 
     var tabReselected by remember {
-        mutableStateOf(
-            navigationItems.associate {
-                it.route to false
-            }
-        )
+        mutableStateOf(navigationItems.associate { it.route to false })
     }
 
     Scaffold(
@@ -107,7 +104,7 @@ fun MainScreen(
                         if (theme.enableBlur) {
                             Modifier.hazeEffect(
                                 state = hazeState,
-                                style = HazeMaterials.thick()
+                                style = HazeMaterials.regular(NavigationBarDefaults.containerColor)
                             )
                         } else Modifier
                     ),
@@ -134,7 +131,7 @@ fun MainScreen(
                             }
                         },
                         icon = {
-                            if (index == navigationItems.size - 1) {
+                            if (item.route == Profile) {
                                 var isLoading by remember {
                                     mutableStateOf(true)
                                 }
@@ -194,6 +191,7 @@ fun MainScreen(
                         exitTransition = { fadeOut(animationSpec = tween(200)) }
                     ) {
                         friendsScreen(
+                            activity = activity,
                             onError = onError,
                             onPhotoClicked = onPhotoClicked,
                             onMessageClicked = onMessageClicked,
@@ -203,17 +201,19 @@ fun MainScreen(
                                 }
                             },
                         )
-                        conversationsGraph(
+                        convosGraph(
+                            activity = activity,
                             onError = onError,
                             onNavigateToMessagesHistory = onNavigateToMessagesHistory,
                             onNavigateToCreateChat = onNavigateToCreateChat,
                             onScrolledToTop = {
                                 tabReselected = tabReselected.toMutableMap().also {
-                                    it[ConversationsGraph] = false
+                                    it[ConvoGraph] = false
                                 }
                             }
                         )
                         profileScreen(
+                            activity = activity,
                             onError = onError,
                             onSettingsButtonClicked = onSettingsButtonClicked,
                             onPhotoClicked = onPhotoClicked

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

@@ -1,55 +1,238 @@
 package dev.meloda.fast.presentation
 
+import android.Manifest
 import android.content.Intent
 import android.net.Uri
 import android.provider.Settings
+import androidx.activity.compose.LocalActivity
 import androidx.compose.animation.core.tween
 import androidx.compose.animation.fadeIn
 import androidx.compose.animation.fadeOut
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.derivedStateOf
 import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
 import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalResources
 import androidx.compose.ui.res.stringResource
 import androidx.compose.ui.window.DialogProperties
+import androidx.lifecycle.compose.LifecycleResumeEffect
 import androidx.lifecycle.compose.collectAsStateWithLifecycle
 import androidx.navigation.NavController
 import androidx.navigation.NavHostController
 import androidx.navigation.compose.NavHost
 import androidx.navigation.compose.rememberNavController
+import com.conena.nanokt.android.content.pxToDp
+import com.google.accompanist.permissions.ExperimentalPermissionsApi
+import com.google.accompanist.permissions.isGranted
+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
-import dev.meloda.fast.conversations.navigation.createChatScreen
-import dev.meloda.fast.conversations.navigation.navigateToCreateChat
+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
 import dev.meloda.fast.messageshistory.navigation.messagesHistoryScreen
 import dev.meloda.fast.messageshistory.navigation.navigateToMessagesHistory
+import dev.meloda.fast.model.api.domain.VkUser
 import dev.meloda.fast.navigation.Main
 import dev.meloda.fast.navigation.mainScreen
-import dev.meloda.fast.photoviewer.navigation.navigateToPhotoView
-import dev.meloda.fast.photoviewer.navigation.photoViewScreen
+import dev.meloda.fast.photoviewer.presentation.PhotoViewDialog
 import dev.meloda.fast.settings.navigation.navigateToSettings
 import dev.meloda.fast.settings.navigation.settingsScreen
 import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.common.LocalSizeConfig
+import dev.meloda.fast.ui.model.DeviceSize
+import dev.meloda.fast.ui.model.SizeConfig
+import dev.meloda.fast.ui.model.ThemeConfig
+import dev.meloda.fast.ui.theme.AppTheme
 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.Companion.toImmutableList
+import dev.meloda.fast.ui.util.isNeedToEnableDarkMode
+import org.koin.androidx.compose.koinViewModel
+import org.koin.compose.koinInject
 
+@OptIn(ExperimentalPermissionsApi::class)
 @Composable
 fun RootScreen(
-    navController: NavHostController = rememberNavController(),
-    viewModel: MainViewModel
+    toggleLongPollService: (enable: Boolean, inBackground: Boolean?) -> Unit,
+    toggleOnlineService: (enable: Boolean) -> Unit
 ) {
+    val resources = LocalResources.current
+
+    val userSettings: UserSettings = koinInject()
+    val longPollController: LongPollController = koinInject()
+
+    val longPollCurrentState by longPollController.currentState.collectAsStateWithLifecycle()
+    val longPollStateToApply by longPollController.stateToApply.collectAsStateWithLifecycle()
+
+            val viewModel: MainViewModel = koinViewModel<MainViewModelImpl>()
+
+    val currentUser: VkUser? by viewModel.currentUser.collectAsStateWithLifecycle()
+
+    val permissionState =
+        rememberPermissionState(permission = Manifest.permission.POST_NOTIFICATIONS)
+
+    val isNeedToCheckPermission by viewModel.isNeedToCheckNotificationsPermission.collectAsStateWithLifecycle()
+    val isNeedToRequestPermission by viewModel.isNeedToRequestNotifications.collectAsStateWithLifecycle()
+
+    LaunchedEffect(isNeedToCheckPermission) {
+        if (isNeedToCheckPermission) {
+            viewModel.onPermissionCheckStatus(permissionState.status)
+
+            if (permissionState.status.isGranted) {
+                if (longPollCurrentState == LongPollState.InApp) {
+                    toggleLongPollService(false, null)
+                }
+
+                toggleLongPollService(true, true)
+            }
+        }
+    }
+
+    LaunchedEffect(isNeedToRequestPermission) {
+        if (isNeedToRequestPermission) {
+            viewModel.onPermissionsRequested()
+            permissionState.launchPermissionRequest()
+        }
+    }
+
+        LifecycleResumeEffect(longPollStateToApply) {
+        if (longPollStateToApply != LongPollState.Background) {
+            if (longPollStateToApply.isLaunched() && longPollCurrentState.isLaunched()
+                && longPollCurrentState != longPollStateToApply
+            ) {
+                toggleLongPollService(false, null)
+            }
+
+            toggleLongPollService(
+                longPollStateToApply.isLaunched(),
+                longPollStateToApply == LongPollState.Background
+            )
+        }
+
+        onPauseOrDispose {}
+    }
+
+    val sendOnline by userSettings.sendOnlineStatus.collectAsStateWithLifecycle()
+    LifecycleResumeEffect(sendOnline) {
+        toggleOnlineService(sendOnline)
+
+        onPauseOrDispose {
+            toggleOnlineService(false)
+        }
+    }
+
+    val deviceWidthDp = remember(true) {
+        resources.displayMetrics.widthPixels.pxToDp()
+    }
+    val deviceHeightDp = remember(true) {
+        resources.displayMetrics.heightPixels.pxToDp()
+    }
+
+    val deviceWidthSize by remember(deviceWidthDp) {
+        derivedStateOf {
+            when {
+                deviceWidthDp <= 360 -> DeviceSize.Small
+                deviceWidthDp <= 600 -> DeviceSize.Compact
+                deviceWidthDp <= 840 -> DeviceSize.Medium
+                else -> DeviceSize.Expanded
+            }
+        }
+    }
+
+    val deviceHeightSize by remember(deviceHeightDp) {
+        derivedStateOf {
+            when {
+                deviceHeightDp <= 480 -> DeviceSize.Small
+                deviceHeightDp <= 700 -> DeviceSize.Compact
+                deviceHeightDp <= 900 -> DeviceSize.Medium
+                else -> DeviceSize.Expanded
+            }
+        }
+    }
+
+    val sizeConfig by remember(deviceWidthSize, deviceHeightSize) {
+        mutableStateOf(
+            SizeConfig(
+                widthSize = deviceWidthSize,
+                heightSize = deviceHeightSize
+            )
+        )
+    }
+
+    val darkMode by userSettings.darkMode.collectAsStateWithLifecycle()
+    val dynamicColors by userSettings.enableDynamicColors.collectAsStateWithLifecycle()
+    val amoledDark by userSettings.enableAmoledDark.collectAsStateWithLifecycle()
+    val enableBlur by userSettings.useBlur.collectAsStateWithLifecycle()
+    val enableMultiline by userSettings.enableMultiline.collectAsStateWithLifecycle()
+    val useSystemFont by userSettings.useSystemFont.collectAsStateWithLifecycle()
+    val enableAnimations by userSettings.enableAnimations.collectAsStateWithLifecycle()
+
+    val setDarkMode = isNeedToEnableDarkMode(darkMode = darkMode)
+
+    val themeConfig by remember(
+        darkMode,
+        dynamicColors,
+        amoledDark,
+        enableBlur,
+        enableMultiline,
+        setDarkMode,
+        useSystemFont
+    ) {
+        derivedStateOf {
+            ThemeConfig(
+                darkMode = setDarkMode,
+                dynamicColors = dynamicColors,
+                selectedColorScheme = 0,
+                amoledDark = amoledDark,
+                enableBlur = enableBlur,
+                enableMultiline = enableMultiline,
+                useSystemFont = useSystemFont,
+                enableAnimations = enableAnimations
+            )
+        }
+    }
+
+    CompositionLocalProvider(
+        LocalThemeConfig provides themeConfig,
+        LocalSizeConfig provides sizeConfig,
+        LocalUser provides currentUser
+    ) {
+        AppTheme(
+            useDarkTheme = themeConfig.darkMode,
+            useDynamicColors = themeConfig.dynamicColors,
+            selectedColorScheme = themeConfig.selectedColorScheme,
+            useAmoledBackground = themeConfig.amoledDark,
+            useSystemFont = themeConfig.useSystemFont
+        ) {
+            val navController: NavHostController = rememberNavController()
+            val activity = LocalActivity.current
             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()
 
@@ -113,11 +296,25 @@ 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<List<String>, Int?>?>(null)
+                    }
+
+                    val captchaRedirectUri by AppSettings.getCaptchaRedirectUriFlow()
+                        .collectAsStateWithLifecycle()
+
+                    Box(modifier = Modifier.fillMaxSize()) {
                         NavHost(
                             navController = navController,
                             startDestination = requireNotNull(startDestination),
@@ -129,6 +326,7 @@ fun RootScreen(
                                     viewModel.onUserAuthenticated()
                                     navController.navigateToMain()
                                 },
+                                onNavigateToSettings = navController::navigateToSettings,
                                 navController = navController
                             )
 
@@ -136,24 +334,31 @@ fun RootScreen(
                                 onError = viewModel::onError,
                                 onSettingsButtonClicked = navController::navigateToSettings,
                                 onNavigateToMessagesHistory = navController::navigateToMessagesHistory,
-                    onPhotoClicked = { url -> navController.navigateToPhotoView(listOf(url)) },
+                                onPhotoClicked = { url ->
+                                    photoViewerInfo = listOf(url) to null
+                                },
                                 onMessageClicked = navController::navigateToMessagesHistory,
-                    onNavigateToCreateChat = navController::navigateToCreateChat
+                                onNavigateToCreateChat = navController::navigateToCreateChat,
                             )
 
                             messagesHistoryScreen(
                                 onError = viewModel::onError,
                                 onBack = navController::navigateUp,
-                    onNavigateToChatMaterials = navController::navigateToChatMaterials
+                                onNavigateToChatMaterials = navController::navigateToChatMaterials,
+                                onNavigateToPhotoViewer = { photos, index ->
+                                    photoViewerInfo = photos to index
+                                }
                             )
                             chatMaterialsScreen(
                                 onBack = navController::navigateUp,
-                    onPhotoClicked = { url -> navController.navigateToPhotoView(listOf(url)) }
+                                onPhotoClicked = { url ->
+                                    photoViewerInfo = listOf(url) to null
+                                }
                             )
                             createChatScreen(
-                    onChatCreated = { conversationId ->
+                                onChatCreated = { convoId ->
                                     navController.popBackStack()
-                        navController.navigateToMessagesHistory(conversationId)
+                                    navController.navigateToMessagesHistory(convoId)
                                 },
                                 navController = navController
                             )
@@ -161,11 +366,39 @@ fun RootScreen(
                             settingsScreen(
                                 onBack = navController::navigateUp,
                                 onLogOutButtonClicked = { navController.navigateToAuth(true) },
-                    onLanguageItemClicked = navController::navigateToLanguagePicker
+                                onLanguageItemClicked = navController::navigateToLanguagePicker,
+                                onRestartRequired = {
+                                    activity?.let {
+                                        val intent = Intent(activity, MainActivity::class.java)
+                                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                                        activity.startActivity(intent)
+                                        activity.finish()
+                                    }
+                                }
                             )
                             languagePickerScreen(onBack = navController::navigateUp)
+                        }
 
-                photoViewScreen(onBack = navController::navigateUp)
+                        PhotoViewDialog(
+                            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)
 }

app/src/main/kotlin/dev/meloda/fast/util/NotificationsUtils.kt

@@ -6,7 +6,7 @@ import android.content.Context
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import dev.meloda.fast.common.AppConstants
-import dev.meloda.fast.ui.R as UiR
+import dev.meloda.fast.ui.R
 
 object NotificationsUtils {
 
@@ -28,7 +28,7 @@ object NotificationsUtils {
         actions: List<NotificationCompat.Action> = emptyList(),
     ): NotificationCompat.Builder {
         val builder = NotificationCompat.Builder(context, channelId)
-            .setSmallIcon(UiR.drawable.ic_fast_logo)
+            .setSmallIcon(R.drawable.ic_fast_logo)
             .setContentTitle(title)
             .setPriority(priority.value)
             .setContentIntent(contentIntent)

app/src/main/res/xml/network_security_config.xml

@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <network-security-config xmlns:tools="http://schemas.android.com/tools">
-    <!-- Allow cleartext network traffic -->
     <base-config
-        cleartextTrafficPermitted="true"
+        cleartextTrafficPermitted="false"
         tools:ignore="InsecureBaseConfiguration">
         <trust-anchors>
             <!-- Trust pre-installed CAs -->

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,6 +1,6 @@
 import com.android.build.api.dsl.ApplicationExtension
 import dev.meloda.fast.configureKotlinAndroid
-import dev.meloda.fast.libs
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -10,12 +10,15 @@ class AndroidApplicationConventionPlugin : Plugin<Project> {
         with(target) {
             with(pluginManager) {
                 apply("com.android.application")
-                apply("org.jetbrains.kotlin.android")
             }
 
             extensions.configure<ApplicationExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = libs.findVersion("targetSdk").get().toString().toInt()
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
+                }
             }
         }
     }

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

@@ -1,18 +1,26 @@
-import com.android.build.gradle.LibraryExtension
+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>()
-            configureAndroidCompose(extension)
+            extensions.configure<LibraryExtension> {
+                configureAndroidCompose(this)
+                androidResources.enable = false
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                }
+            }
         }
     }
 }

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

@@ -1,8 +1,7 @@
+import com.android.build.api.dsl.LibraryExtension
 import com.android.build.api.variant.LibraryAndroidComponentsExtension
-import com.android.build.gradle.LibraryExtension
 import dev.meloda.fast.configureKotlinAndroid
 import dev.meloda.fast.disableUnnecessaryAndroidTests
-import dev.meloda.fast.libs
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -14,14 +13,13 @@ class AndroidLibraryConventionPlugin : Plugin<Project> {
         with(target) {
             with(pluginManager) {
                 apply("com.android.library")
-                apply("org.jetbrains.kotlin.android")
                 apply("org.jetbrains.kotlin.plugin.parcelize")
                 apply("org.jetbrains.kotlin.plugin.serialization")
             }
 
             extensions.configure<LibraryExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = libs.findVersion("targetSdk").get().toString().toInt()
+                androidResources.enable = false
                 defaultConfig.testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
             }
             extensions.configure<LibraryAndroidComponentsExtension> {

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

@@ -1,6 +1,6 @@
-import com.android.build.gradle.TestExtension
+import com.android.build.api.dsl.TestExtension
 import dev.meloda.fast.configureKotlinAndroid
-import dev.meloda.fast.libs
+import dev.meloda.fast.getVersionInt
 import org.gradle.api.Plugin
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.configure
@@ -10,12 +10,15 @@ class AndroidTestConventionPlugin : Plugin<Project> {
         with(target) {
             with(pluginManager) {
                 apply("com.android.test")
-                apply("org.jetbrains.kotlin.android")
             }
 
             extensions.configure<TestExtension> {
                 configureKotlinAndroid(this)
-                defaultConfig.targetSdk = libs.findVersion("targetSdk").get().toString().toInt()
+                defaultConfig {
+                    minSdk = getVersionInt("minSdk")
+                    compileSdk = getVersionInt("compileSdk")
+                    targetSdk = getVersionInt("targetSdk")
+                }
             }
         }
     }

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

@@ -5,12 +5,10 @@ import org.gradle.api.Project
 import org.gradle.kotlin.dsl.dependencies
 
 internal fun Project.configureAndroidCompose(
-    commonExtension: CommonExtension<*, *, *, *, *, *>,
+    commonExtension: CommonExtension,
 ) {
     commonExtension.apply {
-        buildFeatures {
-            compose = true
-        }
+        buildFeatures.compose = true
 
         dependencies {
             val bom = libs.findLibrary("compose-bom").get()

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

@@ -1,6 +1,9 @@
 package dev.meloda.fast
 
+import com.android.build.api.dsl.ApplicationExtension
 import com.android.build.api.dsl.CommonExtension
+import com.android.build.api.dsl.CompileOptions
+import com.android.build.api.dsl.LibraryExtension
 import org.gradle.api.JavaVersion
 import org.gradle.api.Project
 import org.gradle.api.plugins.JavaPluginExtension
@@ -13,24 +16,26 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinBaseExtension
 import org.jetbrains.kotlin.gradle.dsl.KotlinJvmProjectExtension
 
 internal fun Project.configureKotlinAndroid(
-    commonExtension: CommonExtension<*, *, *, *, *, *>,
+    commonExtension: CommonExtension,
 ) {
+    when (commonExtension) {
+        is ApplicationExtension -> commonExtension.compileOptions(buildCompileOptions())
+        is LibraryExtension -> commonExtension.compileOptions(buildCompileOptions())
+    }
+
     commonExtension.apply {
-        compileSdk = libs.findVersion("compileSdk").get().toString().toInt()
-
-        defaultConfig {
-            minSdk = libs.findVersion("minSdk").get().toString().toInt()
-        }
-
-        compileOptions {
-            sourceCompatibility = JavaVersion.VERSION_21
-            targetCompatibility = JavaVersion.VERSION_21
-        }
+        compileSdk = getVersionInt("compileSdk")
+        buildToolsVersion = "36.1.0"
     }
 
     configureKotlin<KotlinAndroidProjectExtension>()
 }
 
+private fun buildCompileOptions(): CompileOptions.() -> Unit = {
+    sourceCompatibility = JavaVersion.VERSION_21
+    targetCompatibility = JavaVersion.VERSION_21
+}
+
 internal fun Project.configureKotlinJvm() {
     extensions.configure<JavaPluginExtension> {
         sourceCompatibility = JavaVersion.VERSION_21
@@ -47,7 +52,7 @@ private inline fun <reified T : KotlinBaseExtension> Project.configureKotlin() =
     when (this) {
         is KotlinAndroidProjectExtension -> compilerOptions
         is KotlinJvmProjectExtension -> compilerOptions
-        else -> TODO("Unsupported project extension $this ${T::class}")
+        else -> throw IllegalArgumentException("Unsupported project extension $this ${T::class}")
     }.apply {
         jvmTarget = JvmTarget.JVM_21
         allWarningsAsErrors = warningsAsErrors.toBoolean()
@@ -55,7 +60,9 @@ private inline fun <reified T : KotlinBaseExtension> Project.configureKotlin() =
             "-opt-in=kotlin.RequiresOptIn",
             // Enable experimental coroutines APIs, including Flow
             "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
-            "-opt-in=kotlinx.coroutines.FlowPreview"
+            "-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

@@ -1,7 +1,6 @@
 plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.android.library) apply false
-    alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.parcelize) apply false
     alias(libs.plugins.kotlin.serialization) apply false
     alias(libs.plugins.kotlin.jvm) apply false
@@ -9,4 +8,6 @@ plugins {
     alias(libs.plugins.room) apply false
     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/AppConstants.kt

@@ -5,8 +5,8 @@ object AppConstants {
     const val INSTALL_APP_MIME_TYPE = "application/vnd.android.package-archive"
     
     const val API_VERSION = "5.238"
-    const val URL_OAUTH = "https://oauth.vk.com"
-    const val URL_API = "https://api.vk.com/method"
+    const val URL_OAUTH = "https://oauth.vk.ru"
+    const val URL_API = "https://api.vk.ru/method"
 
     const val NOTIFICATION_CHANNEL_UNCATEGORIZED = "uncategorized"
     const val NOTIFICATION_CHANNEL_LONG_POLLING = "long_polling"

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

@@ -1,5 +1,7 @@
 package dev.meloda.fast.common.extensions
 
+import android.os.Build
+import android.os.Bundle
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.delay
@@ -11,6 +13,8 @@ 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
 
@@ -42,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,
@@ -103,7 +115,7 @@ fun Any.asInt(): Int {
 }
 
 fun Any.asLong(): Long {
-    return when(this) {
+    return when (this) {
         is Number -> this.toLong()
 
         else -> throw IllegalArgumentException("Object is not numeric")
@@ -117,3 +129,33 @@ fun <T> Any.toList(mapper: (old: Any) -> T): List<T> {
         else -> emptyList()
     }
 }
+
+fun <T> Bundle.getParcelableCompat(key: String, clazz: Class<T>): T? {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        getParcelable(key, clazz)
+    } else {
+        @Suppress("DEPRECATION")
+        getParcelable(key)
+    }
+}
+
+fun <T : Any> Bundle.getParcelableCompat(key: String, clazz: KClass<T>): T? {
+    return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        getParcelable(key, clazz.java)
+    } else {
+        @Suppress("DEPRECATION")
+        getParcelable(key)
+    }
+}
+
+infix fun ClosedRange<Int>.collidesWith(other: ClosedRange<Int>): Boolean {
+    return this.start < other.endInclusive && other.start < this.endInclusive
+}
+
+operator fun ClosedRange<Int>.minus(other: ClosedRange<Int>): ClosedRange<Int> {
+    return (this.start - other.start)..(this.endInclusive - other.endInclusive)
+}
+
+operator fun ClosedRange<Int>.minus(other: Int): ClosedRange<Int> {
+    return (this.start - other)..(this.endInclusive - other)
+}

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,19 +1,22 @@
 package dev.meloda.fast.common.util
 
-import android.content.res.Resources
 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
 import com.conena.nanokt.jvm.util.month
 import com.conena.nanokt.jvm.util.second
 import com.conena.nanokt.jvm.util.year
-import dev.meloda.fast.common.R
 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 {
 
@@ -27,7 +30,11 @@ object TimeUtils {
         }.timeInMillis
     }
 
-    fun getLocalizedDate(resources: Resources, date: Long): String {
+    fun getLocalizedDate(
+        date: Long,
+        yesterday: () -> String,
+        today: () -> String
+    ): String {
         val now = Calendar.getInstance()
         val then = Calendar.getInstance().also { it.timeInMillis = date }
 
@@ -36,48 +43,41 @@ object TimeUtils {
             now.month != then.month -> "dd MMMM"
             now.dayOfMonth != then.dayOfMonth -> {
                 if (now.dayOfMonth - then.dayOfMonth == 1) {
-                    return resources.getString(R.string.yesterday)
+                    return yesterday()
                 } else {
                     "dd MMMM"
                 }
             }
 
-            else -> return resources.getString(R.string.today)
+            else -> return today()
         }
 
         return SimpleDateFormat(pattern, Locale.getDefault()).format(date)
     }
 
-    fun getLocalizedTime(resources: Resources, date: Long): String {
-        val now = Calendar.getInstance()
-        val then = Calendar.getInstance().also { it.timeInMillis = date }
+    fun getLocalizedTime(
+        date: Long,
+        yearShort: () -> String,
+        monthShort: () -> String,
+        weekShort: () -> String,
+        dayShort: () -> String,
+        minuteShort: () -> String,
+        secondShort: () -> String,
+        now: () -> String
+    ): String {
+        val now = Clock.System.now()
+        val then = Instant.fromEpochMilliseconds(date)
+        val diff = now - then
 
         return when {
-            now.year != then.year -> {
-                "${now.year - then.year}${resources.getString(R.string.year_short).lowercase()}"
-            }
-
-            now.month != then.month -> {
-                "${now.month - then.month}${resources.getString(R.string.month_short).lowercase()}"
-            }
-
-            now.dayOfMonth != then.dayOfMonth -> {
-                val change = now.dayOfMonth - then.dayOfMonth
-
-                if (change % 7 == 0) {
-                    "${change / 7}${resources.getString(R.string.week_short).lowercase()}"
-                } else {
-                    "$change${resources.getString(R.string.day_short).lowercase()}"
-                }
-            }
-
-            now.hour == then.hour && now.minute == then.minute -> {
-                resources.getString(R.string.time_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

@@ -0,0 +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/common/src/main/res/values-ru/strings.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="yesterday">Вчера</string>
-    <string name="today">Сегодня</string>
-    <string name="year_short">Г</string>
-    <string name="month_short">М</string>
-    <string name="week_short">Н</string>
-    <string name="day_short">Д</string>
-    <string name="time_now">Сейчас</string>
-</resources>

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

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <string name="yesterday">Yesterday</string>
-    <string name="today">Today</string>
-    <string name="year_short">Y</string>
-    <string name="month_short">M</string>
-    <string name="week_short">W</string>
-    <string name="day_short">D</string>
-    <string name="time_now">Now</string>
-</resources>

core/data/build.gradle.kts

@@ -14,7 +14,6 @@ dependencies {
     api(projects.core.network)
     api(projects.core.database)
 
-    // TODO: 11/08/2024, Danil Nikolaev: remove?
     implementation(libs.retrofit)
     implementation(libs.eithernet)
     implementation(libs.koin.android)

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

@@ -1,7 +1,7 @@
 package dev.meloda.fast.data
 
 import dev.meloda.fast.model.api.data.VkMessageData
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import kotlin.math.abs
@@ -16,17 +16,15 @@ class VkGroupsMap(
 
     fun groups(): List<VkGroupDomain> = map.values.toList()
 
-    fun conversationGroup(conversation: VkConversation): VkGroupDomain? =
-        if (!conversation.peerType.isGroup()) null
-        else map[abs(conversation.id)]
+    fun convoGroup(convo: VkConvo): VkGroupDomain? =
+        if (!convo.peerType.isGroup()) null
+        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,8 +1,7 @@
 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.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkGroupDomain
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
@@ -13,7 +12,7 @@ object VkMemoryCache {
     private val users: HashMap<Long, VkUser> = hashMapOf()
     private val groups: HashMap<Long, VkGroupDomain> = hashMapOf()
     private val messages: HashMap<Long, VkMessage> = hashMapOf()
-    private val conversations: HashMap<Long, VkConversation> = hashMapOf()
+    private val convos: HashMap<Long, VkConvo> = hashMapOf()
     private val contacts: HashMap<Long, VkContactDomain> = hashMapOf()
 
     fun appendUsers(users: List<VkUser>) {
@@ -28,9 +27,9 @@ object VkMemoryCache {
         messages.forEach { message -> VkMemoryCache.messages[message.id] = message }
     }
 
-    fun appendConversations(conversations: List<VkConversation>) {
-        conversations.forEach { conversation ->
-            VkMemoryCache.conversations[conversation.id] = conversation
+    fun appendConvos(convos: List<VkConvo>) {
+        convos.forEach { convo ->
+            VkMemoryCache.convos[convo.id] = convo
         }
     }
 
@@ -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
     }
 
@@ -50,8 +57,8 @@ object VkMemoryCache {
         messages[messageId] = message
     }
 
-    operator fun set(conversationId: Long, conversation: VkConversation) {
-        conversations[conversationId] = conversation
+    operator fun set(convoId: Long, convo: VkConvo) {
+        convos[convoId] = convo
     }
 
     operator fun set(contactId: Long, contact: VkContactDomain) {
@@ -94,16 +101,16 @@ object VkMemoryCache {
         return ids.mapNotNull { id -> messages[id] }
     }
 
-    fun getConversation(id: Long): VkConversation? {
-        return getConversations(id).firstOrNull()
+    fun getConvo(id: Long): VkConvo? {
+        return getConvos(id).firstOrNull()
     }
 
-    fun getConversations(vararg ids: Long): List<VkConversation> {
-        return getConversations(ids.toList())
+    fun getConvos(vararg ids: Long): List<VkConvo> {
+        return getConvos(ids.toList())
     }
 
-    fun getConversations(ids: List<Long>): List<VkConversation> {
-        return ids.mapNotNull { id -> conversations[id] }
+    fun getConvos(ids: List<Long>): List<VkConvo> {
+        return ids.mapNotNull { id -> convos[id] }
     }
 
     fun getContact(id: Long): VkContactDomain? {

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

@@ -1,8 +1,7 @@
 package dev.meloda.fast.data
 
-import dev.meloda.fast.data.UserConfig.userId
 import dev.meloda.fast.model.api.data.VkMessageData
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkUser
 
@@ -16,17 +15,15 @@ class VkUsersMap(
 
     fun users(): List<VkUser> = map.values.toList()
 
-    fun conversationUser(conversation: VkConversation): VkUser? =
-        if (!conversation.peerType.isUser()) null
-        else map[conversation.id]
+    fun convoUser(convo: VkConvo): VkUser? =
+        if (!convo.peerType.isUser()) null
+        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
@@ -36,7 +33,7 @@ class VkUsersMap(
         if (message.fromId > 0) map[message.fromId]
         else null
 
-    fun user(userid: Long): VkUser? = map[userId]
+    fun user(userId: Long): VkUser? = map[userId]
 
     companion object {
 

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

@@ -1,25 +1,28 @@
-package dev.meloda.fast.data.api.conversations
+package dev.meloda.fast.data.api.convos
 
 import com.slack.eithernet.ApiResult
-import dev.meloda.fast.model.ConversationsFilter
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.ConvosFilter
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.network.RestApiErrorDomain
 
-interface ConversationsRepository {
+interface ConvosRepository {
 
-    suspend fun storeConversations(conversations: List<VkConversation>)
+    suspend fun storeConvos(convos: List<VkConvo>)
+    suspend fun getLocalConvos(): List<VkConvo>
+    suspend fun getLocalConvoById(peerId: Long): VkConvo?
+    suspend fun deleteLocalConvo(peerId: Long)
 
-    suspend fun getConversations(
+    suspend fun getConvos(
         count: Int?,
         offset: Int?,
-        filter: ConversationsFilter
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain>
+        filter: ConvosFilter
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain>
 
-    suspend fun getConversationsById(
+    suspend fun getConvosById(
         peerIds: List<Long>,
         extended: Boolean? = null,
         fields: String? = null
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain>
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain>
 
     suspend fun delete(peerId: Long): ApiResult<Long, RestApiErrorDomain>
     suspend fun pin(peerId: Long): ApiResult<Int, RestApiErrorDomain>

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

@@ -1,51 +1,75 @@
-package dev.meloda.fast.data.api.conversations
+package dev.meloda.fast.data.api.convos
 
 import com.slack.eithernet.ApiResult
 import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.data.VkGroupsMap
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.data.VkUsersMap
-import dev.meloda.fast.database.dao.ConversationDao
+import dev.meloda.fast.database.dao.ConvoDao
 import dev.meloda.fast.database.dao.GroupDao
 import dev.meloda.fast.database.dao.MessageDao
 import dev.meloda.fast.database.dao.UserDao
-import dev.meloda.fast.model.ConversationsFilter
+import dev.meloda.fast.model.ConvosFilter
 import dev.meloda.fast.model.api.data.VkContactData
 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.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 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.api.requests.ConversationsGetRequest
+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.conversations.ConversationsService
+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
 
-class ConversationsRepositoryImpl(
-    private val conversationsService: ConversationsService,
+class ConvosRepositoryImpl(
+    private val convosService: ConvosService,
     private val messageDao: MessageDao,
     private val userDao: UserDao,
     private val groupDao: GroupDao,
-    private val conversationDao: ConversationDao
-) : ConversationsRepository {
+    private val convoDao: ConvoDao
+) : ConvosRepository {
 
-    override suspend fun storeConversations(conversations: List<VkConversation>) {
-        conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+    override suspend fun storeConvos(convos: List<VkConvo>) {
+        convoDao.insertAll(convos.map(VkConvo::asEntity))
     }
 
-    override suspend fun getConversations(
+    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?,
-        filter: ConversationsFilter
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        val requestModel = ConversationsGetRequest(
+        filter: ConvosFilter
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+        val requestModel = ConvosGetRequest(
             count = count,
             offset = offset,
             fields = VkConstants.ALL_FIELDS,
@@ -54,7 +78,7 @@ class ConversationsRepositoryImpl(
             startMessageId = null
         )
 
-        conversationsService.getConversations(requestModel.map).mapApiResult(
+        convosService.getConvos(requestModel.map).mapApiResult(
             successMapper = { apiResponse ->
                 val response = apiResponse.requireResponse()
 
@@ -69,33 +93,39 @@ class ConversationsRepositoryImpl(
                 VkMemoryCache.appendGroups(groupsList)
                 VkMemoryCache.appendContacts(contactsList)
 
-                val conversations = response.items.map { item ->
+                val convos = response.items.map { item ->
                     val lastMessage = item.lastMessage?.asDomain()?.let { message ->
                         message.copy(
                             user = usersMap.messageUser(message),
                             group = groupsMap.messageGroup(message),
                             actionUser = usersMap.messageActionUser(message),
-                            actionGroup = groupsMap.messageActionGroup(message)
+                            actionGroup = groupsMap.messageActionGroup(message),
+                            replyMessage = message.replyMessage?.copy(
+                                user = usersMap.messageUser(message),
+                                group = groupsMap.messageGroup(message),
+                                actionUser = usersMap.messageActionUser(message),
+                                actionGroup = groupsMap.messageActionGroup(message),
+                            )
                         ).also { VkMemoryCache[message.id] = it }
                     }
-                    item.conversation.asDomain(lastMessage).let { conversation ->
-                        conversation.copy(
-                            user = usersMap.conversationUser(conversation),
-                            group = groupsMap.conversationGroup(conversation)
-                        ).also { VkMemoryCache[conversation.id] = it }
+                    item.convo.asDomain(lastMessage).let { convo ->
+                        convo.copy(
+                            user = usersMap.convoUser(convo),
+                            group = groupsMap.convoGroup(convo)
+                        ).also { VkMemoryCache[convo.id] = it }
                     }
                 }
 
-                val messages = conversations.mapNotNull(VkConversation::lastMessage)
+                val messages = convos.mapNotNull(VkConvo::lastMessage)
 
                 launch(Dispatchers.IO) {
-                    conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+                    convoDao.insertAll(convos.map(VkConvo::asEntity))
                     messageDao.insertAll(messages.map(VkMessage::asEntity))
                     userDao.insertAll(profilesList.map(VkUser::asEntity))
                     groupDao.insertAll(groupsList.map(VkGroupDomain::asEntity))
                 }
 
-                conversations
+                convos
             },
             errorMapper = { error ->
                 error?.toDomain()
@@ -103,11 +133,11 @@ class ConversationsRepositoryImpl(
         )
     }
 
-    override suspend fun getConversationsById(
+    override suspend fun getConvosById(
         peerIds: List<Long>,
         extended: Boolean?,
         fields: String?
-    ): ApiResult<List<VkConversation>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+    ): ApiResult<List<VkConvo>, RestApiErrorDomain> = withContext(Dispatchers.IO) {
         val requestParams = mutableMapOf(
             "peer_ids" to peerIds.joinToString(separator = ",")
         ).apply {
@@ -115,7 +145,7 @@ class ConversationsRepositoryImpl(
             fields?.let { this["fields"] = it }
         }
 
-        conversationsService.getConversationsById(requestParams).mapApiResult(
+        convosService.getConvosById(requestParams).mapApiResult(
             successMapper = { apiResponse ->
                 val response = apiResponse.requireResponse()
 
@@ -126,17 +156,17 @@ class ConversationsRepositoryImpl(
                 val usersMap = VkUsersMap.forUsers(profilesList)
                 val groupsMap = VkGroupsMap.forGroups(groupsList)
 
-                val conversations = response.items.map { item ->
-                    item.asDomain().let { conversation ->
-                        conversation.copy(
-                            user = usersMap.conversationUser(conversation),
-                            group = groupsMap.conversationGroup(conversation)
-                        ).also { VkMemoryCache[conversation.id] = it }
+                val convos = response.items.map { item ->
+                    item.asDomain().let { convo ->
+                        convo.copy(
+                            user = usersMap.convoUser(convo),
+                            group = groupsMap.convoGroup(convo)
+                        ).also { VkMemoryCache[convo.id] = it }
                     }
                 }
 
                 launch(Dispatchers.IO) {
-                    conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+                    convoDao.insertAll(convos.map(VkConvo::asEntity))
                     userDao.insertAll(profilesList.map(VkUser::asEntity))
                     groupDao.insertAll(groupsList.map(VkGroupDomain::asEntity))
                 }
@@ -145,7 +175,7 @@ class ConversationsRepositoryImpl(
                 VkMemoryCache.appendGroups(groupsList)
                 VkMemoryCache.appendContacts(contactsList)
 
-                conversations
+                convos
             },
             errorMapper = { error ->
                 error?.toDomain()
@@ -155,7 +185,7 @@ class ConversationsRepositoryImpl(
 
     override suspend fun delete(peerId: Long): ApiResult<Long, RestApiErrorDomain> =
         withContext(Dispatchers.IO) {
-            conversationsService.delete(mapOf("peer_id" to peerId.toString())).mapApiResult(
+            convosService.delete(mapOf("peer_id" to peerId.toString())).mapApiResult(
                 successMapper = { response -> response.requireResponse().lastDeletedId },
                 errorMapper = { error -> error?.toDomain() }
             )
@@ -164,19 +194,19 @@ class ConversationsRepositoryImpl(
     override suspend fun pin(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.pin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        convosService.pin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
 
     override suspend fun unpin(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.unpin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        convosService.unpin(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
 
     override suspend fun reorderPinned(
         peerIds: List<Long>
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService
+        convosService
             .reorderPinned(mapOf("peer_ids" to peerIds.joinToString(",")))
             .mapApiDefault()
     }
@@ -184,12 +214,36 @@ class ConversationsRepositoryImpl(
     override suspend fun archive(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.archive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        convosService.archive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
     }
 
     override suspend fun unarchive(
         peerId: Long
     ): ApiResult<Int, RestApiErrorDomain> = withContext(Dispatchers.IO) {
-        conversationsService.unarchive(mapOf("peer_id" to peerId.toString())).mapApiDefault()
+        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/MessagesHistoryInfo.kt

@@ -1,9 +1,9 @@
 package dev.meloda.fast.data.api.messages
 
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 
 data class MessagesHistoryInfo(
     val messages: List<VkMessage>,
-    val conversations: List<VkConversation>
+    val convos: List<VkConvo>
 )

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

@@ -5,7 +5,8 @@ import dev.meloda.fast.model.api.data.VkChatData
 import dev.meloda.fast.model.api.domain.VkAttachment
 import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
 import dev.meloda.fast.model.api.domain.VkMessage
-import dev.meloda.fast.model.api.responses.MessagesGetConversationMembersResponse
+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.network.RestApiErrorDomain
 
@@ -13,8 +14,14 @@ 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(
-        conversationId: Long,
+        convoId: Long,
         offset: Int?,
         count: Int?
     ): ApiResult<MessagesHistoryInfo, RestApiErrorDomain>
@@ -32,7 +39,7 @@ interface MessagesRepository {
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
+        forward: String?,
         attachments: List<VkAttachment>?,
         formatData: VkMessage.FormatData?
     ): ApiResult<MessagesSendResponse, RestApiErrorDomain>
@@ -98,16 +105,21 @@ interface MessagesRepository {
         fields: String? = null
     ): ApiResult<VkChatData, RestApiErrorDomain>
 
-    suspend fun getConversationMembers(
+    suspend fun getConvoMembers(
         peerId: Long,
         offset: Int? = null,
         count: Int? = null,
         extended: Boolean? = null,
         fields: String? = null
-    ): ApiResult<MessagesGetConversationMembersResponse, RestApiErrorDomain>
+    ): ApiResult<MessagesGetConvoMembersResponse, RestApiErrorDomain>
 
     suspend fun removeChatUser(
         chatId: Long,
         memberId: Long
     ): ApiResult<Int, RestApiErrorDomain>
+
+    suspend fun getMessageReadPeers(
+        peerId: Long,
+        cmId: Long
+    ): ApiResult<MessagesGetReadPeersResponse, RestApiErrorDomain>
 }

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

@@ -5,7 +5,7 @@ import dev.meloda.fast.common.VkConstants
 import dev.meloda.fast.data.VkGroupsMap
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.data.VkUsersMap
-import dev.meloda.fast.database.dao.ConversationDao
+import dev.meloda.fast.database.dao.ConvoDao
 import dev.meloda.fast.database.dao.GroupDao
 import dev.meloda.fast.database.dao.MessageDao
 import dev.meloda.fast.database.dao.UserDao
@@ -17,17 +17,18 @@ import dev.meloda.fast.model.api.data.VkUserData
 import dev.meloda.fast.model.api.data.asDomain
 import dev.meloda.fast.model.api.domain.VkAttachment
 import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 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
 import dev.meloda.fast.model.api.requests.MessagesGetByIdRequest
 import dev.meloda.fast.model.api.requests.MessagesGetChatRequest
-import dev.meloda.fast.model.api.requests.MessagesGetConversationMembersRequest
+import dev.meloda.fast.model.api.requests.MessagesGetConvoMembersRequest
 import dev.meloda.fast.model.api.requests.MessagesGetHistoryAttachmentsRequest
 import dev.meloda.fast.model.api.requests.MessagesGetHistoryRequest
 import dev.meloda.fast.model.api.requests.MessagesMarkAsImportantRequest
@@ -36,8 +37,10 @@ import dev.meloda.fast.model.api.requests.MessagesPinMessageRequest
 import dev.meloda.fast.model.api.requests.MessagesRemoveChatUserRequest
 import dev.meloda.fast.model.api.requests.MessagesSendRequest
 import dev.meloda.fast.model.api.requests.MessagesUnpinMessageRequest
-import dev.meloda.fast.model.api.responses.MessagesGetConversationMembersResponse
+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
@@ -51,18 +54,18 @@ class MessagesRepositoryImpl(
     private val messageDao: MessageDao,
     private val userDao: UserDao,
     private val groupDao: GroupDao,
-    private val conversationDao: ConversationDao
+    private val convoDao: ConvoDao
 ) : MessagesRepository {
 
     override suspend fun getHistory(
-        conversationId: Long,
+        convoId: Long,
         offset: Int?,
         count: Int?
     ): ApiResult<MessagesHistoryInfo, RestApiErrorDomain> = withContext(Dispatchers.IO) {
         val requestModel = MessagesGetHistoryRequest(
             count = count,
             offset = offset,
-            peerId = conversationId,
+            peerId = convoId,
             extended = true,
             startMessageId = null,
             rev = null,
@@ -90,24 +93,32 @@ class MessagesRepositoryImpl(
                             user = usersMap.messageUser(message),
                             group = groupsMap.messageGroup(message),
                             actionUser = usersMap.messageActionUser(message),
-                            actionGroup = groupsMap.messageActionGroup(message)
+                            actionGroup = groupsMap.messageActionGroup(message),
+                            replyMessage = message.replyMessage.let { replyMessage ->
+                                replyMessage?.copy(
+                                    user = usersMap.messageUser(replyMessage),
+                                    group = groupsMap.messageGroup(replyMessage),
+                                    actionUser = usersMap.messageActionUser(replyMessage),
+                                    actionGroup = groupsMap.messageActionGroup(replyMessage),
+                                )
+                            }
                         ).also { VkMemoryCache[message.id] = it }
                     }
                 }
 
-                val conversations = response.conversations.orEmpty().map { item ->
+                val convos = response.convos.orEmpty().map { item ->
                     val message = messages.firstOrNull { it.id == item.lastMessageId }
                     item.asDomain(message)
-                        .let { conversation ->
-                            conversation.copy(
-                                user = usersMap.conversationUser(conversation),
-                                group = groupsMap.conversationGroup(conversation)
-                            ).also { VkMemoryCache[conversation.id] = it }
+                        .let { convo ->
+                            convo.copy(
+                                user = usersMap.convoUser(convo),
+                                group = groupsMap.convoGroup(convo)
+                            ).also { VkMemoryCache[convo.id] = it }
                         }
                 }
 
                 launch(Dispatchers.IO) {
-                    conversationDao.insertAll(conversations.map(VkConversation::asEntity))
+                    convoDao.insertAll(convos.map(VkConvo::asEntity))
                     messageDao.insertAll(messages.map(VkMessage::asEntity))
                     userDao.insertAll(profilesList.map(VkUser::asEntity))
                     groupDao.insertAll(groupsList.map(VkGroupDomain::asEntity))
@@ -115,7 +126,7 @@ class MessagesRepositoryImpl(
 
                 MessagesHistoryInfo(
                     messages = messages,
-                    conversations = conversations
+                    convos = convos
                 )
             },
             errorMapper = { error ->
@@ -159,7 +170,15 @@ class MessagesRepositoryImpl(
                         user = usersMap.messageUser(message),
                         group = groupsMap.messageGroup(message),
                         actionUser = usersMap.messageActionUser(message),
-                        actionGroup = groupsMap.messageActionGroup(message)
+                        actionGroup = groupsMap.messageActionGroup(message),
+                        replyMessage = message.replyMessage?.asDomain().let { replyMessage ->
+                            replyMessage?.copy(
+                                user = usersMap.messageUser(replyMessage),
+                                group = groupsMap.messageGroup(replyMessage),
+                                actionUser = usersMap.messageActionUser(replyMessage),
+                                actionGroup = groupsMap.messageActionGroup(replyMessage),
+                            )
+                        }
                     )
                 }
 
@@ -183,7 +202,7 @@ class MessagesRepositoryImpl(
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
+        forward: String?,
         attachments: List<VkAttachment>?,
         formatData: VkMessage.FormatData?
     ): ApiResult<MessagesSendResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
@@ -191,7 +210,7 @@ class MessagesRepositoryImpl(
             peerId = peerId,
             randomId = randomId,
             message = message,
-            replyTo = replyTo,
+            forward = forward,
             attachments = attachments,
             formatData = formatData
         )
@@ -226,7 +245,7 @@ class MessagesRepositoryImpl(
                 offset = offset,
                 preserveOrder = true,
                 attachmentTypes = attachmentTypes,
-                conversationMessageId = cmId,
+                cmId = cmId,
                 fields = VkConstants.ALL_FIELDS
             )
 
@@ -280,7 +299,7 @@ class MessagesRepositoryImpl(
         val requestModel = MessagesPinMessageRequest(
             peerId = peerId,
             messageId = messageId,
-            conversationMessageId = cmId
+            cmId = cmId
         )
 
         messagesService.pin(requestModel.map).mapApiResult(
@@ -308,7 +327,12 @@ class MessagesRepositoryImpl(
             messagesIds = messageIds.orEmpty(),
             important = important
         )
-        messagesService.markAsImportant(requestModel.map).mapApiDefault()
+        messagesService.markAsImportant(requestModel.map).mapApiResult(
+            successMapper = { apiResponse ->
+                apiResponse.requireResponse().marked.map { it.cmId }
+            },
+            errorMapper = { error -> error?.toDomain() }
+        )
     }
 
     override suspend fun delete(
@@ -321,7 +345,7 @@ class MessagesRepositoryImpl(
         val requestModel = MessagesDeleteRequest(
             peerId = peerId,
             messagesIds = messageIds,
-            conversationsMessagesIds = cmIds,
+            cmIds = cmIds,
             isSpam = spam,
             deleteForAll = deleteForAll
         )
@@ -332,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?,
@@ -372,15 +418,15 @@ class MessagesRepositoryImpl(
         messagesService.getChat(requestModel.map).mapApiDefault()
     }
 
-    override suspend fun getConversationMembers(
+    override suspend fun getConvoMembers(
         peerId: Long,
         offset: Int?,
         count: Int?,
         extended: Boolean?,
         fields: String?
-    ): ApiResult<MessagesGetConversationMembersResponse, RestApiErrorDomain> =
+    ): ApiResult<MessagesGetConvoMembersResponse, RestApiErrorDomain> =
         withContext(Dispatchers.IO) {
-            val requestModel = MessagesGetConversationMembersRequest(
+            val requestModel = MessagesGetConvoMembersRequest(
                 peerId = peerId,
                 offset = offset,
                 count = count,
@@ -388,7 +434,7 @@ class MessagesRepositoryImpl(
                 fields = fields
             )
 
-            messagesService.getConversationMembers(requestModel.map).mapApiDefault()
+            messagesService.getConvoMembers(requestModel.map).mapApiDefault()
         }
 
     override suspend fun removeChatUser(
@@ -402,4 +448,18 @@ class MessagesRepositoryImpl(
 
         messagesService.removeChatUser(requestModel.map).mapApiDefault()
     }
+
+    override suspend fun getMessageReadPeers(
+        peerId: Long,
+        cmId: Long
+    ): ApiResult<MessagesGetReadPeersResponse, RestApiErrorDomain> = withContext(Dispatchers.IO) {
+        messagesService.getMessageReadPeers(
+            mapOf(
+                "peer_id" to peerId.toString(),
+                "cmid" to cmId.toString(),
+                "extended" to "1",
+                "fields" to VkConstants.USER_FIELDS
+            )
+        ).mapApiDefault()
+    }
 }

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/data/src/main/kotlin/dev/meloda/fast/data/di/DataModule.kt

@@ -6,8 +6,8 @@ import dev.meloda.fast.data.api.account.AccountRepositoryImpl
 import dev.meloda.fast.data.api.audios.AudiosRepository
 import dev.meloda.fast.data.api.auth.AuthRepository
 import dev.meloda.fast.data.api.auth.AuthRepositoryImpl
-import dev.meloda.fast.data.api.conversations.ConversationsRepository
-import dev.meloda.fast.data.api.conversations.ConversationsRepositoryImpl
+import dev.meloda.fast.data.api.convos.ConvosRepository
+import dev.meloda.fast.data.api.convos.ConvosRepositoryImpl
 import dev.meloda.fast.data.api.files.FilesRepository
 import dev.meloda.fast.data.api.friends.FriendsRepository
 import dev.meloda.fast.data.api.friends.FriendsRepositoryImpl
@@ -45,7 +45,7 @@ val dataModule = module {
 
     singleOf(::AuthRepositoryImpl) bind AuthRepository::class
 
-    singleOf(::ConversationsRepositoryImpl) bind ConversationsRepository::class
+    singleOf(::ConvosRepositoryImpl) bind ConvosRepository::class
 
     singleOf(::FilesRepository)
 

core/database/schemas/dev.meloda.fast.database.CacheDatabase/10.json

@@ -2,7 +2,7 @@
   "formatVersion": 1,
   "database": {
     "version": 10,
-    "identityHash": "fa307a5eb2e1f7d601bd1374174635cd",
+    "identityHash": "6c315b7f800694f635318d86032746ec",
     "entities": [
       {
         "tableName": "users",
@@ -41,50 +41,42 @@
           {
             "fieldPath": "onlineAppId",
             "columnName": "onlineAppId",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "lastSeen",
             "columnName": "lastSeen",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "lastSeenStatus",
             "columnName": "lastSeenStatus",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "birthday",
             "columnName": "birthday",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo50",
             "columnName": "photo50",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo100",
             "columnName": "photo100",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo200",
             "columnName": "photo200",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo400Orig",
             "columnName": "photo400Orig",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           }
         ],
         "primaryKey": {
@@ -92,9 +84,7 @@
           "columnNames": [
             "id"
           ]
-        },
-        "indices": [],
-        "foreignKeys": []
+        }
       },
       {
         "tableName": "groups",
@@ -121,26 +111,22 @@
           {
             "fieldPath": "photo50",
             "columnName": "photo50",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo100",
             "columnName": "photo100",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo200",
             "columnName": "photo200",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "membersCount",
             "columnName": "membersCount",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           }
         ],
         "primaryKey": {
@@ -148,13 +134,11 @@
           "columnNames": [
             "id"
           ]
-        },
-        "indices": [],
-        "foreignKeys": []
+        }
       },
       {
         "tableName": "messages",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `conversationMessageId` INTEGER NOT NULL, `text` TEXT, `isOut` INTEGER NOT NULL, `peerId` INTEGER NOT NULL, `fromId` INTEGER NOT NULL, `date` INTEGER NOT NULL, `randomId` INTEGER NOT NULL, `action` TEXT, `actionMemberId` INTEGER, `actionText` TEXT, `actionConversationMessageId` INTEGER, `actionMessage` TEXT, `updateTime` INTEGER, `important` INTEGER NOT NULL, `forwardIds` TEXT, `attachments` TEXT, `replyMessageId` INTEGER, `geoType` TEXT, `pinnedAt` INTEGER, `isPinned` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `cmId` INTEGER NOT NULL, `text` TEXT, `isOut` INTEGER NOT NULL, `peerId` INTEGER NOT NULL, `fromId` INTEGER NOT NULL, `date` INTEGER NOT NULL, `randomId` INTEGER NOT NULL, `action` TEXT, `actionMemberId` INTEGER, `actionText` TEXT, `actionCmId` INTEGER, `actionMessage` TEXT, `updateTime` INTEGER, `important` INTEGER NOT NULL, `forwardIds` TEXT, `attachments` TEXT, `replyMessageId` INTEGER, `geoType` TEXT, `pinnedAt` INTEGER, `isPinned` INTEGER NOT NULL, PRIMARY KEY(`id`))",
         "fields": [
           {
             "fieldPath": "id",
@@ -163,16 +147,15 @@
             "notNull": true
           },
           {
-            "fieldPath": "conversationMessageId",
-            "columnName": "conversationMessageId",
+            "fieldPath": "cmId",
+            "columnName": "cmId",
             "affinity": "INTEGER",
             "notNull": true
           },
           {
             "fieldPath": "text",
             "columnName": "text",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "isOut",
@@ -207,38 +190,32 @@
           {
             "fieldPath": "action",
             "columnName": "action",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "actionMemberId",
             "columnName": "actionMemberId",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "actionText",
             "columnName": "actionText",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
-            "fieldPath": "actionConversationMessageId",
-            "columnName": "actionConversationMessageId",
-            "affinity": "INTEGER",
-            "notNull": false
+            "fieldPath": "actionCmId",
+            "columnName": "actionCmId",
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "actionMessage",
             "columnName": "actionMessage",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "updateTime",
             "columnName": "updateTime",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "important",
@@ -249,32 +226,27 @@
           {
             "fieldPath": "forwardIds",
             "columnName": "forwardIds",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "attachments",
             "columnName": "attachments",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "replyMessageId",
             "columnName": "replyMessageId",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "geoType",
             "columnName": "geoType",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "pinnedAt",
             "columnName": "pinnedAt",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "isPinned",
@@ -288,13 +260,11 @@
           "columnNames": [
             "id"
           ]
-        },
-        "indices": [],
-        "foreignKeys": []
+        }
       },
       {
         "tableName": "conversations",
-        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `localId` INTEGER NOT NULL, `ownerId` INTEGER, `title` TEXT, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `isPhantom` INTEGER NOT NULL, `lastConversationMessageId` INTEGER NOT NULL, `inReadCmId` INTEGER NOT NULL, `outReadCmId` INTEGER NOT NULL, `inRead` INTEGER NOT NULL, `outRead` INTEGER NOT NULL, `lastMessageId` INTEGER, `unreadCount` INTEGER NOT NULL, `membersCount` INTEGER, `canChangePin` INTEGER NOT NULL, `canChangeInfo` INTEGER NOT NULL, `majorId` INTEGER NOT NULL, `minorId` INTEGER NOT NULL, `pinnedMessageId` INTEGER, `peerType` TEXT NOT NULL, `isArchived` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `localId` INTEGER NOT NULL, `ownerId` INTEGER, `title` TEXT, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `isPhantom` INTEGER NOT NULL, `lastCmId` INTEGER NOT NULL, `inReadCmId` INTEGER NOT NULL, `outReadCmId` INTEGER NOT NULL, `inRead` INTEGER NOT NULL, `outRead` INTEGER NOT NULL, `lastMessageId` INTEGER, `unreadCount` INTEGER NOT NULL, `membersCount` INTEGER, `canChangePin` INTEGER NOT NULL, `canChangeInfo` INTEGER NOT NULL, `majorId` INTEGER NOT NULL, `minorId` INTEGER NOT NULL, `pinnedMessageId` INTEGER, `peerType` TEXT NOT NULL, `isArchived` INTEGER NOT NULL, PRIMARY KEY(`id`))",
         "fields": [
           {
             "fieldPath": "id",
@@ -311,32 +281,27 @@
           {
             "fieldPath": "ownerId",
             "columnName": "ownerId",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "title",
             "columnName": "title",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo50",
             "columnName": "photo50",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo100",
             "columnName": "photo100",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "photo200",
             "columnName": "photo200",
-            "affinity": "TEXT",
-            "notNull": false
+            "affinity": "TEXT"
           },
           {
             "fieldPath": "isPhantom",
@@ -345,8 +310,8 @@
             "notNull": true
           },
           {
-            "fieldPath": "lastConversationMessageId",
-            "columnName": "lastConversationMessageId",
+            "fieldPath": "lastCmId",
+            "columnName": "lastCmId",
             "affinity": "INTEGER",
             "notNull": true
           },
@@ -377,8 +342,7 @@
           {
             "fieldPath": "lastMessageId",
             "columnName": "lastMessageId",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "unreadCount",
@@ -389,8 +353,7 @@
           {
             "fieldPath": "membersCount",
             "columnName": "membersCount",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "canChangePin",
@@ -419,8 +382,7 @@
           {
             "fieldPath": "pinnedMessageId",
             "columnName": "pinnedMessageId",
-            "affinity": "INTEGER",
-            "notNull": false
+            "affinity": "INTEGER"
           },
           {
             "fieldPath": "peerType",
@@ -440,15 +402,12 @@
           "columnNames": [
             "id"
           ]
-        },
-        "indices": [],
-        "foreignKeys": []
+        }
       }
     ],
-    "views": [],
     "setupQueries": [
       "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
-      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'fa307a5eb2e1f7d601bd1374174635cd')"
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '6c315b7f800694f635318d86032746ec')"
     ]
   }
 }

core/database/schemas/dev.meloda.fast.database.CacheDatabase/11.json

@@ -0,0 +1,413 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 11,
+    "identityHash": "a746865995959331f8a1b512c049dacb",
+    "entities": [
+      {
+        "tableName": "users",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `firstName` TEXT NOT NULL, `lastName` TEXT NOT NULL, `isOnline` INTEGER NOT NULL, `isOnlineMobile` INTEGER NOT NULL, `onlineAppId` INTEGER, `lastSeen` INTEGER, `lastSeenStatus` TEXT, `birthday` TEXT, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `photo400Orig` TEXT, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "firstName",
+            "columnName": "firstName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastName",
+            "columnName": "lastName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isOnline",
+            "columnName": "isOnline",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isOnlineMobile",
+            "columnName": "isOnlineMobile",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "onlineAppId",
+            "columnName": "onlineAppId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "lastSeen",
+            "columnName": "lastSeen",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "lastSeenStatus",
+            "columnName": "lastSeenStatus",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "birthday",
+            "columnName": "birthday",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo50",
+            "columnName": "photo50",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo100",
+            "columnName": "photo100",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo200",
+            "columnName": "photo200",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo400Orig",
+            "columnName": "photo400Orig",
+            "affinity": "TEXT"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "groups",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `name` TEXT NOT NULL, `screenName` TEXT NOT NULL, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `membersCount` INTEGER, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "screenName",
+            "columnName": "screenName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "photo50",
+            "columnName": "photo50",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo100",
+            "columnName": "photo100",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo200",
+            "columnName": "photo200",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "membersCount",
+            "columnName": "membersCount",
+            "affinity": "INTEGER"
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "messages",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `cmId` INTEGER NOT NULL, `text` TEXT, `isOut` INTEGER NOT NULL, `peerId` INTEGER NOT NULL, `fromId` INTEGER NOT NULL, `date` INTEGER NOT NULL, `randomId` INTEGER NOT NULL, `action` TEXT, `actionMemberId` INTEGER, `actionText` TEXT, `actionCmId` INTEGER, `actionMessage` TEXT, `updateTime` INTEGER, `important` INTEGER NOT NULL, `forwardIds` TEXT, `attachments` TEXT, `replyMessageId` INTEGER, `geoType` TEXT, `pinnedAt` INTEGER, `isPinned` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "cmId",
+            "columnName": "cmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "text",
+            "columnName": "text",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "isOut",
+            "columnName": "isOut",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "peerId",
+            "columnName": "peerId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "fromId",
+            "columnName": "fromId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "date",
+            "columnName": "date",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "randomId",
+            "columnName": "randomId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "action",
+            "columnName": "action",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "actionMemberId",
+            "columnName": "actionMemberId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "actionText",
+            "columnName": "actionText",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "actionCmId",
+            "columnName": "actionCmId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "actionMessage",
+            "columnName": "actionMessage",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "updateTime",
+            "columnName": "updateTime",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "important",
+            "columnName": "important",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "forwardIds",
+            "columnName": "forwardIds",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "attachments",
+            "columnName": "attachments",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "replyMessageId",
+            "columnName": "replyMessageId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "geoType",
+            "columnName": "geoType",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "pinnedAt",
+            "columnName": "pinnedAt",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "isPinned",
+            "columnName": "isPinned",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "convos",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `localId` INTEGER NOT NULL, `ownerId` INTEGER, `title` TEXT, `photo50` TEXT, `photo100` TEXT, `photo200` TEXT, `isPhantom` INTEGER NOT NULL, `lastCmId` INTEGER NOT NULL, `inReadCmId` INTEGER NOT NULL, `outReadCmId` INTEGER NOT NULL, `inRead` INTEGER NOT NULL, `outRead` INTEGER NOT NULL, `lastMessageId` INTEGER, `unreadCount` INTEGER NOT NULL, `membersCount` INTEGER, `canChangePin` INTEGER NOT NULL, `canChangeInfo` INTEGER NOT NULL, `majorId` INTEGER NOT NULL, `minorId` INTEGER NOT NULL, `pinnedMessageId` INTEGER, `peerType` TEXT NOT NULL, `isArchived` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "localId",
+            "columnName": "localId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "ownerId",
+            "columnName": "ownerId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "title",
+            "columnName": "title",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo50",
+            "columnName": "photo50",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo100",
+            "columnName": "photo100",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "photo200",
+            "columnName": "photo200",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "isPhantom",
+            "columnName": "isPhantom",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastCmId",
+            "columnName": "lastCmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "inReadCmId",
+            "columnName": "inReadCmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "outReadCmId",
+            "columnName": "outReadCmId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "inRead",
+            "columnName": "inRead",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "outRead",
+            "columnName": "outRead",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastMessageId",
+            "columnName": "lastMessageId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "unreadCount",
+            "columnName": "unreadCount",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "membersCount",
+            "columnName": "membersCount",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "canChangePin",
+            "columnName": "canChangePin",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "canChangeInfo",
+            "columnName": "canChangeInfo",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "majorId",
+            "columnName": "majorId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "minorId",
+            "columnName": "minorId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "pinnedMessageId",
+            "columnName": "pinnedMessageId",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "peerType",
+            "columnName": "peerType",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isArchived",
+            "columnName": "isArchived",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'a746865995959331f8a1b512c049dacb')"
+    ]
+  }
+}

core/database/src/main/kotlin/dev/meloda/fast/database/CacheDatabase.kt

@@ -3,12 +3,12 @@ package dev.meloda.fast.database
 import androidx.room.Database
 import androidx.room.RoomDatabase
 import androidx.room.TypeConverters
-import dev.meloda.fast.database.dao.ConversationDao
+import dev.meloda.fast.database.dao.ConvoDao
 import dev.meloda.fast.database.dao.GroupDao
 import dev.meloda.fast.database.dao.MessageDao
 import dev.meloda.fast.database.dao.UserDao
 import dev.meloda.fast.database.typeconverters.Converters
-import dev.meloda.fast.model.database.VkConversationEntity
+import dev.meloda.fast.model.database.VkConvoEntity
 import dev.meloda.fast.model.database.VkGroupEntity
 import dev.meloda.fast.model.database.VkMessageEntity
 import dev.meloda.fast.model.database.VkUserEntity
@@ -18,15 +18,15 @@ import dev.meloda.fast.model.database.VkUserEntity
         VkUserEntity::class,
         VkGroupEntity::class,
         VkMessageEntity::class,
-        VkConversationEntity::class
+        VkConvoEntity::class
     ],
 
-    version = 10
+    version = 11
 )
 @TypeConverters(Converters::class)
 abstract class CacheDatabase : RoomDatabase() {
     abstract fun userDao(): UserDao
     abstract fun groupDao(): GroupDao
     abstract fun messageDao(): MessageDao
-    abstract fun conversationDao(): ConversationDao
+    abstract fun convoDao(): ConvoDao
 }

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

@@ -1,30 +0,0 @@
-package dev.meloda.fast.database.dao
-
-import androidx.room.Dao
-import androidx.room.Query
-import androidx.room.Transaction
-import dev.meloda.fast.model.database.ConversationWithMessage
-import dev.meloda.fast.model.database.VkConversationEntity
-
-@Dao
-abstract class ConversationDao : EntityDao<VkConversationEntity> {
-
-    @Query("SELECT * FROM conversations")
-    abstract suspend fun getAll(): List<VkConversationEntity>
-
-    @Query("SELECT * FROM conversations WHERE id IN (:ids)")
-    abstract suspend fun getAllByIds(ids: List<Int>): List<VkConversationEntity>
-
-    @Query("SELECT * FROM conversations WHERE id IS (:id)")
-    abstract suspend fun getById(id: Long): VkConversationEntity?
-
-    @Transaction
-    @Query("SELECT * FROM conversations WHERE id IS (:id)")
-    abstract suspend fun getByIdWithMessage(id: Long): ConversationWithMessage?
-
-    @Query("DELETE FROM conversations WHERE rowid IN (:ids)")
-    abstract suspend fun deleteByIds(ids: List<Int>): Int
-}
-
-
-

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

@@ -0,0 +1,37 @@
+package dev.meloda.fast.database.dao
+
+import androidx.room.Dao
+import androidx.room.Query
+import androidx.room.Transaction
+import dev.meloda.fast.model.database.ConvoWithMessage
+import dev.meloda.fast.model.database.VkConvoEntity
+
+@Dao
+abstract class ConvoDao : EntityDao<VkConvoEntity> {
+
+    @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>
+
+    @Query("SELECT * FROM convos WHERE id IS (:id)")
+    abstract suspend fun getById(id: Long): VkConvoEntity?
+
+    @Transaction
+    @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 (:conversationId)")
-    abstract suspend fun getAll(conversationId: Long): List<VkMessageEntity>
+    @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/database/src/main/kotlin/dev/meloda/fast/database/di/DatabaseModule.kt

@@ -17,13 +17,13 @@ val databaseModule = module {
 
     single {
         Room.databaseBuilder(get(), CacheDatabase::class.java, "cache")
-            .fallbackToDestructiveMigration()
+            .fallbackToDestructiveMigration(true)
             .build()
     }
     single { cacheDB().userDao() }
     single { cacheDB().groupDao() }
     single { cacheDB().messageDao() }
-    single { cacheDB().conversationDao() }
+    single { cacheDB().convoDao() }
 }
 
 private fun Scope.cacheDB(): CacheDatabase = get()

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
     }
@@ -96,6 +115,20 @@ object AppSettings {
             )
             set(value) = put(SettingsKeys.KEY_SHOW_EMOJI_BUTTON, value)
 
+        var showAttachmentButton: Boolean
+            get() = get(
+                SettingsKeys.KEY_SHOW_ATTACHMENT_BUTTON,
+                SettingsKeys.DEFAULT_VALUE_SHOW_ATTACHMENT_BUTTON
+            )
+            set(value) = put(SettingsKeys.KEY_SHOW_ATTACHMENT_BUTTON, value)
+
+        var showManualRefreshOptions: Boolean
+            get() = get(
+                SettingsKeys.KEY_SHOW_MANUAL_REFRESH_OPTIONS,
+                SettingsKeys.DEFAULT_VALUE_SHOW_MANUAL_REFRESH_OPTIONS
+            )
+            set(value) = put(SettingsKeys.KEY_SHOW_MANUAL_REFRESH_OPTIONS, value)
+
         var enableHaptic: Boolean
             get() = get(
                 SettingsKeys.KEY_ENABLE_HAPTIC,
@@ -197,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

@@ -11,6 +11,10 @@ object SettingsKeys {
     const val DEFAULT_VALUE_USE_CONTACT_NAMES = false
     const val KEY_SHOW_EMOJI_BUTTON = "show_emoji_button"
     const val DEFAULT_VALUE_KEY_SHOW_EMOJI_BUTTON = false
+    const val KEY_SHOW_ATTACHMENT_BUTTON = "show_attachment_button"
+    const val DEFAULT_VALUE_SHOW_ATTACHMENT_BUTTON = false
+    const val KEY_SHOW_MANUAL_REFRESH_OPTIONS = "show_manual_refresh_options"
+    const val DEFAULT_VALUE_SHOW_MANUAL_REFRESH_OPTIONS = false
 
     const val KEY_APPEARANCE = "appearance"
     const val KEY_APPEARANCE_MULTILINE = "appearance_multiline"
@@ -35,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
@@ -46,6 +52,9 @@ object SettingsKeys {
     const val DEFAULT_ENABLE_HAPTIC = true
     const val KEY_DEBUG_NETWORK_LOG_LEVEL = "debug_network_log_level"
     const val DEFAULT_NETWORK_LOG_LEVEL = 3
+    const val KEY_DEBUG_IMPORT_AUTH_DATA = "debug_import_auth_data"
+    const val KEY_DEBUG_EXPORT_AUTH_DATA = "debug_export_auth_data"
+
     const val KEY_USE_SYSTEM_FONT = "use_system_font"
     const val DEFAULT_USE_SYSTEM_FONT = false
     const val KEY_MORE_ANIMATIONS = "more_animations"

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

@@ -14,15 +14,10 @@ interface UserSettings {
     val enableDynamicColors: StateFlow<Boolean>
     val appLanguage: StateFlow<String>
 
-    val fastText: StateFlow<String>
-
     val sendOnlineStatus: StateFlow<Boolean>
 
-    val showAlertAfterCrash: StateFlow<Boolean>
     val longPollInBackground: StateFlow<Boolean>
     val useBlur: StateFlow<Boolean>
-    val showEmojiButton: StateFlow<Boolean>
-    val showTimeInActionMessages: StateFlow<Boolean>
     val useSystemFont: StateFlow<Boolean>
     val enableAnimations: StateFlow<Boolean>
     val showDebugCategory: StateFlow<Boolean>
@@ -35,15 +30,10 @@ interface UserSettings {
     fun onEnableDynamicColorsChanged(enable: Boolean)
     fun onAppLanguageChanged(language: String)
 
-    fun onFastTextChanged(text: String)
-
     fun onSendOnlineStatusChanged(send: Boolean)
 
-    fun onShowAlertAfterCrashChanged(show: Boolean)
     fun onLongPollInBackgroundChanged(inBackground: Boolean)
     fun onUseBlurChanged(use: Boolean)
-    fun onShowEmojiButtonChanged(show: Boolean)
-    fun onShowTimeInActionMessagesChanged(show: Boolean)
     fun onUseSystemFontChanged(use: Boolean)
     fun onShowDebugCategoryChanged(show: Boolean)
 }
@@ -58,16 +48,11 @@ class UserSettingsImpl : UserSettings {
     override val enableDynamicColors = MutableStateFlow(AppSettings.Appearance.enableDynamicColors)
     override val appLanguage = MutableStateFlow(AppSettings.Appearance.appLanguage)
 
-    override val fastText = MutableStateFlow(AppSettings.Features.fastText)
-
     override val sendOnlineStatus = MutableStateFlow(AppSettings.Activity.sendOnlineStatus)
 
-    override val showAlertAfterCrash = MutableStateFlow(AppSettings.Debug.showAlertAfterCrash)
-    override val longPollInBackground = MutableStateFlow(AppSettings.Experimental.longPollInBackground)
+    override val longPollInBackground =
+        MutableStateFlow(AppSettings.Experimental.longPollInBackground)
     override val useBlur = MutableStateFlow(AppSettings.Experimental.useBlur)
-    override val showEmojiButton = MutableStateFlow(AppSettings.General.showEmojiButton)
-    override val showTimeInActionMessages =
-        MutableStateFlow(AppSettings.Experimental.showTimeInActionMessages)
     override val useSystemFont = MutableStateFlow(AppSettings.Appearance.useSystemFont)
     override val enableAnimations = MutableStateFlow(AppSettings.Experimental.moreAnimations)
     override val showDebugCategory = MutableStateFlow(AppSettings.Debug.showDebugCategory)
@@ -96,18 +81,10 @@ class UserSettingsImpl : UserSettings {
         appLanguage.value = language
     }
 
-    override fun onFastTextChanged(text: String) {
-        fastText.value = text
-    }
-
     override fun onSendOnlineStatusChanged(send: Boolean) {
         sendOnlineStatus.value = send
     }
 
-    override fun onShowAlertAfterCrashChanged(show: Boolean) {
-        showAlertAfterCrash.value = show
-    }
-
     override fun onLongPollInBackgroundChanged(inBackground: Boolean) {
         longPollInBackground.value = inBackground
     }
@@ -116,14 +93,6 @@ class UserSettingsImpl : UserSettings {
         useBlur.value = use
     }
 
-    override fun onShowEmojiButtonChanged(show: Boolean) {
-        showEmojiButton.value = show
-    }
-
-    override fun onShowTimeInActionMessagesChanged(show: Boolean) {
-        showTimeInActionMessages.value = show
-    }
-
     override fun onUseSystemFontChanged(use: Boolean) {
         useSystemFont.value = use
     }

core/domain/build.gradle.kts

@@ -8,11 +8,16 @@ android {
 }
 
 dependencies {
+    api(projects.core.common)
     api(projects.core.data)
     api(projects.core.model)
 
-    // TODO: 11/08/2024, Danil Nikolaev: remove?
     implementation(libs.kotlinx.coroutines.core)
     implementation(libs.koin.core)
     implementation(libs.eithernet)
+
+    implementation(libs.bundles.nanokt)
+
+    implementation(platform(libs.compose.bom))
+    implementation(libs.compose.ui)
 }

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

@@ -1,25 +1,28 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
-import dev.meloda.fast.model.ConversationsFilter
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.ConvosFilter
+import dev.meloda.fast.model.api.domain.VkConvo
 import kotlinx.coroutines.flow.Flow
 
-interface ConversationsUseCase : BaseUseCase {
+interface ConvoUseCase : BaseUseCase {
 
-    suspend fun storeConversations(conversations: List<VkConversation>)
+    suspend fun storeConvos(convos: List<VkConvo>)
+    suspend fun getLocalConvos(): List<VkConvo>
+    suspend fun getLocalConvoById(peerId: Long): VkConvo?
+    suspend fun deleteLocalConvo(peerId: Long)
 
-    fun getConversations(
+    fun getConvos(
         count: Int? = null,
         offset: Int? = null,
-        filter: ConversationsFilter
-    ): Flow<State<List<VkConversation>>>
+        filter: ConvosFilter
+    ): Flow<State<List<VkConvo>>>
 
     fun getById(
         peerIds: List<Long>,
         extended: Boolean? = null,
         fields: String? = null
-    ): Flow<State<List<VkConversation>>>
+    ): Flow<State<List<VkConvo>>>
 
     fun delete(peerId: Long): Flow<State<Long>>
 

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

@@ -1,30 +1,42 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
-import dev.meloda.fast.data.api.conversations.ConversationsRepository
+import dev.meloda.fast.data.api.convos.ConvosRepository
 import dev.meloda.fast.data.mapToState
-import dev.meloda.fast.model.ConversationsFilter
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.ConvosFilter
+import dev.meloda.fast.model.api.domain.VkConvo
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.withContext
 
-class ConversationsUseCaseImpl(
-    private val repository: ConversationsRepository,
-) : ConversationsUseCase {
+class ConvoUseCaseImpl(
+    private val repository: ConvosRepository,
+) : ConvoUseCase {
 
-    override suspend fun storeConversations(
-        conversations: List<VkConversation>
+    override suspend fun storeConvos(
+        convos: List<VkConvo>
     ) = withContext(Dispatchers.IO) {
-        repository.storeConversations(conversations)
+        repository.storeConvos(convos)
     }
 
-    override fun getConversations(
+    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?,
-        filter: ConversationsFilter
-    ): Flow<State<List<VkConversation>>> = flowNewState {
-        repository.getConversations(
+        filter: ConvosFilter
+    ): Flow<State<List<VkConvo>>> = flowNewState {
+        repository.getConvos(
             count = count,
             offset = offset,
             filter = filter
@@ -35,8 +47,8 @@ class ConversationsUseCaseImpl(
         peerIds: List<Long>,
         extended: Boolean?,
         fields: String?
-    ): Flow<State<List<VkConversation>>> = flowNewState {
-        repository.getConversationsById(
+    ): Flow<State<List<VkConvo>>> = flowNewState {
+        repository.getConvosById(
             peerIds = peerIds,
             extended = extended,
             fields = fields

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/GetMessageReadPeersUseCase.kt

@@ -0,0 +1,21 @@
+package dev.meloda.fast.domain
+
+import dev.meloda.fast.data.State
+import dev.meloda.fast.data.api.messages.MessagesRepository
+import dev.meloda.fast.data.mapToState
+import kotlinx.coroutines.flow.Flow
+
+class GetMessageReadPeersUseCase(
+    private val repository: MessagesRepository
+) : BaseUseCase {
+
+    operator fun invoke(
+        peerId: Long,
+        cmId: Long
+    ): Flow<State<Int>> = flowNewState {
+        repository.getMessageReadPeers(
+            peerId = peerId,
+            cmId = cmId
+        ).mapToState(successMapper = { it.totalCount })
+    }
+}

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

@@ -1,22 +1,22 @@
 package dev.meloda.fast.domain
 
 import dev.meloda.fast.data.State
-import dev.meloda.fast.data.api.conversations.ConversationsRepository
+import dev.meloda.fast.data.api.convos.ConvosRepository
 import dev.meloda.fast.data.mapToState
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import kotlinx.coroutines.flow.Flow
 
-class LoadConversationsByIdUseCase(
-    private val conversationsRepository: ConversationsRepository
+class LoadConvosByIdUseCase(
+    private val convosRepository: ConvosRepository
 ) : BaseUseCase {
 
     operator fun invoke(
         peerIds: List<Long>,
         extended: Boolean? = null,
         fields: String? = null
-    ): Flow<State<List<VkConversation>>> = flowNewState {
-        conversationsRepository
-            .getConversationsById(
+    ): Flow<State<List<VkConvo>>> = flowNewState {
+        convosRepository
+            .getConvosById(
                 peerIds = peerIds,
                 extended = extended,
                 fields = fields,

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.ConversationFlags
-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.VkConversation
-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 conversationsUseCase: ConversationsUseCase,
-    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 conversation =
-                async {
-                    loadConversation(
-                        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 = conversation?.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 = ConversationFlags.parse(flags)
-
-        coroutineScope.launch(Dispatchers.IO) {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    ConversationFlags.ARCHIVED -> {
-                        val conversation = loadConversation(
-                            peerId = peerId,
-                            extended = true,
-                            fields = VkConstants.ALL_FIELDS
-                        ) ?: return@forEach
-
-                        val message = loadMessage(
-                            peerId = peerId,
-                            cmId = conversation.lastCmId
-                        )
-
-                        val eventToSend = LongPollParsedEvent.ChatArchived(
-                            conversation = conversation.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 = ConversationFlags.parse(flags)
-
-        coroutineScope.launch(Dispatchers.IO) {
-            parsedFlags.forEach { flag ->
-                when (flag) {
-                    ConversationFlags.ARCHIVED -> {
-                        val conversation = loadConversation(
-                            peerId = peerId,
-                            extended = true,
-                            fields = VkConstants.ALL_FIELDS
-                        ) ?: return@forEach
-
-                        val message = loadMessage(
-                            peerId = peerId,
-                            cmId = conversation.lastCmId
-                        )
-
-                        val eventToSend = LongPollParsedEvent.ChatArchived(
-                            conversation = conversation.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 loadConversation(
-        peerId: Long,
-        extended: Boolean = false,
-        fields: String? = null
-    ): VkConversation? = suspendCoroutine { continuation ->
-        coroutineScope.launch(Dispatchers.IO) {
-            conversationsUseCase.getById(
-                peerIds = listOf(peerId),
-                extended = extended,
-                fields = fields
-            ).listenValue(coroutineScope) { state ->
-                state.processState(
-                    error = { error ->
-                        Log.e("LongPollUpdatesParser", "loadConversation: error: $error")
-                        continuation.resume(null)
-                    },
-                    success = { response ->
-                        val conversation = response.singleOrNull() ?: run {
-                            continuation.resume(null)
-                            return@listenValue
-                        }
-
-                        continuation.resume(conversation)
-                    }
-                )
-            }
-        }
-    }
-
-    @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,9 +12,14 @@ 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(
-        conversationId: Long,
+        convoId: Long,
         count: Int?,
         offset: Int?
     ): Flow<State<MessagesHistoryInfo>>
@@ -32,7 +37,7 @@ interface MessagesUseCase : BaseUseCase {
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
+        forward: String?,
         attachments: List<VkAttachment>?,
         formatData: VkMessage.FormatData?
     ): Flow<State<MessagesSendResponse>>

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

@@ -22,13 +22,33 @@ 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(
-        conversationId: Long,
+        convoId: Long,
         count: Int?,
         offset: Int?
     ): Flow<State<MessagesHistoryInfo>> = flowNewState {
         repository.getHistory(
-            conversationId = conversationId,
+            convoId = convoId,
             offset = offset,
             count = count
         ).mapToState()
@@ -56,7 +76,7 @@ class MessagesUseCaseImpl(
         peerId: Long,
         randomId: Long,
         message: String?,
-        replyTo: Long?,
+        forward: String?,
         attachments: List<VkAttachment>?,
         formatData: VkMessage.FormatData?
     ): Flow<State<MessagesSendResponse>> = flowNewState {
@@ -64,7 +84,7 @@ class MessagesUseCaseImpl(
             peerId = peerId,
             randomId = randomId,
             message = message,
-            replyTo = replyTo,
+            forward = forward,
             attachments = attachments,
             formatData = formatData
         ).mapToState()

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/di/DomainModule.kt

@@ -6,7 +6,8 @@ import dev.meloda.fast.domain.AccountUseCaseImpl
 import dev.meloda.fast.domain.GetCurrentAccountUseCase
 import dev.meloda.fast.domain.GetLocalUserByIdUseCase
 import dev.meloda.fast.domain.GetLocalUsersByIdsUseCase
-import dev.meloda.fast.domain.LoadConversationsByIdUseCase
+import dev.meloda.fast.domain.GetMessageReadPeersUseCase
+import dev.meloda.fast.domain.LoadConvosByIdUseCase
 import dev.meloda.fast.domain.LoadUserByIdUseCase
 import dev.meloda.fast.domain.LoadUsersByIdsUseCase
 import dev.meloda.fast.domain.StoreUsersUseCase
@@ -26,5 +27,7 @@ val domainModule = module {
     singleOf(::AccountUseCaseImpl) bind AccountUseCase::class
     singleOf(::GetCurrentAccountUseCase)
 
-    singleOf(::LoadConversationsByIdUseCase)
+    singleOf(::LoadConvosByIdUseCase)
+
+    singleOf(::GetMessageReadPeersUseCase)
 }

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

@@ -1,7 +1,6 @@
-package dev.meloda.fast.conversations.util
+package dev.meloda.fast.domain.util
 
 import android.content.res.Resources
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.text.SpanStyle
 import androidx.compose.ui.text.buildAnnotatedString
@@ -13,57 +12,22 @@ import dev.meloda.fast.common.extensions.orDots
 import dev.meloda.fast.common.model.UiImage
 import dev.meloda.fast.common.model.UiText
 import dev.meloda.fast.common.model.parseString
-import dev.meloda.fast.common.util.TimeUtils
 import dev.meloda.fast.data.UserConfig
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.model.InteractionType
 import dev.meloda.fast.model.api.PeerType
 import dev.meloda.fast.model.api.data.AttachmentType
 import dev.meloda.fast.model.api.domain.VkAttachment
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.model.api.domain.VkVideoDomain
-import dev.meloda.fast.ui.model.api.ActionState
-import dev.meloda.fast.ui.model.api.ConversationOption
-import dev.meloda.fast.ui.model.api.UiConversation
-import dev.meloda.fast.ui.util.ImmutableList
-import dev.meloda.fast.ui.util.emptyImmutableList
+import dev.meloda.fast.ui.R
 import java.util.Calendar
 import java.util.Locale
 import kotlin.math.ln
 import kotlin.math.pow
-import dev.meloda.fast.ui.R as UiR
 
-fun VkConversation.asPresentation(
-    resources: Resources,
-    useContactName: Boolean,
-    isExpanded: Boolean = false,
-    options: ImmutableList<ConversationOption> = emptyImmutableList()
-): UiConversation = UiConversation(
-    id = id,
-    lastMessageId = lastMessageId,
-    avatar = extractAvatar(),
-    title = extractTitle(this, useContactName, resources),
-    unreadCount = extractUnreadCount(lastMessage, this),
-    date = TimeUtils.getLocalizedTime(resources, (lastMessage?.date ?: -1) * 1000L),
-    message = extractMessage(resources, lastMessage, id, peerType),
-    attachmentImage = if (lastMessage?.text == null) null
-    else getAttachmentConversationIcon(lastMessage),
-    isPinned = majorId > 0,
-    actionImageId = ActionState.parse(isPhantom, isCallInProgress).getResourceId(),
-    isBirthday = extractBirthday(this),
-    isUnread = !isRead(),
-    isAccount = isAccount(id),
-    isOnline = !isAccount(id) && user?.onlineStatus?.isOnline() == true,
-    lastMessage = lastMessage,
-    peerType = peerType,
-    interactionText = extractInteractionText(resources, this),
-    isExpanded = isExpanded,
-    isArchived = isArchived,
-    options = options
-)
-
-fun VkConversation.extractAvatar() = when (peerType) {
+fun VkConvo.extractAvatar(): UiImage = when (peerType) {
     PeerType.USER -> {
         if (isAccount(id)) null
         else user?.photo200
@@ -76,20 +40,19 @@ fun VkConversation.extractAvatar() = when (peerType) {
     PeerType.CHAT -> {
         photo200
     }
-}?.let(UiImage::Url) ?: UiImage.Resource(UiR.drawable.ic_account_circle_cut)
+}?.let(UiImage::Url) ?: UiImage.Resource(R.drawable.ic_account_circle_fill_round_24)
 
-private fun extractTitle(
-    conversation: VkConversation,
+fun VkConvo.extractTitle(
     useContactName: Boolean,
     resources: Resources
-) = when (conversation.peerType) {
+) = when (peerType) {
     PeerType.USER -> {
-        if (isAccount(conversation.id)) {
-            UiText.Resource(UiR.string.favorites)
+        if (isAccount(id)) {
+            UiText.Resource(R.string.favorites)
         } else {
-            val userName = conversation.user?.let { user ->
+            val userName = user?.let { user ->
                 if (useContactName) {
-                    VkMemoryCache.getContact(user.id)?.name ?: user.fullName
+                    VkMemoryCache.getContact(user.id)?.name
                 } else {
                     user.fullName
                 }
@@ -99,22 +62,22 @@ private fun extractTitle(
         }
     }
 
-    PeerType.GROUP -> UiText.Simple(conversation.group?.name.orDots())
-    PeerType.CHAT -> UiText.Simple(conversation.title.orDots())
+    PeerType.GROUP -> UiText.Simple(group?.name.orDots())
+    PeerType.CHAT -> UiText.Simple(title.orDots())
 }.parseString(resources).orDots()
 
-private fun extractUnreadCount(
+fun extractUnreadCount(
     lastMessage: VkMessage?,
-    conversation: VkConversation
+    convo: VkConvo
 ): String? = when {
-    lastMessage?.isOut == false && conversation.isInRead() -> null
-    conversation.unreadCount == 0 -> null
-    conversation.unreadCount < 1000 -> conversation.unreadCount.toString()
+    lastMessage?.isOut == false && convo.isInRead() -> null
+    convo.unreadCount == 0 -> null
+    convo.unreadCount < 1000 -> convo.unreadCount.toString()
     else -> {
-        val exp = (ln(conversation.unreadCount.toDouble()) / ln(1000.0)).toInt()
+        val exp = (ln(convo.unreadCount.toDouble()) / ln(1000.0)).toInt()
         val suffix = "KMBT"[exp - 1]
 
-        val result = conversation.unreadCount / 1000.0.pow(exp.toDouble())
+        val result = convo.unreadCount / 1000.0.pow(exp.toDouble())
 
         if (result.toLong().toDouble() == result) {
             String.format(Locale.getDefault(), "%.0f%s", result, suffix)
@@ -124,13 +87,14 @@ private fun extractUnreadCount(
     }
 }
 
-private fun extractMessage(
+fun extractMessage(
     resources: Resources,
     lastMessage: VkMessage?,
     peerId: Long,
-    peerType: PeerType
+    peerType: PeerType,
+    showPeer: Boolean = true
 ): AnnotatedString {
-    val youPrefix = UiText.Resource(UiR.string.you_message_prefix)
+    val youPrefix = UiText.Resource(R.string.you_message_prefix)
         .parseString(resources)
         .orDots()
 
@@ -153,6 +117,8 @@ private fun extractMessage(
     val messageText = lastMessage?.text.orEmpty()
 
     val prefixText: AnnotatedString? = when {
+        !showPeer -> null
+
         actionMessage != null -> null
 
         lastMessage == null -> null
@@ -219,16 +185,17 @@ private fun extractMessage(
                 .let { text ->
                     extractTextWithVisualizedMentions(
                         isOut = lastMessage?.isOut == true,
-                        originalText = text
+                        originalText = text,
+                        formatData = null
                     )
                 }
-                .let { text -> prefix + text }
+                .let { text -> prefix + text.orEmpty() }
     }
 
     return finalText
 }
 
-private fun extractActionText(
+fun extractActionText(
     lastMessage: VkMessage?,
     resources: Resources,
     youPrefix: String
@@ -265,7 +232,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_CREATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_created,
+                    R.string.message_action_chat_created,
                     listOf(prefix, text)
                 ).parseString(resources).orEmpty()
 
@@ -288,7 +255,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_TITLE_UPDATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_renamed,
+                    R.string.message_action_chat_renamed,
                     listOf(prefix, text)
                 ).parseString(resources).orEmpty()
 
@@ -311,7 +278,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_update,
+                    R.string.message_action_chat_photo_update,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -324,7 +291,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_REMOVE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_remove,
+                    R.string.message_action_chat_photo_remove,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -338,7 +305,7 @@ private fun extractActionText(
             VkMessage.Action.CHAT_KICK_USER -> {
                 if (memberId == fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_left,
+                        R.string.message_action_chat_user_left,
                         listOf(memberPrefix)
                     ).parseString(resources).orEmpty().let(::append)
 
@@ -353,7 +320,7 @@ private fun extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_kicked,
+                        R.string.message_action_chat_user_kicked,
                         listOf(prefix, postfix)
                     ).parseString(resources).orEmpty()
 
@@ -378,7 +345,7 @@ private fun extractActionText(
             VkMessage.Action.CHAT_INVITE_USER -> {
                 if (memberId == lastMessage.fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_returned,
+                        R.string.message_action_chat_user_returned,
                         listOf(memberPrefix)
                     ).parseString(resources).orEmpty().let(::append)
 
@@ -393,7 +360,7 @@ private fun extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_invited,
+                        R.string.message_action_chat_user_invited,
                         listOf(memberPrefix, postfix)
                     ).parseString(resources).orEmpty()
 
@@ -411,7 +378,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_link,
+                    R.string.message_action_chat_user_joined_by_link,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -424,7 +391,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call,
+                    R.string.message_action_chat_user_joined_by_call,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -437,7 +404,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call_link,
+                    R.string.message_action_chat_user_joined_by_call_link,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -450,7 +417,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_PIN_MESSAGE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_pin_message,
+                    R.string.message_action_chat_pin_message,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -463,7 +430,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_UNPIN_MESSAGE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_unpin_message,
+                    R.string.message_action_chat_unpin_message,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -476,7 +443,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_SCREENSHOT -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_screenshot,
+                    R.string.message_action_chat_screenshot,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -489,7 +456,7 @@ private fun extractActionText(
 
             VkMessage.Action.CHAT_STYLE_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_style_update,
+                    R.string.message_action_chat_style_update,
                     listOf(prefix)
                 ).parseString(resources).orEmpty().let(::append)
 
@@ -503,16 +470,25 @@ private fun extractActionText(
     }
 }
 
-private fun extractAttachmentIcon(
+fun extractAttachmentIcon(
     lastMessage: VkMessage?
 ): UiImage? = when {
     lastMessage == null -> null
     lastMessage.text == null -> null
+    lastMessage.geoType != null -> {
+        val geoType = lastMessage.geoType
+        if (geoType == "point") {
+            UiImage.Resource(R.drawable.ic_pin_drop_fill_round_24)
+        } else {
+            UiImage.Resource(R.drawable.ic_map_fill_round_24)
+        }
+    }
+
     !lastMessage.forwards.isNullOrEmpty() -> {
         if (lastMessage.forwards.orEmpty().size == 1) {
-            UiImage.Resource(UiR.drawable.ic_attachment_forwarded_message)
+            UiImage.Resource(R.drawable.ic_reply_round_24)
         } else {
-            UiImage.Resource(UiR.drawable.ic_attachment_forwarded_messages)
+            UiImage.Resource(R.drawable.ic_reply_all_round_24)
         }
     }
 
@@ -520,19 +496,15 @@ private fun extractAttachmentIcon(
         lastMessage.attachments?.let { attachments ->
             if (attachments.isEmpty()) return null
             if (attachments.size == 1 || isAttachmentsHaveOneType(attachments)) {
-                lastMessage.geoType?.let {
-                    return UiImage.Resource(UiR.drawable.ic_map_marker)
-                }
-
                 getAttachmentIconByType(attachments.first().type)
             } else {
-                UiImage.Resource(UiR.drawable.ic_baseline_attach_file_24)
+                UiImage.Resource(R.drawable.ic_attach_file_round_24)
             }
         }
     }
 }
 
-private fun extractAttachmentText(
+fun extractAttachmentText(
     resources: Resources,
     lastMessage: VkMessage?
 ): AnnotatedString? = when {
@@ -542,13 +514,13 @@ private fun extractAttachmentText(
             withStyle(style = SpanStyle(fontWeight = FontWeight.SemiBold)) {
                 when (lastMessage.geoType) {
                     "point" -> {
-                        UiText.Resource(UiR.string.message_geo_point)
+                        UiText.Resource(R.string.message_geo_point)
                             .parseString(resources)
                             .let(::append)
                     }
 
                     else -> {
-                        UiText.Resource(UiR.string.message_geo)
+                        UiText.Resource(R.string.message_geo)
                             .parseString(resources)
                             .let(::append)
                     }
@@ -583,7 +555,7 @@ private fun extractAttachmentText(
                         }
 
                         else -> {
-                            UiText.Resource(UiR.string.message_attachments_many)
+                            UiText.Resource(R.string.message_attachments_many)
                                 .parseString(resources)
                                 .let(::append)
                         }
@@ -598,22 +570,22 @@ private fun extractAttachmentText(
 
 private fun getAttachmentIconByType(attachmentType: AttachmentType): UiImage? {
     return when (attachmentType) {
-        AttachmentType.PHOTO -> UiR.drawable.ic_attachment_photo
-        AttachmentType.VIDEO -> UiR.drawable.ic_attachment_video
-        AttachmentType.AUDIO -> UiR.drawable.ic_attachment_audio
-        AttachmentType.FILE -> UiR.drawable.ic_attachment_file
-        AttachmentType.LINK -> UiR.drawable.ic_attachment_link
-        AttachmentType.AUDIO_MESSAGE -> UiR.drawable.ic_attachment_voice
-        AttachmentType.MINI_APP -> UiR.drawable.ic_attachment_mini_app
-        AttachmentType.STICKER -> UiR.drawable.ic_attachment_sticker
-        AttachmentType.GIFT -> UiR.drawable.ic_attachment_gift
-        AttachmentType.WALL -> UiR.drawable.ic_attachment_wall
-        AttachmentType.GRAFFITI -> UiR.drawable.ic_attachment_graffiti
-        AttachmentType.POLL -> UiR.drawable.ic_attachment_poll
-        AttachmentType.WALL_REPLY -> UiR.drawable.ic_attachment_wall_reply
-        AttachmentType.CALL -> UiR.drawable.ic_attachment_call
-        AttachmentType.GROUP_CALL_IN_PROGRESS -> UiR.drawable.ic_attachment_group_call
-        AttachmentType.STORY -> UiR.drawable.ic_attachment_story
+        AttachmentType.PHOTO -> R.drawable.ic_image_fill_round_24
+        AttachmentType.VIDEO -> R.drawable.ic_video_fill_round_24
+        AttachmentType.AUDIO -> R.drawable.ic_music_note_round_24
+        AttachmentType.FILE -> R.drawable.ic_draft_fill_round_24
+        AttachmentType.LINK -> R.drawable.ic_language_round_24
+        AttachmentType.AUDIO_MESSAGE -> R.drawable.ic_mic_fill_round_24
+        AttachmentType.MINI_APP -> R.drawable.ic_widgets_fill_round_24
+        AttachmentType.STICKER -> R.drawable.ic_sticker_fill_round_24
+        AttachmentType.GIFT -> R.drawable.ic_attachment_gift_old
+        AttachmentType.WALL -> R.drawable.ic_brick_fill_round_24
+        AttachmentType.GRAFFITI -> R.drawable.ic_fragrance_fill_round_24
+        AttachmentType.POLL -> R.drawable.ic_insert_chart_fill_round_24
+        AttachmentType.WALL_REPLY -> R.drawable.ic_comment_fill_round_24
+        AttachmentType.CALL -> R.drawable.ic_call_round_24
+        AttachmentType.GROUP_CALL_IN_PROGRESS -> R.drawable.ic_perm_phone_msg_fill_round_24
+        AttachmentType.STORY -> R.drawable.ic_history_toggle_off_round_24
         AttachmentType.UNKNOWN -> null
         AttachmentType.CURATOR -> null
         AttachmentType.EVENT -> null
@@ -624,7 +596,7 @@ private fun getAttachmentIconByType(attachmentType: AttachmentType): UiImage? {
         AttachmentType.NARRATIVE -> null
         AttachmentType.ARTICLE -> null
         AttachmentType.VIDEO_MESSAGE -> null
-        AttachmentType.GROUP_CHAT_STICKER -> UiR.drawable.ic_attachment_sticker
+        AttachmentType.GROUP_CHAT_STICKER -> R.drawable.ic_sticker_fill_round_24
         AttachmentType.STICKER_PACK_PREVIEW -> null
     }?.let(UiImage::Resource)
 }
@@ -642,7 +614,7 @@ private fun isAttachmentsHaveOneType(attachments: List<VkAttachment>): Boolean {
     return true
 }
 
-private fun extractForwardsText(
+fun extractForwardsText(
     resources: Resources,
     lastMessage: VkMessage?
 ): AnnotatedString? = when {
@@ -653,8 +625,8 @@ private fun extractForwardsText(
         withStyle(style = SpanStyle(fontWeight = FontWeight.SemiBold)) {
             append(
                 UiText.Resource(
-                    if (forwards.size == 1) UiR.string.forwarded_message
-                    else UiR.string.forwarded_messages
+                    if (forwards.size == 1) R.string.forwarded_message
+                    else R.string.forwarded_messages
                 ).parseString(resources)
             )
         }
@@ -663,84 +635,22 @@ private fun extractForwardsText(
     else -> null
 }
 
-fun extractTextWithVisualizedMentions(
-    isOut: Boolean,
-    originalText: String
-): AnnotatedString = buildAnnotatedString {
-    val regex = """\[(id|club)(\d+)\|([^]]+)]""".toRegex()
-
-    val mentions = mutableListOf<MentionIndex>()
-
-    var currentIndex = 0
-    val replacements = mutableListOf<Pair<IntRange, String>>()
-
-    val result = regex.replace(originalText) { matchResult ->
-        val idPrefix = matchResult.groups[1]?.value.orEmpty()
-        val startIndex = matchResult.range.first
-        val endIndex = matchResult.range.last
-
-        val id = matchResult.groups[2]?.value ?: ""
-
-        val replaced = matchResult.groups[3]?.value.orEmpty()
-
-        val indexRange =
-            (startIndex + currentIndex)..startIndex + currentIndex + replaced.length
-
-        replacements.add(indexRange to replaced)
-
-        mentions += MentionIndex(
-            id = id.toLongOrNull() ?: -1,
-            idPrefix = idPrefix,
-            indexRange = indexRange
-        )
-
-        currentIndex += replaced.length - (endIndex - startIndex + 1)
-
-        replaced
-    }
-
-    append(result)
-
-    mentions.forEach { mention ->
-        val startIndex = mention.indexRange.first
-        val endIndex = mention.indexRange.last
-
-        addStyle(
-            style = SpanStyle(color = Color.Red),
-            start = startIndex,
-            end = endIndex
-        )
-        addStringAnnotation(
-            tag = mention.idPrefix,
-            annotation = mention.id.toString(),
-            start = startIndex,
-            end = endIndex
-        )
-    }
-}
-
-data class MentionIndex(
-    val id: Long,
-    val idPrefix: String,
-    val indexRange: IntRange
-)
-
-private fun getAttachmentUiText(
+fun getAttachmentUiText(
     attachment: VkAttachment,
     size: Int = 1,
 ): UiText {
     if (attachment.type == AttachmentType.VIDEO &&
         (attachment as? VkVideoDomain)?.isShortVideo == true
     ) {
-        return UiText.Resource(UiR.string.message_attachments_clip)
+        return UiText.Resource(R.string.message_attachments_clip)
     }
 
     if (attachment.type.isMultiple()) {
         return when (attachment.type) {
-            AttachmentType.PHOTO -> UiR.plurals.attachment_photos
-            AttachmentType.VIDEO -> UiR.plurals.attachment_videos
-            AttachmentType.AUDIO -> UiR.plurals.attachment_audios
-            AttachmentType.FILE -> UiR.plurals.attachment_files
+            AttachmentType.PHOTO -> R.plurals.attachment_photos
+            AttachmentType.VIDEO -> R.plurals.attachment_videos
+            AttachmentType.AUDIO -> R.plurals.attachment_audios
+            AttachmentType.FILE -> R.plurals.attachment_files
             else -> throw IllegalArgumentException("Unknown multiple type: ${attachment.type}")
         }.let { resId -> UiText.QuantityResource(resId, size) }
     }
@@ -754,48 +664,34 @@ private fun getAttachmentUiText(
             throw IllegalArgumentException("Unknown multiple type: ${attachment.type}")
         }
 
-        AttachmentType.LINK -> UiR.string.message_attachments_link
-        AttachmentType.AUDIO_MESSAGE -> UiR.string.message_attachments_audio_message
-        AttachmentType.MINI_APP -> UiR.string.message_attachments_mini_app
-        AttachmentType.STICKER -> UiR.string.message_attachments_sticker
-        AttachmentType.GIFT -> UiR.string.message_attachments_gift
-        AttachmentType.WALL -> UiR.string.message_attachments_wall
-        AttachmentType.GRAFFITI -> UiR.string.message_attachments_graffiti
-        AttachmentType.POLL -> UiR.string.message_attachments_poll
-        AttachmentType.WALL_REPLY -> UiR.string.message_attachments_wall_reply
-        AttachmentType.CALL -> UiR.string.message_attachments_call
-        AttachmentType.GROUP_CALL_IN_PROGRESS -> UiR.string.message_attachments_call_in_progress
-        AttachmentType.CURATOR -> UiR.string.message_attachments_curator
-        AttachmentType.EVENT -> UiR.string.message_attachments_event
-        AttachmentType.STORY -> UiR.string.message_attachments_story
-        AttachmentType.WIDGET -> UiR.string.message_attachments_widget
-        AttachmentType.ARTIST -> UiR.string.message_attachments_artist
-        AttachmentType.AUDIO_PLAYLIST -> UiR.string.message_attachments_audio_playlist
-        AttachmentType.PODCAST -> UiR.string.message_attachments_podcast
-        AttachmentType.NARRATIVE -> UiR.string.message_attachments_narrative
-        AttachmentType.ARTICLE -> UiR.string.message_attachments_article
-        AttachmentType.VIDEO_MESSAGE -> UiR.string.message_attachments_video_message
-        AttachmentType.GROUP_CHAT_STICKER -> UiR.string.message_attachments_group_sticker
-        AttachmentType.STICKER_PACK_PREVIEW -> UiR.string.message_attachments_sticker_pack_preview
+        AttachmentType.LINK -> R.string.message_attachments_link
+        AttachmentType.AUDIO_MESSAGE -> R.string.message_attachments_audio_message
+        AttachmentType.MINI_APP -> R.string.message_attachments_mini_app
+        AttachmentType.STICKER -> R.string.message_attachments_sticker
+        AttachmentType.GIFT -> R.string.message_attachments_gift
+        AttachmentType.WALL -> R.string.message_attachments_wall
+        AttachmentType.GRAFFITI -> R.string.message_attachments_graffiti
+        AttachmentType.POLL -> R.string.message_attachments_poll
+        AttachmentType.WALL_REPLY -> R.string.message_attachments_wall_reply
+        AttachmentType.CALL -> R.string.message_attachments_call
+        AttachmentType.GROUP_CALL_IN_PROGRESS -> R.string.message_attachments_call_in_progress
+        AttachmentType.CURATOR -> R.string.message_attachments_curator
+        AttachmentType.EVENT -> R.string.message_attachments_event
+        AttachmentType.STORY -> R.string.message_attachments_story
+        AttachmentType.WIDGET -> R.string.message_attachments_widget
+        AttachmentType.ARTIST -> R.string.message_attachments_artist
+        AttachmentType.AUDIO_PLAYLIST -> R.string.message_attachments_audio_playlist
+        AttachmentType.PODCAST -> R.string.message_attachments_podcast
+        AttachmentType.NARRATIVE -> R.string.message_attachments_narrative
+        AttachmentType.ARTICLE -> R.string.message_attachments_article
+        AttachmentType.VIDEO_MESSAGE -> R.string.message_attachments_video_message
+        AttachmentType.GROUP_CHAT_STICKER -> R.string.message_attachments_group_sticker
+        AttachmentType.STICKER_PACK_PREVIEW -> R.string.message_attachments_sticker_pack_preview
     }.let(UiText::Resource)
 }
 
-private fun getAttachmentConversationIcon(message: VkMessage?): UiImage? {
-    return message?.attachments?.let { attachments ->
-        if (attachments.isEmpty()) return null
-        if (attachments.size == 1 || isAttachmentsHaveOneType(attachments)) {
-            message.geoType?.let {
-                return UiImage.Resource(UiR.drawable.ic_map_marker)
-            }
-            getAttachmentIconByType(attachments.first().type)
-        } else {
-            UiImage.Resource(UiR.drawable.ic_baseline_attach_file_24)
-        }
-    }
-}
-
-private fun extractBirthday(conversation: VkConversation): Boolean {
-    val birthday = conversation.user?.birthday ?: return false
+fun extractBirthday(convo: VkConvo): Boolean {
+    val birthday = convo.user?.birthday ?: return false
     val splitBirthday = birthday.split(".").mapNotNull(String::toIntOrNull)
 
     if (splitBirthday.isEmpty()) return false
@@ -815,37 +711,35 @@ private fun extractBirthday(conversation: VkConversation): Boolean {
     } else false
 }
 
-private fun extractReadCondition(
-    conversation: VkConversation,
+fun extractReadCondition(
+    convo: VkConvo,
     lastMessage: VkMessage?
-): Boolean = !conversation.isRead(lastMessage)
+): Boolean = !convo.isRead(lastMessage)
 
-private fun isAccount(peerId: Long) = peerId == UserConfig.userId
-
-private fun extractInteractionText(
+fun extractInteractionText(
     resources: Resources,
-    conversation: VkConversation
+    convo: VkConvo
 ): String? {
-    val interactionType = InteractionType.parse(conversation.interactionType)
-    val interactiveUsers = extractInteractionUsers(conversation)
+    val interactionType = InteractionType.parse(convo.interactionType)
+    val interactiveUsers = extractInteractionUsers(convo)
 
     val typingText =
         if (interactionType == null) {
             null
         } else {
-            if (!conversation.peerType.isChat() && interactiveUsers.size == 1) {
+            if (!convo.peerType.isChat() && interactiveUsers.size == 1) {
                 when (interactionType) {
-                    InteractionType.File -> UiR.string.chat_interaction_uploading_file
-                    InteractionType.Photo -> UiR.string.chat_interaction_uploading_photo
-                    InteractionType.Typing -> UiR.string.chat_interaction_typing
-                    InteractionType.Video -> UiR.string.chat_interaction_uploading_video
-                    InteractionType.VoiceMessage -> UiR.string.chat_interaction_recording_audio_message
+                    InteractionType.File -> R.string.chat_interaction_uploading_file
+                    InteractionType.Photo -> R.string.chat_interaction_uploading_photo
+                    InteractionType.Typing -> R.string.chat_interaction_typing
+                    InteractionType.Video -> R.string.chat_interaction_uploading_video
+                    InteractionType.VoiceMessage -> R.string.chat_interaction_recording_audio_message
                 }.let(UiText::Resource)
             } else {
                 if (interactiveUsers.size == 1) {
-                    UiR.string.chat_interaction_chat_single_typing
+                    R.string.chat_interaction_chat_single_typing
                 } else {
-                    UiR.string.chat_interaction_chat_typing
+                    R.string.chat_interaction_chat_typing
                 }.let { resId ->
                     UiText.ResourceParams(
                         resId,
@@ -858,8 +752,8 @@ private fun extractInteractionText(
     return typingText
 }
 
-private fun extractInteractionUsers(conversation: VkConversation): List<String> {
-    return conversation.interactionIds.mapNotNull { id ->
+fun extractInteractionUsers(convo: VkConvo): List<String> {
+    return convo.interactionIds.mapNotNull { id ->
         when {
             id > 0 -> VkMemoryCache.getUser(id)?.fullName
             id < 0 -> VkMemoryCache.getGroup(id)?.name

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

@@ -0,0 +1,49 @@
+package dev.meloda.fast.domain.util
+
+import android.content.res.Resources
+import dev.meloda.fast.common.util.TimeUtils
+import dev.meloda.fast.model.api.domain.VkConvo
+import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.model.vk.ActionState
+import dev.meloda.fast.ui.model.vk.ConvoOption
+import dev.meloda.fast.ui.model.vk.UiConvo
+import dev.meloda.fast.ui.util.ImmutableList
+import dev.meloda.fast.ui.util.emptyImmutableList
+
+fun VkConvo.asPresentation(
+    resources: Resources,
+    useContactName: Boolean,
+    isExpanded: Boolean = false,
+    options: ImmutableList<ConvoOption> = emptyImmutableList()
+): UiConvo = UiConvo(
+    id = id,
+    lastMessageId = lastMessageId,
+    avatar = extractAvatar(),
+    title = extractTitle(useContactName, resources),
+    unreadCount = extractUnreadCount(lastMessage, this),
+    date = TimeUtils.getLocalizedTime(
+        date = (lastMessage?.date ?: -1) * 1000L,
+        yearShort = { resources.getString(R.string.year_short) },
+        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),
+    attachmentImage = if (lastMessage?.text == null) null
+    else extractAttachmentIcon(lastMessage),
+    isPinned = majorId > 0,
+    actionImageId = ActionState.parse(isPhantom, isCallInProgress).getResourceId(),
+    isBirthday = extractBirthday(this),
+    isUnread = !isRead(),
+    isAccount = isAccount(id),
+    isOnline = !isAccount(id) && user?.onlineStatus?.isOnline() == true,
+    lastMessage = lastMessage,
+    peerType = peerType,
+    interactionText = extractInteractionText(resources, this),
+    isExpanded = isExpanded,
+    isArchived = isArchived,
+    options = options
+)

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

@@ -3,7 +3,7 @@ package dev.meloda.fast.domain.util
 import dev.meloda.fast.common.model.UiImage
 import dev.meloda.fast.data.VkMemoryCache
 import dev.meloda.fast.model.api.domain.VkUser
-import dev.meloda.fast.ui.model.api.UiFriend
+import dev.meloda.fast.ui.model.vk.UiFriend
 
 fun VkUser.asPresentation(
     useContactNames: Boolean = false

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

@@ -1,34 +1,20 @@
-package dev.meloda.fast.messageshistory.util
+package dev.meloda.fast.domain.util
 
 import android.content.res.Resources
-import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.text.AnnotatedString
-import androidx.compose.ui.text.AnnotatedString.Annotation
 import androidx.compose.ui.text.SpanStyle
-import androidx.compose.ui.text.StringAnnotation
 import androidx.compose.ui.text.buildAnnotatedString
-import androidx.compose.ui.text.font.FontStyle
 import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextDecoration
 import dev.meloda.fast.common.extensions.orDots
 import dev.meloda.fast.common.model.UiImage
 import dev.meloda.fast.common.model.UiText
 import dev.meloda.fast.common.model.parseString
-import dev.meloda.fast.common.provider.ResourceProvider
 import dev.meloda.fast.data.UserConfig
-import dev.meloda.fast.data.VkMemoryCache
-import dev.meloda.fast.messageshistory.model.SendingStatus
-import dev.meloda.fast.messageshistory.model.UiItem
-import dev.meloda.fast.model.api.PeerType
-import dev.meloda.fast.model.api.domain.FormatDataType
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.PeerType.Companion.getPeerType
 import dev.meloda.fast.model.api.domain.VkMessage
 import dev.meloda.fast.ui.R
 import java.text.SimpleDateFormat
 import java.util.Locale
-import dev.meloda.fast.ui.R as UiR
-
-private fun isAccount(fromId: Long) = fromId == UserConfig.userId
 
 fun VkMessage.extractAvatar() = when {
     isUser() -> {
@@ -41,7 +27,7 @@ fun VkMessage.extractAvatar() = when {
     }
 
     else -> null
-}?.let(UiImage::Url) ?: UiImage.Resource(UiR.drawable.ic_account_circle_cut)
+}?.let(UiImage::Url) ?: UiImage.Resource(R.drawable.ic_account_circle_fill_round_24)
 
 fun VkMessage.extractDate(): String =
     SimpleDateFormat("HH:mm", Locale.getDefault()).format(date * 1000L)
@@ -57,97 +43,17 @@ fun VkMessage.extractTitle(): String = when {
     else -> throw IllegalStateException("Message is not from user nor group. fromId: $fromId")
 }
 
-fun VkConversation.extractAvatar(): UiImage = when (peerType) {
-    PeerType.USER -> {
-        if (isAccount(id)) null
-        else user?.photo200
-    }
+fun VkMessage.extractReplyTitle(): String? = replyMessage?.extractTitle()
 
-    PeerType.GROUP -> {
-        group?.photo200
-    }
-
-    PeerType.CHAT -> {
-        photo200
-    }
-}?.let(UiImage::Url) ?: UiImage.Resource(R.drawable.ic_account_circle_cut)
-
-fun VkConversation.extractTitle(
-    useContactName: Boolean,
-    resources: Resources
-) = when (peerType) {
-    PeerType.USER -> {
-        if (isAccount(id)) {
-            UiText.Resource(UiR.string.favorites)
-        } else {
-            val userName = user?.let { user ->
-                if (useContactName) {
-                    VkMemoryCache.getContact(user.id)?.name
-                } else {
-                    user.fullName
-                }
-            }
-
-            UiText.Simple(userName.orDots())
-        }
-    }
-
-    PeerType.GROUP -> UiText.Simple(group?.name.orDots())
-    PeerType.CHAT -> UiText.Simple(title.orDots())
-}.parseString(resources).orDots()
-
-fun VkMessage.asPresentation(
-    conversation: VkConversation,
-    resourceProvider: ResourceProvider,
-    showName: Boolean,
-    prevMessage: VkMessage?,
-    nextMessage: VkMessage?,
-    showTimeInActionMessages: Boolean,
-    isSelected: Boolean
-): UiItem = when {
-    action != null -> UiItem.ActionMessage(
-        id = id,
-        cmId = cmId,
-        text = extractActionText(
-            resources = resourceProvider.resources,
-            youPrefix = resourceProvider.getString(R.string.you_message_prefix),
-            showTime = showTimeInActionMessages
-        ) ?: buildAnnotatedString { },
-        actionCmId = actionConversationMessageId
+fun VkMessage.extractReplySummary(resources: Resources): AnnotatedString? =
+    extractMessage(
+        resources = resources,
+        lastMessage = this,
+        peerId = peerId,
+        peerType = getPeerType(),
+        showPeer = false
     )
 
-    else -> UiItem.Message(
-        id = id,
-        cmId = cmId,
-        text = extractTextWithVisualizedMentions(
-            isOut = isOut,
-            originalText = text,
-            formatData = formatData
-        ),
-        isOut = isOut,
-        fromId = fromId,
-        date = extractDate(),
-        randomId = randomId,
-        isInChat = isPeerChat(),
-        name = extractTitle(),
-        showDate = true,
-        showAvatar = extractShowAvatar(nextMessage),
-        showName = showName && extractShowName(prevMessage),
-        avatar = extractAvatar(),
-        isEdited = updateTime != null,
-        isRead = isRead(conversation),
-        sendingStatus = when {
-            isFailed() -> SendingStatus.FAILED
-            id <= 0 -> SendingStatus.SENDING
-            else -> SendingStatus.SENT
-        },
-        isSelected = isSelected,
-        isPinned = isPinned,
-        isImportant = isImportant,
-        attachments = attachments?.ifEmpty { null }
-    )
-}
-
 fun VkMessage.extractShowAvatar(nextMessage: VkMessage?): Boolean {
     if (isOut) return false
     return nextMessage == null || nextMessage.fromId != fromId
@@ -198,7 +104,7 @@ fun VkMessage.extractActionText(
         when (action) {
             VkMessage.Action.CHAT_CREATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_created,
+                    R.string.message_action_chat_created,
                     listOf(prefix, text)
                 ).parseString(resources)
                     .orEmpty()
@@ -226,7 +132,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_TITLE_UPDATE -> {
                 val string = UiText.ResourceParams(
-                    UiR.string.message_action_chat_renamed,
+                    R.string.message_action_chat_renamed,
                     listOf(prefix, text)
                 ).parseString(resources)
                     .orEmpty()
@@ -254,7 +160,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_update,
+                    R.string.message_action_chat_photo_update,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -274,7 +180,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_PHOTO_REMOVE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_photo_remove,
+                    R.string.message_action_chat_photo_remove,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -295,7 +201,7 @@ fun VkMessage.extractActionText(
             VkMessage.Action.CHAT_KICK_USER -> {
                 if (memberId == fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_left,
+                        R.string.message_action_chat_user_left,
                         listOf(memberPrefix)
                     ).parseString(resources)
                         .orEmpty()
@@ -317,7 +223,7 @@ fun VkMessage.extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_kicked,
+                        R.string.message_action_chat_user_kicked,
                         listOf(prefix, postfix)
                     ).parseString(resources)
                         .orEmpty()
@@ -347,7 +253,7 @@ fun VkMessage.extractActionText(
             VkMessage.Action.CHAT_INVITE_USER -> {
                 if (memberId == lastMessage.fromId) {
                     UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_returned,
+                        R.string.message_action_chat_user_returned,
                         listOf(memberPrefix)
                     ).parseString(resources)
                         .orEmpty()
@@ -369,7 +275,7 @@ fun VkMessage.extractActionText(
                         else lastMessage.actionUser.toString()
 
                     val string = UiText.ResourceParams(
-                        UiR.string.message_action_chat_user_invited,
+                        R.string.message_action_chat_user_invited,
                         listOf(memberPrefix, postfix)
                     ).parseString(resources)
                         .orEmpty()
@@ -392,7 +298,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_link,
+                    R.string.message_action_chat_user_joined_by_link,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -412,7 +318,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call,
+                    R.string.message_action_chat_user_joined_by_call,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -432,7 +338,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_INVITE_USER_BY_CALL_LINK -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_user_joined_by_call_link,
+                    R.string.message_action_chat_user_joined_by_call_link,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -457,7 +363,7 @@ fun VkMessage.extractActionText(
 //                val hasMessageText = messageText.isNotEmpty()
 
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_pin_message,
+                    R.string.message_action_chat_pin_message,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -493,7 +399,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_UNPIN_MESSAGE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_unpin_message,
+                    R.string.message_action_chat_unpin_message,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -513,7 +419,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_SCREENSHOT -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_screenshot,
+                    R.string.message_action_chat_screenshot,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -533,7 +439,7 @@ fun VkMessage.extractActionText(
 
             VkMessage.Action.CHAT_STYLE_UPDATE -> {
                 UiText.ResourceParams(
-                    UiR.string.message_action_chat_style_update,
+                    R.string.message_action_chat_style_update,
                     listOf(prefix)
                 ).parseString(resources)
                     .orEmpty()
@@ -553,153 +459,3 @@ fun VkMessage.extractActionText(
         }
     }
 }
-
-// TODO: 04-Apr-25, Danil Nikolaev: get rid of method duplication
-fun extractTextWithVisualizedMentions(
-    isOut: Boolean,
-    originalText: String?,
-    formatData: VkMessage.FormatData?
-): AnnotatedString? {
-    if (originalText == null) return null
-
-    val annotations =
-        mutableListOf<AnnotatedString.Range<out Annotation>>()
-
-    val regex = """\[(id|club)(\d+)\|([^]]+)]""".toRegex()
-
-    val mentions = mutableListOf<MentionIndex>()
-
-    var currentIndex = 0
-    val replacements = mutableListOf<Pair<IntRange, String>>()
-
-    val newText = regex.replace(originalText) { matchResult ->
-        val idPrefix = matchResult.groups[1]?.value.orEmpty()
-        val startIndex = matchResult.range.first
-        val endIndex = matchResult.range.last
-
-        val id = matchResult.groups[2]?.value ?: ""
-
-        val replaced = matchResult.groups[3]?.value.orEmpty()
-
-        val indexRange =
-            (startIndex + currentIndex)..startIndex + currentIndex + replaced.length
-
-        replacements.add(indexRange to replaced)
-
-        mentions += MentionIndex(
-            id = id.toLongOrNull() ?: -1,
-            idPrefix = idPrefix,
-            indexRange = indexRange
-        )
-
-        currentIndex += replaced.length - (endIndex - startIndex + 1)
-
-        replaced
-    }
-
-    mentions.forEach { mention ->
-        val startIndex = mention.indexRange.first
-        val endIndex = mention.indexRange.last
-
-        annotations += if (isOut) {
-            AnnotatedString.Range(
-                item = SpanStyle(textDecoration = TextDecoration.Underline),
-                start = startIndex,
-                end = endIndex
-            )
-        } else {
-            AnnotatedString.Range(
-                item = SpanStyle(color = Color.Red),
-                start = startIndex,
-                end = endIndex
-            )
-        }
-
-        annotations += AnnotatedString.Range(
-            item = StringAnnotation(mention.id.toString()),
-            tag = mention.idPrefix,
-            start = startIndex,
-            end = endIndex
-        )
-    }
-
-    if (formatData == null) return AnnotatedString(text = newText, annotations = annotations)
-
-    var current = 0
-
-    val newOffsets = formatData.items.map { (offset, length) ->
-        val r = replacements.filter { (range, _) ->
-            (range - current) collidesWith (offset..<offset + length) || offset > range.first
-        }
-
-        current = r.sumOf { (range, _) -> range.last - range.first - 1 }
-
-        offset + current
-    }
-
-    formatData.items.forEachIndexed { index, item ->
-        val offset = newOffsets[index]
-
-        val spanStyle = when (item.type) {
-            FormatDataType.BOLD -> {
-                SpanStyle(fontWeight = FontWeight.SemiBold)
-            }
-
-            FormatDataType.ITALIC -> {
-                SpanStyle(fontStyle = FontStyle.Italic)
-            }
-
-            FormatDataType.UNDERLINE -> {
-                SpanStyle(textDecoration = TextDecoration.Underline)
-            }
-
-            FormatDataType.URL -> {
-                annotations += AnnotatedString.Range(
-                    item = StringAnnotation(item.url.orEmpty()),
-                    start = offset,
-                    end = offset + item.length,
-                    tag = newText.substring(offset, offset + item.length)
-                )
-
-                if (isOut) {
-                    SpanStyle(
-                        fontWeight = FontWeight.SemiBold,
-                        textDecoration = TextDecoration.Underline
-                    )
-
-                } else {
-                    SpanStyle(
-                        fontWeight = FontWeight.SemiBold,
-                        color = Color.Red
-                    )
-                }
-            }
-        }
-
-        annotations += AnnotatedString.Range(
-            item = spanStyle,
-            start = offset,
-            end = offset + item.length
-        )
-    }
-
-    return AnnotatedString(text = newText, annotations = annotations)
-}
-
-data class MentionIndex(
-    val id: Long,
-    val idPrefix: String,
-    val indexRange: IntRange
-)
-
-infix fun ClosedRange<Int>.collidesWith(other: ClosedRange<Int>): Boolean {
-    return this.start < other.endInclusive && other.start < this.endInclusive
-}
-
-operator fun ClosedRange<Int>.minus(other: ClosedRange<Int>): ClosedRange<Int> {
-    return (this.start - other.start)..(this.endInclusive - other.endInclusive)
-}
-
-operator fun ClosedRange<Int>.minus(other: Int): ClosedRange<Int> {
-    return (this.start - other)..(this.endInclusive - other)
-}

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

@@ -0,0 +1,65 @@
+package dev.meloda.fast.domain.util
+
+import androidx.compose.ui.text.buildAnnotatedString
+import dev.meloda.fast.common.provider.ResourceProvider
+import dev.meloda.fast.model.api.domain.VkConvo
+import dev.meloda.fast.model.api.domain.VkMessage
+import dev.meloda.fast.ui.R
+import dev.meloda.fast.ui.model.vk.MessageUiItem
+import dev.meloda.fast.ui.model.vk.SendingStatus
+import dev.meloda.fast.ui.util.ImmutableList.Companion.toImmutableList
+
+fun VkMessage.asPresentation(
+    convo: VkConvo,
+    resourceProvider: ResourceProvider,
+    showName: Boolean,
+    prevMessage: VkMessage?,
+    nextMessage: VkMessage?,
+    showTimeInActionMessages: Boolean,
+    isSelected: Boolean
+): MessageUiItem = when {
+    action != null -> MessageUiItem.ActionMessage(
+        id = id,
+        cmId = cmId,
+        text = extractActionText(
+            resources = resourceProvider.resources,
+            youPrefix = resourceProvider.getString(R.string.you_message_prefix),
+            showTime = showTimeInActionMessages
+        ) ?: buildAnnotatedString { },
+        actionCmId = actionCmId
+    )
+
+    else -> MessageUiItem.Message(
+        id = id,
+        cmId = cmId,
+        text = extractTextWithVisualizedMentions(
+            isOut = isOut,
+            originalText = text,
+            formatData = formatData
+        ),
+        isOut = isOut,
+        fromId = fromId,
+        date = extractDate(),
+        randomId = randomId,
+        isInChat = isPeerChat(),
+        name = extractTitle(),
+        showDate = true,
+        showAvatar = extractShowAvatar(nextMessage),
+        showName = showName && extractShowName(prevMessage),
+        avatar = extractAvatar(),
+        isEdited = updateTime != null,
+        isRead = isRead(convo),
+        sendingStatus = when {
+            isFailed() -> SendingStatus.FAILED
+            id <= 0 -> SendingStatus.SENDING
+            else -> SendingStatus.SENT
+        },
+        isSelected = isSelected,
+        isPinned = isPinned,
+        isImportant = isImportant,
+        attachments = attachments?.ifEmpty { null }?.toImmutableList(),
+        replyCmId = replyMessage?.cmId,
+        replyTitle = extractReplyTitle(),
+        replySummary = replyMessage?.extractReplySummary(resourceProvider.resources)
+    )
+}

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

@@ -0,0 +1,177 @@
+package dev.meloda.fast.domain.util
+
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.text.SpanStyle
+import androidx.compose.ui.text.StringAnnotation
+import androidx.compose.ui.text.font.FontStyle
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.text.style.TextDecoration
+import com.conena.nanokt.collections.indexOfFirstOrNull
+import dev.meloda.fast.common.extensions.collidesWith
+import dev.meloda.fast.common.extensions.minus
+import dev.meloda.fast.data.UserConfig
+import dev.meloda.fast.model.api.domain.FormatDataType
+import dev.meloda.fast.model.api.domain.VkMessage
+import dev.meloda.fast.ui.model.vk.MentionIndex
+import dev.meloda.fast.ui.model.vk.MessageUiItem
+
+fun emptyAnnotatedString(): AnnotatedString = AnnotatedString(text = "")
+
+fun AnnotatedString?.orEmpty(): AnnotatedString = this ?: emptyAnnotatedString()
+
+fun String.annotated(): AnnotatedString = AnnotatedString(text = this)
+
+fun isAccount(id: Long) = id == UserConfig.userId
+
+fun extractTextWithVisualizedMentions(
+    isOut: Boolean,
+    originalText: String?,
+    formatData: VkMessage.FormatData?
+): AnnotatedString? {
+    if (originalText == null) return null
+
+    val annotations =
+        mutableListOf<AnnotatedString.Range<out androidx.compose.ui.text.AnnotatedString.Annotation>>()
+
+    val regex = """\[(id|club)(\d+)\|([^]]+)]""".toRegex()
+
+    val mentions = mutableListOf<MentionIndex>()
+
+    var currentIndex = 0
+    val replacements = mutableListOf<Pair<IntRange, String>>()
+
+    val newText = regex.replace(originalText) { matchResult ->
+        val idPrefix = matchResult.groups[1]?.value.orEmpty()
+        val startIndex = matchResult.range.first
+        val endIndex = matchResult.range.last
+
+        val id = matchResult.groups[2]?.value ?: ""
+
+        val replaced = matchResult.groups[3]?.value.orEmpty()
+
+        val indexRange =
+            (startIndex + currentIndex)..startIndex + currentIndex + replaced.length
+
+        replacements.add(indexRange to replaced)
+
+        mentions += MentionIndex(
+            id = id.toLongOrNull() ?: -1,
+            idPrefix = idPrefix,
+            indexRange = indexRange
+        )
+
+        currentIndex += replaced.length - (endIndex - startIndex + 1)
+
+        replaced
+    }
+
+    mentions.forEach { mention ->
+        val startIndex = mention.indexRange.first
+        val endIndex = mention.indexRange.last
+
+        annotations += if (isOut) {
+            AnnotatedString.Range(
+                item = SpanStyle(textDecoration = TextDecoration.Underline),
+                start = startIndex,
+                end = endIndex
+            )
+        } else {
+            AnnotatedString.Range(
+                item = SpanStyle(color = Color.Red),
+                start = startIndex,
+                end = endIndex
+            )
+        }
+
+        annotations += AnnotatedString.Range(
+            item = StringAnnotation(mention.id.toString()),
+            tag = mention.idPrefix,
+            start = startIndex,
+            end = endIndex
+        )
+    }
+
+    if (formatData == null) {
+        return AnnotatedString(text = newText, annotations = annotations)
+    }
+
+    var current = 0
+
+    val newOffsets = formatData.items.map { (offset, length) ->
+        val r = replacements.filter { (range, _) ->
+            (range - current) collidesWith (offset..<offset + length) || offset > range.first
+        }
+
+        current = r.sumOf { (range, _) -> range.last - range.first - 1 }
+
+        offset + current
+    }
+
+    formatData.items.forEachIndexed { index, item ->
+        val offset = newOffsets[index]
+
+        val spanStyle = when (item.type) {
+            FormatDataType.BOLD -> {
+                SpanStyle(fontWeight = FontWeight.SemiBold)
+            }
+
+            FormatDataType.ITALIC -> {
+                SpanStyle(fontStyle = FontStyle.Italic)
+            }
+
+            FormatDataType.UNDERLINE -> {
+                SpanStyle(textDecoration = TextDecoration.Underline)
+            }
+
+            FormatDataType.URL -> {
+                annotations += AnnotatedString.Range(
+                    item = StringAnnotation(item.url.orEmpty()),
+                    start = offset,
+                    end = offset + item.length,
+                    tag = newText.substring(offset, offset + item.length)
+                )
+
+                if (isOut) {
+                    SpanStyle(
+                        fontWeight = FontWeight.SemiBold,
+                        textDecoration = TextDecoration.Underline
+                    )
+
+                } else {
+                    SpanStyle(
+                        fontWeight = FontWeight.SemiBold,
+                        color = Color.Red
+                    )
+                }
+            }
+        }
+
+        annotations += AnnotatedString.Range(
+            item = spanStyle,
+            start = offset,
+            end = offset + item.length
+        )
+    }
+
+    return AnnotatedString(text = newText, annotations = annotations)
+}
+
+
+fun List<MessageUiItem>.firstMessage(): MessageUiItem.Message =
+    filterIsInstance<MessageUiItem.Message>().first()
+
+fun List<MessageUiItem>.firstMessageOrNull(): MessageUiItem.Message? =
+    filterIsInstance<MessageUiItem.Message>().firstOrNull()
+
+fun List<MessageUiItem>.indexOfMessageById(messageId: Long): Int =
+    indexOfFirst { it.id == messageId }
+
+fun List<MessageUiItem>.findMessageById(messageId: Long): MessageUiItem.Message? =
+    firstOrNull { it.id == messageId } as MessageUiItem.Message?
+
+fun List<MessageUiItem>.indexOfMessageByCmId(cmId: Long): Int? =
+    indexOfFirstOrNull { it.cmId == cmId }
+
+fun List<MessageUiItem>.findMessageByCmId(cmId: Long): MessageUiItem.Message =
+    first { it.cmId == cmId } as MessageUiItem.Message

core/model/build.gradle.kts

@@ -4,7 +4,7 @@ plugins {
 }
 
 android {
-    namespace = "dev.meloda.fast.datastore"
+    namespace = "dev.meloda.fast.model"
 }
 
 dependencies {
@@ -12,7 +12,7 @@ dependencies {
     ksp(libs.moshi.kotlin.codegen)
 
     implementation(platform(libs.compose.bom))
-    implementation(libs.bundles.compose)
+    implementation(libs.compose.ui)
 
     implementation(libs.room.ktx)
     implementation(libs.room.runtime)

core/model/src/main/kotlin/dev/meloda/fast/model/ConvoFlags.kt

@@ -1,6 +1,6 @@
 package dev.meloda.fast.model
 
-enum class ConversationFlags(val value: Int) {
+enum class ConvoFlags(val value: Int) {
     DISABLE_PUSH(16),
     DISABLE_SOUND(32),
     INCOMING_CHAT_REQUEST(256),
@@ -17,10 +17,10 @@ enum class ConversationFlags(val value: Int) {
 
     companion object {
 
-        fun parse(mask: Int): List<ConversationFlags> {
-            val flags = mutableListOf<ConversationFlags>()
+        fun parse(mask: Int): List<ConvoFlags> {
+            val flags = mutableListOf<ConvoFlags>()
 
-            ConversationFlags.entries.forEach { flag ->
+            ConvoFlags.entries.forEach { flag ->
                 if (mask and flag.value > 0) {
                     flags.add(flag)
                 }

core/model/src/main/kotlin/dev/meloda/fast/model/ConvosFilter.kt

@@ -1,5 +1,5 @@
 package dev.meloda.fast.model
 
-enum class ConversationsFilter {
+enum class ConvosFilter {
     ALL, UNREAD, ARCHIVE, BUSINESS_NOTIFY
 }

core/model/src/main/kotlin/dev/meloda/fast/model/LongPollParsedEvent.kt

@@ -1,6 +1,6 @@
 package dev.meloda.fast.model
 
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 
 sealed interface LongPollParsedEvent {
@@ -92,7 +92,7 @@ sealed interface LongPollParsedEvent {
     ) : LongPollParsedEvent
 
     data class ChatArchived(
-        val conversation: VkConversation,
+        val convo: VkConvo,
         val archived: Boolean
     ) : LongPollParsedEvent
 }

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

@@ -1,5 +1,7 @@
 package dev.meloda.fast.model.api
 
+import dev.meloda.fast.model.api.domain.VkMessage
+
 enum class PeerType(val value: String) {
     USER("user"),
     GROUP("group"),
@@ -13,5 +15,14 @@ enum class PeerType(val value: String) {
         fun parse(type: String): PeerType {
             return entries.first { it.value == type }
         }
+
+        fun VkMessage.getPeerType(): PeerType {
+            return when {
+                peerId > 2_000_000_000 -> CHAT
+                peerId > 0 -> USER
+                peerId < 0 -> GROUP
+                else -> throw IllegalArgumentException("Unknown peer type for peerId: 0")
+            }
+        }
     }
 }

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/VkAttachmentHistoryMessageData.kt

@@ -8,7 +8,7 @@ import dev.meloda.fast.model.api.domain.VkAttachmentHistoryMessage
 data class VkAttachmentHistoryMessageData(
     @Json(name = "message_id") val messageId: Long,
     @Json(name = "date") val date: Int,
-    @Json(name = "cmid") val conversationMessageId: Long,
+    @Json(name = "cmid") val cmId: Long,
     @Json(name = "from_id") val fromId: Long,
     @Json(name = "position") val position: Int,
     @Json(name = "attachment") val attachment: VkAttachmentItemData
@@ -16,7 +16,7 @@ data class VkAttachmentHistoryMessageData(
 
     fun toDomain(): VkAttachmentHistoryMessage = VkAttachmentHistoryMessage(
         messageId = messageId,
-        conversationMessageId = conversationMessageId,
+        cmId = cmId,
         date = date,
         fromId = fromId,
         position = position,

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

@@ -3,19 +3,19 @@ package dev.meloda.fast.model.api.data
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
 import dev.meloda.fast.model.api.PeerType
-import dev.meloda.fast.model.api.domain.VkConversation
+import dev.meloda.fast.model.api.domain.VkConvo
 import dev.meloda.fast.model.api.domain.VkMessage
 
 @JsonClass(generateAdapter = true)
-data class VkConversationData(
+data class VkConvoData(
     @Json(name = "peer") val peer: Peer,
     @Json(name = "last_message_id") val lastMessageId: Long?,
     @Json(name = "in_read") val inRead: Long,
     @Json(name = "out_read") val outRead: Long,
-    @Json(name = "in_read_cmid") val inReadConversationMessageId: Long,
-    @Json(name = "out_read_cmid") val outReadConversationMessageId: Long,
+    @Json(name = "in_read_cmid") val inReadCmId: Long,
+    @Json(name = "out_read_cmid") val outReadCmId: Long,
     @Json(name = "sort_id") val sortId: SortId,
-    @Json(name = "last_conversation_message_id") val lastConversationMessageId: Long,
+    @Json(name = "last_conversation_message_id") val lastCmId: Long,
     @Json(name = "is_marked_unread") val isMarkedUnread: Boolean,
     @Json(name = "important") val important: Boolean,
     @Json(name = "push_settings") val pushSettings: PushSettings?,
@@ -111,7 +111,7 @@ data class VkConversationData(
 
     fun asDomain(
         lastMessage: VkMessage? = null,
-    ): VkConversation = VkConversation(
+    ): VkConvo = VkConvo(
         id = peer.id,
         localId = peer.localId,
         title = chatSettings?.title,
@@ -120,7 +120,7 @@ data class VkConversationData(
         photo200 = chatSettings?.photo?.photo200,
         isCallInProgress = callInProgress != null,
         isPhantom = chatSettings?.isDisappearing == true,
-        lastCmId = lastConversationMessageId,
+        lastCmId = lastCmId,
         inRead = inRead,
         outRead = outRead,
         lastMessageId = lastMessageId,
@@ -132,8 +132,8 @@ data class VkConversationData(
         canChangePin = chatSettings?.acl?.canChangePin == true,
         canChangeInfo = chatSettings?.acl?.canChangeInfo == true,
         pinnedMessageId = chatSettings?.pinnedMessage?.id,
-        inReadCmId = inReadConversationMessageId,
-        outReadCmId = outReadConversationMessageId,
+        inReadCmId = inReadCmId,
+        outReadCmId = outReadCmId,
         interactionType = -1,
         interactionIds = emptyList(),
         peerType = PeerType.parse(peer.type),

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

@@ -1,12 +1,13 @@
 package dev.meloda.fast.model.api.data
 
-import dev.meloda.fast.model.api.domain.VkGiftDomain
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
+import dev.meloda.fast.model.api.domain.VkGiftDomain
 
 @JsonClass(generateAdapter = true)
 data class VkGiftData(
     @Json(name = "id") val id: Long,
+    @Json(name = "thumb_512") val thumb512: String?,
     @Json(name = "thumb_256") val thumb256: String?,
     @Json(name = "thumb_96") val thumb96: String?,
     @Json(name = "thumb_48") val thumb48: String
@@ -14,6 +15,7 @@ data class VkGiftData(
 
     fun toDomain() = VkGiftDomain(
         id = id,
+        thumb512 = thumb512,
         thumb256 = thumb256,
         thumb96 = thumb96,
         thumb48 = thumb48

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

@@ -56,7 +56,7 @@ data class VkMessageData(
         @Json(name = "type") val type: String,
         @Json(name = "member_id") val memberId: Long?,
         @Json(name = "text") val text: String?,
-        @Json(name = "conversation_message_id") val conversationMessageId: Long?,
+        @Json(name = "conversation_message_id") val cmId: Long?,
         @Json(name = "message") val message: String?
     )
 
@@ -102,10 +102,10 @@ fun VkMessageData.asDomain(): VkMessage = VkMessage(
     action = VkMessage.Action.parse(action?.type),
     actionMemberId = action?.memberId,
     actionText = action?.text,
-    actionConversationMessageId = action?.conversationMessageId,
+    actionCmId = action?.cmId,
     actionMessage = action?.message,
     geoType = geo?.type,
-    isImportant = important ?: false,
+    isImportant = important == true,
     updateTime = updateTime,
     forwards = fwdMessages.orEmpty().map(VkMessageData::asDomain),
     attachments = attachments.map(VkAttachmentItemData::toDomain),

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

@@ -12,7 +12,7 @@ data class VkPinnedMessageData(
     @Json(name = "from_id") val fromId: Long,
     @Json(name = "out") val out: Boolean?,
     @Json(name = "text") val text: String,
-    @Json(name = "conversation_message_id") val conversationMessageId: Long,
+    @Json(name = "conversation_message_id") val cmId: Long,
     @Json(name = "fwd_messages") val forwards: List<VkMessageData>?,
     @Json(name = "important") val important: Boolean = false,
     @Json(name = "random_id") val randomId: Long = 0,
@@ -28,7 +28,7 @@ data class VkPinnedMessageData(
 
     fun mapToDomain(): VkMessage = VkMessage(
         id = id ?: -1,
-        cmId = conversationMessageId,
+        cmId = cmId,
         text = text.ifBlank { null },
         isOut = out == true,
         peerId = peerId ?: -1,
@@ -38,7 +38,7 @@ data class VkPinnedMessageData(
         action = VkMessage.Action.parse(action?.type),
         actionMemberId = action?.memberId,
         actionText = action?.text,
-        actionConversationMessageId = action?.conversationMessageId,
+        actionCmId = action?.cmId,
         actionMessage = action?.message,
         geoType = geo?.type,
         isImportant = important,

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

@@ -37,7 +37,7 @@ data class VkUserData(
 
     @JsonClass(generateAdapter = true)
     data class LastSeen(
-        @Json(name = "platform") val platform: Int,
+        @Json(name = "platform") val platform: Int?,
         @Json(name = "time") val time: Int
     )
 

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

@@ -54,9 +54,9 @@ data class VkVideoMessageData(
 
     @JsonClass(generateAdapter = true)
     data class Image(
-        val height: Int?,
-        val url: String?,
-        val width: Int?,
+        val height: Int,
+        val url: String,
+        val width: Int,
         val with_padding: Int?,
     )
 
@@ -73,6 +73,7 @@ data class VkVideoMessageData(
     )
 
     fun toDomain(): VkVideoMessageDomain = VkVideoMessageDomain(
-        id = id
+        id = id,
+        image = image.orEmpty().filter { it.width / it.height == 1 }.maxByOrNull { it.width }?.url
     )
 }

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/VkAttachmentHistoryMessage.kt

@@ -2,7 +2,7 @@ package dev.meloda.fast.model.api.domain
 
 data class VkAttachmentHistoryMessage(
     val messageId: Long,
-    val conversationMessageId: Long,
+    val cmId: Long,
     val date: Int,
     val fromId: Long,
     val position: Int,

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

@@ -1,9 +1,9 @@
 package dev.meloda.fast.model.api.domain
 
 import dev.meloda.fast.model.api.PeerType
-import dev.meloda.fast.model.database.VkConversationEntity
+import dev.meloda.fast.model.database.VkConvoEntity
 
-data class VkConversation(
+data class VkConvo(
     val id: Long,
     val localId: Long,
     val ownerId: Long?,
@@ -54,7 +54,7 @@ data class VkConversation(
     }
 
     companion object {
-        val EMPTY: VkConversation = VkConversation(
+        val EMPTY: VkConvo = VkConvo(
             id = -1,
             localId = -1,
             ownerId = null,
@@ -90,7 +90,7 @@ data class VkConversation(
     }
 }
 
-fun VkConversation.asEntity(): VkConversationEntity = VkConversationEntity(
+fun VkConvo.asEntity(): VkConvoEntity = VkConvoEntity(
     id = id,
     localId = localId,
     ownerId = ownerId,
@@ -99,7 +99,7 @@ fun VkConversation.asEntity(): VkConversationEntity = VkConversationEntity(
     photo100 = photo100,
     photo200 = photo200,
     isPhantom = isPhantom,
-    lastConversationMessageId = lastCmId,
+    lastCmId = lastCmId,
     inReadCmId = inReadCmId,
     outReadCmId = outReadCmId,
     inRead = inRead,