357 lines
14 KiB
Swift
357 lines
14 KiB
Swift
import Foundation
|
|
import SwiftUI
|
|
|
|
@Observable
|
|
final class ChatViewModel {
|
|
var messages: [Message] = []
|
|
var isLoading = false
|
|
var isSending = false
|
|
var errorMessage: String?
|
|
var searchQuery = ""
|
|
var searchResults: [String] = [] // message IDs matching search
|
|
var currentSearchIndex = 0
|
|
|
|
private var notificationTask: Task<Void, Never>?
|
|
|
|
func loadMessages(convId: String, chatClient: ChatClient) async {
|
|
let email = await chatClient.email
|
|
let cacheKey = await chatClient.cacheKey
|
|
|
|
// 1. Load from cache
|
|
let cachedDicts = MessageCache.load(email: email, convId: convId, cacheKey: cacheKey)
|
|
let cached = cachedDicts?.compactMap { Message.fromCacheDict($0) } ?? []
|
|
|
|
if !cached.isEmpty {
|
|
// Cache hit — show immediately, no spinner
|
|
messages = cached.sorted { $0.createdAt < $1.createdAt }
|
|
} else {
|
|
// No cache — show spinner (first open)
|
|
isLoading = true
|
|
}
|
|
|
|
// 2. Determine after_ts from newest cached message
|
|
let newestCached = messages.last
|
|
|
|
// 3. Fetch from server
|
|
let serverMessages: [Message]
|
|
if let newest = newestCached {
|
|
let afterTs = DateParsing.format(newest.createdAt)
|
|
#if DEBUG
|
|
print("DEBUG getMessages after_ts=\(afterTs)")
|
|
#endif
|
|
serverMessages = await chatClient.getMessages(convId: convId, limit: 50, afterTs: afterTs)
|
|
} else {
|
|
serverMessages = await chatClient.getMessages(convId: convId, limit: 50)
|
|
}
|
|
|
|
// 4. Merge
|
|
if newestCached != nil {
|
|
// Incremental: dedup by ID, append new, sort
|
|
let existingIds = Set(messages.map(\.id))
|
|
let newMessages = serverMessages.filter { !existingIds.contains($0.id) }
|
|
if !newMessages.isEmpty {
|
|
messages.append(contentsOf: newMessages)
|
|
messages.sort { $0.createdAt < $1.createdAt }
|
|
}
|
|
} else {
|
|
// Full fetch: replace
|
|
messages = serverMessages
|
|
}
|
|
|
|
// 5. Sync deleted (only for incremental)
|
|
if let newest = newestCached {
|
|
let afterTs = DateParsing.format(newest.createdAt)
|
|
#if DEBUG
|
|
print("DEBUG get_deleted_since since_ts=\(afterTs)")
|
|
#endif
|
|
let deletedIds = await chatClient.getDeletedSince(convId: convId, sinceTs: afterTs)
|
|
if !deletedIds.isEmpty {
|
|
messages.removeAll { deletedIds.contains($0.id) }
|
|
}
|
|
}
|
|
|
|
// 6. Loading done
|
|
isLoading = false
|
|
|
|
// 7. Save to cache
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
|
|
// 8. Mark entire conversation as read (server-side bulk mark)
|
|
// This handles messages not in cache (e.g. failed to decrypt or never fetched)
|
|
await chatClient.markConversationRead(convId: convId)
|
|
// Update local readBy for cached messages so cache reflects read state
|
|
let currentUserId = await chatClient.userId ?? ""
|
|
var anyUpdated = false
|
|
for i in messages.indices {
|
|
if !messages[i].isMine(currentUserId: currentUserId) && !messages[i].readBy.contains(currentUserId) {
|
|
messages[i].readBy.insert(currentUserId)
|
|
anyUpdated = true
|
|
}
|
|
}
|
|
if anyUpdated {
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
}
|
|
}
|
|
|
|
func loadOlderMessages(convId: String, chatClient: ChatClient) async {
|
|
let older = await chatClient.getMessages(convId: convId, limit: 50, offset: messages.count)
|
|
messages.insert(contentsOf: older, at: 0)
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
}
|
|
|
|
func sendMessage(convId: String, text: String, members: [ConversationMember],
|
|
chatClient: ChatClient, replyTo: String? = nil) async {
|
|
guard !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else { return }
|
|
|
|
isSending = true
|
|
errorMessage = nil
|
|
|
|
let (success, msg, sentMessage) = await chatClient.sendMessage(
|
|
convId: convId, text: text, members: members, replyTo: replyTo
|
|
)
|
|
|
|
isSending = false
|
|
|
|
if !success {
|
|
errorMessage = msg
|
|
} else if let sentMessage = sentMessage {
|
|
// Append locally — don't reload from server (ratchet keys are one-time)
|
|
if !messages.contains(where: { $0.id == sentMessage.id }) {
|
|
messages.append(sentMessage)
|
|
}
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
}
|
|
}
|
|
|
|
func deleteMessage(messageId: String, convId: String, chatClient: ChatClient) async {
|
|
let success = await chatClient.deleteMessage(messageId: messageId, convId: convId)
|
|
if success {
|
|
messages.removeAll { $0.id == messageId }
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
}
|
|
}
|
|
|
|
func saveCache(convId: String, chatClient: ChatClient) async {
|
|
let email = await chatClient.email
|
|
let cacheKey = await chatClient.cacheKey
|
|
let dicts = messages.map { $0.toCacheDict() }
|
|
try? MessageCache.save(email: email, convId: convId, messages: dicts, cacheKey: cacheKey)
|
|
}
|
|
|
|
func search(query: String) {
|
|
searchQuery = query
|
|
if query.isEmpty {
|
|
searchResults = []
|
|
currentSearchIndex = 0
|
|
return
|
|
}
|
|
let lower = query.lowercased()
|
|
searchResults = messages.filter { $0.text?.lowercased().contains(lower) == true }.map(\.id)
|
|
currentSearchIndex = searchResults.isEmpty ? 0 : searchResults.count - 1
|
|
}
|
|
|
|
func nextSearchResult() {
|
|
guard !searchResults.isEmpty else { return }
|
|
currentSearchIndex = (currentSearchIndex + 1) % searchResults.count
|
|
}
|
|
|
|
func prevSearchResult() {
|
|
guard !searchResults.isEmpty else { return }
|
|
currentSearchIndex = (currentSearchIndex - 1 + searchResults.count) % searchResults.count
|
|
}
|
|
|
|
func startNotificationListener(convId: String, chatClient: ChatClient) {
|
|
notificationTask?.cancel()
|
|
notificationTask = Task {
|
|
for await notification in await chatClient.makeNotificationStream() {
|
|
await handleNotification(notification, convId: convId, chatClient: chatClient)
|
|
}
|
|
}
|
|
}
|
|
|
|
@MainActor
|
|
private func handleNotification(_ notification: ChatNotification, convId: String, chatClient: ChatClient) {
|
|
switch notification {
|
|
case .newMessage(let data):
|
|
if data["conversation_id"] as? String == convId {
|
|
Task {
|
|
if let message = await chatClient.decryptNotification(data) {
|
|
await MainActor.run {
|
|
// Deduplicate — sent messages are already appended locally
|
|
if !messages.contains(where: { $0.id == message.id }) {
|
|
messages.append(message)
|
|
}
|
|
}
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
// Only mark as read if from someone else
|
|
let myId = await chatClient.userId ?? ""
|
|
if message.senderId != myId {
|
|
await chatClient.markRead(convId: convId, messageIds: [message.id])
|
|
}
|
|
await chatClient.flushSelfEncrypt()
|
|
}
|
|
}
|
|
}
|
|
case .messageDeleted(let data):
|
|
if let msgId = data["message_id"] as? String {
|
|
messages.removeAll { $0.id == msgId }
|
|
Task {
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
}
|
|
}
|
|
case .messagesRead(let data):
|
|
if let readUserId = data["user_id"] as? String,
|
|
let msgIds = data["message_ids"] as? [String] {
|
|
for i in messages.indices {
|
|
if msgIds.contains(messages[i].id) {
|
|
messages[i].readBy.insert(readUserId)
|
|
}
|
|
}
|
|
}
|
|
case .messageReacted(let data):
|
|
if let msgId = data["message_id"] as? String,
|
|
let reactUserId = data["user_id"] as? String,
|
|
let reaction = data["reaction"] as? String,
|
|
let action = data["action"] as? String,
|
|
let idx = messages.firstIndex(where: { $0.id == msgId }) {
|
|
if action == "add" {
|
|
let newReaction = MessageReaction(userId: reactUserId, reaction: reaction, createdAt: Date())
|
|
if !messages[idx].reactions.contains(where: { $0.userId == reactUserId && $0.reaction == reaction }) {
|
|
messages[idx].reactions.append(newReaction)
|
|
}
|
|
} else {
|
|
messages[idx].reactions.removeAll { $0.userId == reactUserId && $0.reaction == reaction }
|
|
}
|
|
Task { await saveCache(convId: convId, chatClient: chatClient) }
|
|
}
|
|
case .messagePinned(let data):
|
|
if let msgId = data["message_id"] as? String,
|
|
let pinUserId = data["user_id"] as? String,
|
|
let idx = messages.firstIndex(where: { $0.id == msgId }) {
|
|
messages[idx].pinnedAt = Date()
|
|
messages[idx].pinnedBy = pinUserId
|
|
Task { await saveCache(convId: convId, chatClient: chatClient) }
|
|
}
|
|
case .messageUnpinned(let data):
|
|
if let msgId = data["message_id"] as? String,
|
|
let idx = messages.firstIndex(where: { $0.id == msgId }) {
|
|
messages[idx].pinnedAt = nil
|
|
messages[idx].pinnedBy = nil
|
|
Task { await saveCache(convId: convId, chatClient: chatClient) }
|
|
}
|
|
case .messageDelivered(let data):
|
|
// Delivery receipt — message was successfully received by recipient
|
|
if let msgId = data["message_id"] as? String,
|
|
let idx = messages.firstIndex(where: { $0.id == msgId }) {
|
|
messages[idx].readBy.insert("__delivered__")
|
|
Task { await saveCache(convId: convId, chatClient: chatClient) }
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
func reactToMessage(messageId: String, convId: String, reaction: String,
|
|
currentUserId: String, chatClient: ChatClient) async {
|
|
guard let idx = messages.firstIndex(where: { $0.id == messageId }) else { return }
|
|
let existingReaction = messages[idx].reactions.first { $0.userId == currentUserId }
|
|
let hasSameReaction = existingReaction?.reaction == reaction
|
|
let savedReactions = messages[idx].reactions
|
|
|
|
// Optimistic update
|
|
if hasSameReaction {
|
|
// Tapping same emoji — remove it
|
|
messages[idx].reactions.removeAll { $0.userId == currentUserId }
|
|
} else {
|
|
// Remove any previous reaction from this user, then add new one
|
|
messages[idx].reactions.removeAll { $0.userId == currentUserId }
|
|
messages[idx].reactions.append(MessageReaction(userId: currentUserId, reaction: reaction, createdAt: Date()))
|
|
}
|
|
|
|
// If user had a different reaction, remove it on server first
|
|
if let old = existingReaction, old.reaction != reaction {
|
|
let _ = await chatClient.reactMessage(messageId: messageId, conversationId: convId,
|
|
reaction: old.reaction, action: "remove")
|
|
}
|
|
|
|
// Add or remove the target reaction on server
|
|
let action = hasSameReaction ? "remove" : "add"
|
|
let success = await chatClient.reactMessage(messageId: messageId, conversationId: convId,
|
|
reaction: reaction, action: action)
|
|
if !success {
|
|
// Revert on failure
|
|
messages[idx].reactions = savedReactions
|
|
}
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
}
|
|
|
|
func pinMessage(messageId: String, convId: String, pin: Bool,
|
|
chatClient: ChatClient) async {
|
|
guard let idx = messages.firstIndex(where: { $0.id == messageId }) else { return }
|
|
|
|
// Optimistic update
|
|
if pin {
|
|
messages[idx].pinnedAt = Date()
|
|
messages[idx].pinnedBy = await chatClient.userId
|
|
} else {
|
|
messages[idx].pinnedAt = nil
|
|
messages[idx].pinnedBy = nil
|
|
}
|
|
|
|
let success = await chatClient.pinMessage(messageId: messageId, conversationId: convId,
|
|
action: pin ? "pin" : "unpin")
|
|
if !success {
|
|
// Revert on failure
|
|
if pin {
|
|
messages[idx].pinnedAt = nil
|
|
messages[idx].pinnedBy = nil
|
|
}
|
|
}
|
|
await saveCache(convId: convId, chatClient: chatClient)
|
|
}
|
|
|
|
// MARK: - Forward Message
|
|
|
|
func forwardMessage(message: Message, targetConvId: String,
|
|
targetMembers: [ConversationMember], chatClient: ChatClient) async -> Bool {
|
|
var originalMsg: [String: Any] = [
|
|
"text": message.text ?? "",
|
|
"sender": message.senderUsername,
|
|
"conversation_id": message.conversationId,
|
|
"message_id": message.id,
|
|
]
|
|
if let file = message.file {
|
|
originalMsg["file"] = [
|
|
"file_id": file.fileId,
|
|
"aes_key": file.aesKey,
|
|
"iv": file.iv,
|
|
"filename": file.filename,
|
|
"size": file.size,
|
|
"mime_type": file.mimeType,
|
|
] as [String: Any]
|
|
}
|
|
if let image = message.image {
|
|
var imgDict: [String: Any] = [
|
|
"file_id": image.fileId,
|
|
"aes_key": image.aesKey,
|
|
"iv": image.iv,
|
|
"filename": image.filename,
|
|
"size": image.size,
|
|
]
|
|
if let thumb = image.thumbnail { imgDict["thumbnail"] = thumb }
|
|
originalMsg["image"] = imgDict
|
|
}
|
|
|
|
let (success, _, _) = await chatClient.forwardMessage(
|
|
targetConvId: targetConvId, originalMsg: originalMsg,
|
|
targetMembers: targetMembers
|
|
)
|
|
return success
|
|
}
|
|
|
|
func stop() {
|
|
notificationTask?.cancel()
|
|
notificationTask = nil
|
|
}
|
|
}
|