893 lines
36 KiB
Kotlin
893 lines
36 KiB
Kotlin
package chats.presentation.chat_detail
|
|
|
|
import androidx.lifecycle.ViewModel
|
|
import androidx.lifecycle.viewModelScope
|
|
import chats.data.remote.signalr.ChatEvent
|
|
import chats.data.remote.signalr.ChatHubClient
|
|
import chats.data.remote.signalr.ConnectionStatus
|
|
import chats.data.repository.toDomain
|
|
import chats.domain.model.Message
|
|
import chats.domain.repository.ChatRepository
|
|
import core.network.NetworkManager
|
|
import core.network.ServerConfig
|
|
import core.security.TokenManager
|
|
import dagger.hilt.android.lifecycle.HiltViewModel
|
|
import kotlinx.coroutines.Job
|
|
import kotlinx.coroutines.delay
|
|
import kotlinx.coroutines.flow.*
|
|
import kotlinx.coroutines.launch
|
|
import java.io.File
|
|
import javax.inject.Inject
|
|
import core.utils.copyUriToFile
|
|
import core.utils.ImageUtils
|
|
import chats.data.remote.api.KlipyGifDto
|
|
|
|
private const val TAG = "ChatDetailViewModel"
|
|
|
|
data class ChatDetailState(
|
|
val messages: List<Message> = emptyList(),
|
|
val chatName: String? = null,
|
|
val chatAvatar: String? = null,
|
|
val isLoading: Boolean = false,
|
|
val isLoadingMore: Boolean = false,
|
|
val isTyping: Boolean = false,
|
|
val typingUser: String? = null,
|
|
val error: String? = null,
|
|
val canCall: Boolean = true,
|
|
val maxFileSize: Long = 100 * 1024 * 1024,
|
|
val trendingGifs: List<KlipyGifDto> = emptyList(),
|
|
val searchedGifs: List<KlipyGifDto> = emptyList(),
|
|
val recentGifs: List<KlipyGifDto> = emptyList(),
|
|
val gifCategories: List<chats.data.remote.api.GifCategoryDto> = emptyList(),
|
|
val isGifsLoading: Boolean = false,
|
|
val initialScrollIndex: Int? = null,
|
|
val pendingAttachments: List<File> = emptyList(),
|
|
val isUploading: Boolean = false,
|
|
val isCompressionEnabled: Boolean = true,
|
|
val inputText: String = "",
|
|
val replyingMessage: Message? = null,
|
|
val editingMessage: Message? = null,
|
|
val forwardingMessages: List<Message> = emptyList(),
|
|
val availableChatsToForward: List<chats.domain.model.Chat> = emptyList(),
|
|
val selectedMessageIds: Set<String> = emptySet(),
|
|
val pinnedMessages: List<Message> = emptyList()
|
|
)
|
|
|
|
@HiltViewModel
|
|
class ChatDetailViewModel @Inject constructor(
|
|
private val repository: ChatRepository,
|
|
private val signalrClient: ChatHubClient,
|
|
private val serverConfig: ServerConfig,
|
|
private val tokenManager: TokenManager,
|
|
private val activeChatTracker: core.notifications.data.ActiveChatTracker,
|
|
private val signalrNotificationObserver: chats.data.remote.signalr.SignalRNotificationObserver,
|
|
private val networkManager: NetworkManager,
|
|
@dagger.hilt.android.qualifiers.ApplicationContext private val context: android.content.Context
|
|
) : ViewModel() {
|
|
|
|
private val _state = MutableStateFlow(ChatDetailState())
|
|
val state: StateFlow<ChatDetailState> = _state.asStateFlow()
|
|
|
|
private var currentChatId: String? = null
|
|
private var typingTimerJob: Job? = null
|
|
private var signalrEventsJob: Job? = null
|
|
private var lastTypingSentTime: Long = 0
|
|
|
|
private val prefs = context.getSharedPreferences("chat_settings", android.content.Context.MODE_PRIVATE)
|
|
|
|
init {
|
|
val config = serverConfig.getServerConfig()
|
|
val savedCompression = prefs.getBoolean("compression_enabled", true)
|
|
_state.update { it.copy(
|
|
canCall = config.features.calls,
|
|
maxFileSize = config.limits.maxFileSize,
|
|
isCompressionEnabled = savedCompression
|
|
) }
|
|
}
|
|
|
|
fun toggleCompression() {
|
|
_state.update { currentState ->
|
|
val newValue = !currentState.isCompressionEnabled
|
|
prefs.edit().putBoolean("compression_enabled", newValue).apply()
|
|
currentState.copy(isCompressionEnabled = newValue)
|
|
}
|
|
}
|
|
|
|
fun getCurrentUserId(): String {
|
|
return tokenManager.getUserId() ?: ""
|
|
}
|
|
|
|
fun setChatId(chatId: String) {
|
|
if (currentChatId == chatId) return
|
|
currentChatId = chatId
|
|
activeChatTracker.setChatId(chatId)
|
|
|
|
_state.update { it.copy(
|
|
messages = emptyList(),
|
|
isLoading = true,
|
|
initialScrollIndex = null
|
|
) }
|
|
|
|
// Ensure SignalR is connected and join the chat room
|
|
val token = tokenManager.getToken()
|
|
val baseUrl = serverConfig.getBaseUrl()
|
|
if (token != null && baseUrl.isNotBlank()) {
|
|
signalrClient.connect(baseUrl.removeSuffix("/api/"), token)
|
|
signalrClient.joinChat(chatId)
|
|
}
|
|
|
|
loadChatInfo(chatId)
|
|
observeSignalRStatus(chatId)
|
|
observeSignalREvents(chatId)
|
|
observeNetworkStatus(chatId)
|
|
|
|
// Initial sync from network
|
|
refreshMessages(chatId)
|
|
}
|
|
|
|
private fun observeNetworkStatus(chatId: String) {
|
|
// При восстановлении сети обновляем сообщения
|
|
networkManager.isOnline
|
|
.filter { it } // Только переход в онлайн
|
|
.distinctUntilChanged()
|
|
.onEach {
|
|
android.util.Log.d(TAG, "Network restored in chat detail, refreshing messages")
|
|
kotlinx.coroutines.delay(1000) // Дадим сети стабилизироваться
|
|
refreshMessages(chatId)
|
|
}
|
|
.launchIn(viewModelScope)
|
|
}
|
|
|
|
private fun observeSignalRStatus(chatId: String) {
|
|
// При переподключении SignalR обновляем сообщения
|
|
signalrClient.status
|
|
.filter { it == ConnectionStatus.CONNECTED }
|
|
.distinctUntilChanged()
|
|
.onEach {
|
|
android.util.Log.d(TAG, "SignalR connected, refreshing messages for chat $chatId")
|
|
refreshMessages(chatId)
|
|
}
|
|
.launchIn(viewModelScope)
|
|
}
|
|
|
|
private fun updateMessages(messages: List<Message>) {
|
|
val sortedMessages = messages.sortedByDescending { it.sequenceId }
|
|
_state.update { it.copy(
|
|
messages = sortedMessages,
|
|
isLoading = false,
|
|
initialScrollIndex = 0 // In reverse layout, 0 is the bottom
|
|
) }
|
|
}
|
|
|
|
fun onInitialScrollDone() {
|
|
_state.update { it.copy(initialScrollIndex = -1) }
|
|
}
|
|
|
|
fun refreshMessages(chatId: String) {
|
|
viewModelScope.launch {
|
|
try {
|
|
// Сначала пытаемся загрузить из сети
|
|
val messages = repository.getMessages(chatId)
|
|
if (messages.isNotEmpty()) {
|
|
updateMessages(messages)
|
|
return@launch
|
|
}
|
|
} catch (e: Exception) {
|
|
android.util.Log.d(TAG, "Network load failed, trying cache")
|
|
}
|
|
|
|
// Если сеть не доступна или пуста - загружаем из Room
|
|
try {
|
|
val cachedMessages = repository.getMessagesFlow(chatId).first()
|
|
android.util.Log.d(TAG, "Loaded ${cachedMessages.size} messages from cache")
|
|
updateMessages(cachedMessages)
|
|
} catch (e: Exception) {
|
|
android.util.Log.e(TAG, "Cache load failed", e)
|
|
_state.update { it.copy(isLoading = false, messages = emptyList()) }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun loadMoreMessages() {
|
|
val chatId = currentChatId ?: return
|
|
if (_state.value.isLoading || _state.value.isLoadingMore) return
|
|
|
|
val oldestMsg = _state.value.messages.lastOrNull() ?: return
|
|
|
|
viewModelScope.launch {
|
|
_state.update { it.copy(isLoadingMore = true) }
|
|
try {
|
|
android.util.Log.d("ChatDetailVM", "Loading more history before seqId: ${oldestMsg.sequenceId}")
|
|
val moreMessages = repository.getMessages(chatId, cursor = oldestMsg.sequenceId.toString())
|
|
if (moreMessages.isNotEmpty()) {
|
|
val newSorted = moreMessages.sortedByDescending { it.sequenceId }
|
|
_state.update { currentState ->
|
|
// Избегаем дубликатов
|
|
val existingIds = currentState.messages.map { it.id }.toSet()
|
|
val uniqueMore = newSorted.filter { it.id !in existingIds }
|
|
currentState.copy(messages = currentState.messages + uniqueMore)
|
|
}
|
|
}
|
|
} finally {
|
|
_state.update { it.copy(isLoadingMore = false) }
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun loadChatInfo(chatId: String) {
|
|
viewModelScope.launch {
|
|
// Пробуем загрузить из API
|
|
try {
|
|
val chats = repository.getChats()
|
|
val chat = chats.find { it.id == chatId }
|
|
chat?.let { c ->
|
|
_state.update { it.copy(chatName = c.name, chatAvatar = c.avatar) }
|
|
android.util.Log.d(TAG, "Loaded chat info from API: ${c.name}")
|
|
return@launch
|
|
}
|
|
} catch (e: Exception) {
|
|
android.util.Log.d(TAG, "API load failed, will use messages for title")
|
|
}
|
|
|
|
// Если API недоступно - берём имя из сообщений (для личных чатов)
|
|
try {
|
|
val cachedMessages = repository.getMessagesFlow(chatId).first()
|
|
val otherUserMessage = cachedMessages.firstOrNull { it.senderId != getCurrentUserId() }
|
|
otherUserMessage?.let { msg ->
|
|
_state.update { it.copy(chatName = msg.senderName, chatAvatar = msg.senderAvatar) }
|
|
android.util.Log.d(TAG, "Loaded chat title from messages: ${msg.senderName}")
|
|
}
|
|
} catch (e: Exception) {
|
|
android.util.Log.e(TAG, "Failed to load chat title from messages", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
private fun updateMessageReaction(messageId: String, userId: String, emoji: String) {
|
|
_state.update { s ->
|
|
val updatedMessages = s.messages.map { msg ->
|
|
if (msg.id == messageId) {
|
|
val currentReactions = msg.reactions.toMutableMap()
|
|
currentReactions[emoji] = (currentReactions[emoji] ?: 0) + 1
|
|
msg.copy(reactions = currentReactions)
|
|
} else msg
|
|
}
|
|
s.copy(messages = updatedMessages)
|
|
}
|
|
}
|
|
|
|
// For handling reaction removed event
|
|
private fun removeMessageReaction(messageId: String, userId: String, emoji: String) {
|
|
_state.update { s ->
|
|
val updatedMessages = s.messages.map { msg ->
|
|
if (msg.id == messageId) {
|
|
val currentReactions = msg.reactions.toMutableMap()
|
|
val count = currentReactions[emoji] ?: 0
|
|
if (count > 1) {
|
|
currentReactions[emoji] = count - 1
|
|
} else {
|
|
currentReactions.remove(emoji)
|
|
}
|
|
msg.copy(reactions = currentReactions)
|
|
} else msg
|
|
}
|
|
s.copy(messages = updatedMessages)
|
|
}
|
|
}
|
|
|
|
private fun observeSignalREvents(chatId: String) {
|
|
signalrEventsJob?.cancel()
|
|
signalrEventsJob = signalrClient.events
|
|
.onEach { android.util.Log.d("ChatDetailVM", "Received SignalR event: $it for chat: $chatId") }
|
|
.filter { event ->
|
|
val eventChatId = when(event) {
|
|
is ChatEvent.NewMessage -> event.message.chatId
|
|
is ChatEvent.ReactionUpdated -> event.chatId
|
|
is ChatEvent.UserTyping -> event.chatId
|
|
is ChatEvent.MessagesRead -> event.chatId
|
|
else -> null
|
|
}
|
|
|
|
if (eventChatId == null) return@filter false
|
|
|
|
val match = eventChatId == chatId || eventChatId.contains(chatId) || chatId.contains(eventChatId)
|
|
if (match) {
|
|
android.util.Log.d("ChatDetailVM", "Event MATCHED chat $chatId: $event")
|
|
}
|
|
match
|
|
}
|
|
.onEach { event ->
|
|
when (event) {
|
|
is ChatEvent.NewMessage -> {
|
|
android.util.Log.d("ChatDetailVM", "New message added to bottom, NOT marking as read automatically")
|
|
val baseUrl = serverConfig.getBaseUrl().removeSuffix("/api/")
|
|
val domainMsg = event.message.toDomain(getCurrentUserId(), baseUrl)
|
|
|
|
_state.update { currentState ->
|
|
if (currentState.messages.any { it.id == domainMsg.id }) return@update currentState
|
|
currentState.copy(messages = listOf(domainMsg) + currentState.messages)
|
|
}
|
|
}
|
|
is ChatEvent.ReactionUpdated -> {
|
|
if (event.isRemoved) {
|
|
removeMessageReaction(event.messageId, event.userId, event.emoji)
|
|
} else {
|
|
updateMessageReaction(event.messageId, event.userId, event.emoji)
|
|
}
|
|
}
|
|
is ChatEvent.MessageDeleted -> {
|
|
_state.update { currentState ->
|
|
currentState.copy(messages = currentState.messages.filter { it.id != event.messageId })
|
|
}
|
|
}
|
|
is ChatEvent.MessageEdited -> {
|
|
_state.update { currentState ->
|
|
val updated = currentState.messages.map { msg ->
|
|
if (msg.id == event.messageId) msg.copy(content = event.content) else msg
|
|
}
|
|
currentState.copy(messages = updated)
|
|
}
|
|
}
|
|
is ChatEvent.UserTyping -> {
|
|
// Игнорируем свои же typing события
|
|
if (event.userId == getCurrentUserId()) {
|
|
android.util.Log.d("ChatDetailVM", "Ignoring own typing event")
|
|
return@onEach
|
|
}
|
|
_state.update { it.copy(isTyping = true) }
|
|
typingTimerJob?.cancel()
|
|
typingTimerJob = viewModelScope.launch {
|
|
delay(3000)
|
|
_state.update { it.copy(isTyping = false) }
|
|
}
|
|
}
|
|
is ChatEvent.UserStoppedTyping -> {
|
|
// Игнорируем свои же события
|
|
if (event.userId == getCurrentUserId()) {
|
|
android.util.Log.d("ChatDetailVM", "Ignoring own stopped typing event")
|
|
return@onEach
|
|
}
|
|
_state.update { it.copy(isTyping = false) }
|
|
}
|
|
is ChatEvent.MessagesRead -> {
|
|
val currentUserId = getCurrentUserId()
|
|
_state.update { currentState ->
|
|
val updatedMessages = currentState.messages.map { msg ->
|
|
if (msg.sequenceId <= event.lastReadSequenceId) {
|
|
// Обновляем isRead на основе readBy
|
|
val isRead = if (msg.senderId == currentUserId) {
|
|
// Своё сообщение: прочитано, если кто-то кроме отправителя в readBy
|
|
event.userId != currentUserId
|
|
} else {
|
|
// Чужое сообщение: прочитано, если текущий пользователь в readBy
|
|
event.userId == currentUserId
|
|
}
|
|
msg.copy(isRead = isRead)
|
|
} else msg
|
|
}
|
|
currentState.copy(messages = updatedMessages)
|
|
}
|
|
}
|
|
is ChatEvent.MessagePinned -> {
|
|
val baseUrl = serverConfig.getBaseUrl().removeSuffix("/api/")
|
|
_state.update { s ->
|
|
val domainMsg = event.message.toDomain(getCurrentUserId(), baseUrl)
|
|
s.copy(pinnedMessages = (s.pinnedMessages + domainMsg).distinctBy { it.id })
|
|
}
|
|
}
|
|
is ChatEvent.MessageUnpinned -> {
|
|
_state.update { s ->
|
|
s.copy(pinnedMessages = s.pinnedMessages.filter { it.id != event.messageId })
|
|
}
|
|
}
|
|
else -> Unit
|
|
}
|
|
}
|
|
.launchIn(viewModelScope)
|
|
}
|
|
|
|
fun clearChatId() {
|
|
android.util.Log.d("ChatDetailVM", "KILLING ALL SESSION JOBS for $currentChatId")
|
|
signalrEventsJob?.cancel()
|
|
signalrEventsJob = null
|
|
currentChatId = null
|
|
activeChatTracker.setChatId(null)
|
|
_state.update { it.copy(messages = emptyList(), isLoading = false) }
|
|
}
|
|
|
|
fun markAsRead() {
|
|
val chatId = currentChatId ?: return
|
|
val messages = _state.value.messages
|
|
if (messages.isEmpty()) return
|
|
|
|
val currentUserId = getCurrentUserId()
|
|
|
|
// Находим последнее сообщение от собеседника
|
|
val lastMessageFromOther = messages.firstOrNull { it.senderId != currentUserId } ?: return
|
|
|
|
viewModelScope.launch {
|
|
try {
|
|
// Мгновенно обновляем в памяти для "галочек"
|
|
_state.update { currentState ->
|
|
val updatedMessages = currentState.messages.map { msg ->
|
|
// Для чужих сообщений помечаем как прочитанные, если sequenceId <= последнего сообщения от собеседника
|
|
if (msg.senderId != currentUserId && msg.sequenceId <= lastMessageFromOther.sequenceId) {
|
|
msg.copy(isRead = true)
|
|
} else msg
|
|
}
|
|
currentState.copy(messages = updatedMessages)
|
|
}
|
|
|
|
// Отправляем на сервер
|
|
repository.markMessagesAsRead(chatId, lastMessageFromOther.id, lastMessageFromOther.sequenceId)
|
|
|
|
// Обновляем через SignalR observer для получения актуальных данных
|
|
signalrNotificationObserver.refresh()
|
|
} catch (e: Exception) {
|
|
android.util.Log.e("ChatDetailVM", "markAsRead failed", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun onInputTextChanged(text: String) {
|
|
_state.update { it.copy(inputText = text) }
|
|
|
|
val chatId = currentChatId ?: return
|
|
|
|
// Отправляем индикатор набора текста
|
|
val now = System.currentTimeMillis()
|
|
if (now - lastTypingSentTime > 1000) {
|
|
signalrClient.sendTypingIndicator(chatId)
|
|
lastTypingSentTime = now
|
|
|
|
// Отправляем "остановился печатать" через 3 секунды
|
|
typingTimerJob?.cancel()
|
|
typingTimerJob = viewModelScope.launch {
|
|
delay(3000)
|
|
signalrClient.sendUserStoppedTyping(chatId)
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
fun onReply(message: Message) {
|
|
_state.update { it.copy(replyingMessage = message) }
|
|
}
|
|
|
|
fun forwardMessages(targetChatId: String, messages: List<Message>) {
|
|
viewModelScope.launch {
|
|
messages.forEach { msg ->
|
|
repository.sendMessage(
|
|
chatId = targetChatId,
|
|
content = msg.content,
|
|
type = msg.mediaType.name.lowercase(),
|
|
forwardedFromId = msg.senderId
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun onForward(message: Message) {
|
|
_state.update { it.copy(forwardingMessages = listOf(message)) }
|
|
loadChatsForForwarding()
|
|
}
|
|
|
|
fun loadChatsForForwarding() {
|
|
viewModelScope.launch {
|
|
try {
|
|
val chats = repository.getChats()
|
|
_state.update { it.copy(availableChatsToForward = chats) }
|
|
} catch (e: Exception) {
|
|
// Ignore
|
|
}
|
|
}
|
|
}
|
|
|
|
fun cancelForwarding() {
|
|
_state.update { it.copy(forwardingMessages = emptyList(), availableChatsToForward = emptyList()) }
|
|
}
|
|
|
|
fun onForwardSelectedMessages() {
|
|
val selectedIds = _state.value.selectedMessageIds
|
|
val messages = _state.value.messages.filter { selectedIds.contains(it.id) }
|
|
_state.update { it.copy(forwardingMessages = messages) }
|
|
loadChatsForForwarding()
|
|
}
|
|
|
|
fun toggleSelection(messageId: String) {
|
|
_state.update { s ->
|
|
val newSelection = if (s.selectedMessageIds.contains(messageId)) {
|
|
s.selectedMessageIds - messageId
|
|
} else {
|
|
s.selectedMessageIds + messageId
|
|
}
|
|
s.copy(selectedMessageIds = newSelection)
|
|
}
|
|
}
|
|
|
|
fun clearSelection() {
|
|
_state.update { it.copy(selectedMessageIds = emptySet()) }
|
|
}
|
|
|
|
fun cancelReply() {
|
|
_state.update { it.copy(replyingMessage = null) }
|
|
}
|
|
|
|
fun cancelEdit() {
|
|
_state.update { it.copy(editingMessage = null, inputText = "") }
|
|
}
|
|
|
|
fun deleteMessage(message: Message, forEveryone: Boolean) {
|
|
viewModelScope.launch {
|
|
try {
|
|
repository.deleteMessage(message.id, forEveryone)
|
|
// Local update if needed (will also come via SignalR for everyone, but forMe might need local only update)
|
|
_state.update { currentState ->
|
|
currentState.copy(messages = currentState.messages.filter { it.id != message.id })
|
|
}
|
|
} catch (e: Exception) {
|
|
_state.update { it.copy(error = "Delete failed: ${e.localizedMessage}") }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun onEdit(message: Message) {
|
|
_state.update { it.copy(editingMessage = message, inputText = message.content ?: "", replyingMessage = null) }
|
|
}
|
|
|
|
fun pinMessage(messageId: String) {
|
|
val chatId = currentChatId ?: return
|
|
signalrClient.pinMessage(messageId, chatId)
|
|
}
|
|
|
|
fun unpinMessage(messageId: String) {
|
|
val chatId = currentChatId ?: return
|
|
signalrClient.unpinMessage(messageId, chatId)
|
|
}
|
|
|
|
fun onPin(message: Message) {
|
|
pinMessage(message.id)
|
|
}
|
|
|
|
fun sendMessage(onFail: (String) -> Unit = {}) {
|
|
val chatId = currentChatId ?: return
|
|
val text = _state.value.inputText
|
|
val pending = _state.value.pendingAttachments
|
|
val replyToId = _state.value.replyingMessage?.id
|
|
val editingMsg = _state.value.editingMessage
|
|
if (text.isBlank() && pending.isEmpty()) return
|
|
|
|
// Handle Edit
|
|
if (editingMsg != null) {
|
|
_state.update { it.copy(inputText = "", editingMessage = null) }
|
|
viewModelScope.launch {
|
|
try {
|
|
val updated = repository.editMessage(editingMsg.id, text)
|
|
_state.update { currentState ->
|
|
val updatedList = currentState.messages.map {
|
|
if (it.id == updated.id) updated else it
|
|
}
|
|
currentState.copy(messages = updatedList)
|
|
}
|
|
} catch (e: Exception) {
|
|
_state.update { it.copy(error = "Edit failed: ${e.localizedMessage}") }
|
|
onFail(text)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// Clear input immediately to avoid double clicks and ensure UI experience
|
|
_state.update { it.copy(inputText = "", replyingMessage = null) }
|
|
|
|
val tempId = "temp_${System.currentTimeMillis()}"
|
|
val userId = getCurrentUserId()
|
|
|
|
// Determine mediaType based on attachments
|
|
val mediaType = when {
|
|
pending.isEmpty() -> chats.domain.model.MediaType.TEXT
|
|
pending.any { it.extension.lowercase() in listOf("jpg", "jpeg", "png", "webp", "gif") } -> chats.domain.model.MediaType.IMAGE
|
|
pending.any { it.extension.lowercase() in listOf("mp4", "mov", "webm") } -> chats.domain.model.MediaType.VIDEO
|
|
else -> chats.domain.model.MediaType.TEXT
|
|
}
|
|
|
|
val tempMessage = Message(
|
|
id = tempId,
|
|
chatId = chatId,
|
|
senderId = userId,
|
|
content = if (text.isBlank()) null else text,
|
|
createdAt = java.util.Date().toString(),
|
|
mediaType = mediaType,
|
|
media = emptyList(),
|
|
senderName = "Вы",
|
|
senderAvatar = null,
|
|
reactions = emptyMap(),
|
|
isRead = false,
|
|
sequenceId = 0
|
|
)
|
|
|
|
viewModelScope.launch {
|
|
repository.saveMessage(tempMessage)
|
|
}
|
|
|
|
viewModelScope.launch {
|
|
try {
|
|
// Upload attachments if any
|
|
val attachmentRequests = if (_state.value.pendingAttachments.isNotEmpty()) {
|
|
_state.update { it.copy(isUploading = true) }
|
|
val requests = _state.value.pendingAttachments.map { file ->
|
|
val url = repository.uploadMedia(file)
|
|
chats.data.remote.api.AttachmentRequest(
|
|
type = when {
|
|
file.extension.lowercase() in listOf("jpg", "jpeg", "png", "webp", "gif", "heic", "heif") -> "image"
|
|
file.extension.lowercase() in listOf("mp4", "mov", "3gp", "mkv", "webm") -> "video"
|
|
file.extension.lowercase() in listOf("mp3", "m4a", "wav", "aac", "ogg") -> "audio"
|
|
else -> "file"
|
|
},
|
|
url = url,
|
|
fileName = file.name,
|
|
fileSize = file.length()
|
|
)
|
|
}
|
|
_state.update { it.copy(isUploading = false, pendingAttachments = emptyList()) }
|
|
requests
|
|
} else {
|
|
null
|
|
}
|
|
|
|
val sentMessage = repository.sendMessage(
|
|
chatId = chatId,
|
|
content = if (text.isBlank()) null else text,
|
|
type = if (attachmentRequests != null) "media" else "text",
|
|
attachments = attachmentRequests,
|
|
replyToId = replyToId
|
|
)
|
|
repository.deleteLocalMessage(tempId)
|
|
repository.saveMessage(sentMessage)
|
|
// Clear attachments on success
|
|
_state.update { it.copy(pendingAttachments = emptyList()) }
|
|
} catch (e: Exception) {
|
|
repository.deleteLocalMessage(tempId)
|
|
_state.update { it.copy(error = e.localizedMessage, isUploading = false) }
|
|
onFail(text)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun addReaction(messageId: String, emoji: String) {
|
|
val chatId = currentChatId ?: return
|
|
|
|
// We rely on SignalR event to update the count to avoid double counting
|
|
// especially since domain Message doesn't track user IDs for reactions yet.
|
|
signalrClient.addReaction(messageId, chatId, emoji)
|
|
}
|
|
|
|
fun sendVoiceMessage(file: File) {
|
|
val chatId = currentChatId ?: return
|
|
val replyToId = _state.value.replyingMessage?.id
|
|
_state.update { it.copy(replyingMessage = null) }
|
|
|
|
val tempId = "temp_voice_${System.currentTimeMillis()}"
|
|
val userId = getCurrentUserId()
|
|
|
|
val tempMessage = Message(
|
|
id = tempId,
|
|
chatId = chatId,
|
|
senderId = userId,
|
|
content = null,
|
|
createdAt = java.util.Date().toString(),
|
|
mediaType = chats.domain.model.MediaType.AUDIO,
|
|
media = emptyList(),
|
|
senderName = "Вы",
|
|
reactions = emptyMap(),
|
|
isRead = false,
|
|
sequenceId = 0
|
|
)
|
|
|
|
viewModelScope.launch {
|
|
repository.saveMessage(tempMessage)
|
|
}
|
|
|
|
viewModelScope.launch {
|
|
try {
|
|
// 1. Upload the audio file
|
|
val url = repository.uploadMedia(file)
|
|
|
|
// 2. Send the message with the attachment
|
|
val attachment = chats.data.remote.api.AttachmentRequest(
|
|
type = "voice",
|
|
url = url,
|
|
fileName = file.name,
|
|
fileSize = file.length()
|
|
)
|
|
|
|
val sentMessage = repository.sendMessage(
|
|
chatId = chatId,
|
|
content = null,
|
|
type = "audio",
|
|
attachments = listOf(attachment),
|
|
replyToId = replyToId
|
|
)
|
|
|
|
repository.deleteLocalMessage(tempId)
|
|
repository.saveMessage(sentMessage)
|
|
} catch (e: Exception) {
|
|
repository.deleteLocalMessage(tempId)
|
|
_state.update { it.copy(error = "Ошибка отправки голосового: ${e.localizedMessage}") }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun addPendingAttachment(uri: android.net.Uri, context: android.content.Context) {
|
|
viewModelScope.launch {
|
|
val mimeType = context.contentResolver.getType(uri) ?: ""
|
|
val file = if (_state.value.isCompressionEnabled && mimeType.startsWith("image")) {
|
|
ImageUtils.compressImage(context, uri)
|
|
} else {
|
|
copyUriToFile(context, uri)
|
|
}
|
|
|
|
file?.let { f ->
|
|
_state.update { it.copy(pendingAttachments = it.pendingAttachments + f) }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun formatDateHeader(dateString: String): String {
|
|
return try {
|
|
// Парсим ISO 8601 (например 2024-04-14T20:56:00Z)
|
|
val isoFormat = java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", java.util.Locale.US).apply {
|
|
timeZone = java.util.TimeZone.getTimeZone("UTC")
|
|
}
|
|
val date = isoFormat.parse(dateString) ?: return dateString
|
|
|
|
// Форматируем в локальное время: "14 апреля"
|
|
java.text.SimpleDateFormat("d MMMM", java.util.Locale("ru")).format(date)
|
|
} catch (e: Exception) {
|
|
dateString
|
|
}
|
|
}
|
|
|
|
fun getLocalDateString(isoDate: String): String {
|
|
return try {
|
|
val isoFormat = java.text.SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss", java.util.Locale.US).apply {
|
|
timeZone = java.util.TimeZone.getTimeZone("UTC")
|
|
}
|
|
val date = isoFormat.parse(isoDate) ?: return isoDate
|
|
// Возвращаем просто дату YYYY-MM-DD в локальном часовом поясе для группировки
|
|
java.text.SimpleDateFormat("yyyy-MM-dd", java.util.Locale.getDefault()).format(date)
|
|
} catch (e: Exception) {
|
|
isoDate.split("T").first()
|
|
}
|
|
}
|
|
|
|
fun removePendingAttachment(file: File) {
|
|
_state.update { it.copy(pendingAttachments = it.pendingAttachments - file) }
|
|
}
|
|
|
|
fun uploadMedia(file: File) {
|
|
if (file.length() > _state.value.maxFileSize) {
|
|
_state.update { it.copy(error = "File too large") }
|
|
return
|
|
}
|
|
viewModelScope.launch {
|
|
try {
|
|
val url = repository.uploadMedia(file)
|
|
// After upload, we might want to send a message with this media
|
|
// For now, let's just log it or handle as per app requirements
|
|
} catch (e: Exception) {
|
|
_state.update { it.copy(error = e.localizedMessage) }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun loadTrendingGifs() {
|
|
if (_state.value.trendingGifs.isNotEmpty()) return
|
|
|
|
viewModelScope.launch {
|
|
_state.update { it.copy(isGifsLoading = true) }
|
|
try {
|
|
val gifs = repository.getTrendingGifs(0)
|
|
_state.update { it.copy(trendingGifs = gifs, isGifsLoading = false) }
|
|
} catch (e: Exception) {
|
|
_state.update { it.copy(isGifsLoading = false, error = "GIF load error: ${e.message}") }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun loadGifCategories() {
|
|
if (_state.value.gifCategories.isNotEmpty()) return
|
|
viewModelScope.launch {
|
|
try {
|
|
val categories = repository.getGifCategories()
|
|
_state.update { it.copy(gifCategories = categories) }
|
|
} catch (e: Exception) {
|
|
// Ignore failure
|
|
}
|
|
}
|
|
}
|
|
|
|
private var searchJob: Job? = null
|
|
fun searchGifs(query: String) {
|
|
searchJob?.cancel()
|
|
if (query.isBlank()) {
|
|
_state.update { it.copy(searchedGifs = emptyList()) }
|
|
return
|
|
}
|
|
searchJob = viewModelScope.launch {
|
|
delay(500)
|
|
_state.update { it.copy(isGifsLoading = true) }
|
|
try {
|
|
val gifs = repository.searchGifs(query, 0)
|
|
_state.update { it.copy(searchedGifs = gifs, isGifsLoading = false) }
|
|
} catch (e: Exception) {
|
|
_state.update { it.copy(isGifsLoading = false) }
|
|
}
|
|
}
|
|
}
|
|
|
|
fun sendGif(url: String) {
|
|
val chatId = currentChatId ?: return
|
|
val replyToId = _state.value.replyingMessage?.id
|
|
_state.update { it.copy(replyingMessage = null) }
|
|
|
|
val tempId = "temp_gif_${System.currentTimeMillis()}"
|
|
val userId = getCurrentUserId()
|
|
|
|
val tempMessage = Message(
|
|
id = tempId,
|
|
chatId = chatId,
|
|
senderId = userId,
|
|
content = url,
|
|
createdAt = java.util.Date().toString(),
|
|
mediaType = chats.domain.model.MediaType.IMAGE, // We map GIF to IMAGE for rendering
|
|
media = listOf(chats.domain.model.Media(url = url, type = "image", id = "temp_media")),
|
|
senderName = "Вы",
|
|
senderAvatar = null,
|
|
reactions = emptyMap(),
|
|
isRead = false,
|
|
sequenceId = 0
|
|
)
|
|
|
|
viewModelScope.launch {
|
|
repository.saveMessage(tempMessage)
|
|
}
|
|
|
|
viewModelScope.launch {
|
|
try {
|
|
val attachment = chats.data.remote.api.AttachmentRequest(
|
|
type = "image",
|
|
url = url,
|
|
fileName = "gif.gif",
|
|
fileSize = 0
|
|
)
|
|
val sentMessage = repository.sendMessage(chatId, null, "image", listOf(attachment), replyToId)
|
|
|
|
repository.deleteLocalMessage(tempId)
|
|
repository.saveMessage(sentMessage)
|
|
|
|
// Add to recent
|
|
val allGifs = _state.value.trendingGifs + _state.value.searchedGifs + _state.value.recentGifs
|
|
val selectedGif = allGifs.find { gif ->
|
|
val gifUrl = gif.files?.get("hd")?.get("gif")?.url
|
|
?: gif.files?.get("sd")?.get("gif")?.url
|
|
?: gif.file?.get("hd")?.get("gif")?.url
|
|
?: gif.file?.get("sd")?.get("gif")?.url
|
|
?: gif.media_formats?.get("gif")?.url
|
|
?: gif.images?.original?.url
|
|
gifUrl == url
|
|
}
|
|
|
|
selectedGif?.let { gif ->
|
|
val newList = (listOf(gif) + _state.value.recentGifs).distinctBy { it.id }.take(20)
|
|
_state.update { it.copy(recentGifs = newList) }
|
|
}
|
|
} catch (e: Exception) {
|
|
repository.deleteLocalMessage(tempId)
|
|
_state.update { it.copy(error = e.localizedMessage) }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|