another.im-ios/ConversationsClassic/AppData/Store/ConversationStore.swift

import AVFoundation
import Combine
import Foundation
import GRDB
import Photos

@MainActor
final class ConversationStore: ObservableObject {
    @Published private(set) var messages: [Message] = []
    @Published var replyText = ""

    private(set) var roster: Roster
    private let client: Client
    private let blockSize = Const.messagesPageSize
    private let messagesMax = Const.messagesMaxSize

    private var messagesCancellable: AnyCancellable?

    init(roster: Roster, client: Client) {
        self.client = client
        self.roster = roster
        subscribe()
    }
}

extension ConversationStore {
    func sendMessage(_ message: String) async {
        // prepare message
        let message = Message(
            id: UUID().uuidString,
            type: .chat,
            date: Date(),
            contentType: .text,
            status: .pending,
            from: roster.bareJid,
            to: roster.contactBareJid,
            body: message,
            subject: nil,
            thread: nil,
            oobUrl: nil
        )

        // store as pending on db, and send
        do {
            try await message.save()
            try await client.sendMessage(message)
            try await message.setStatus(.sent)
        } catch {
            try? await message.setStatus(.error)
        }
    }
}

extension ConversationStore {
    var attachmentsStore: AttachmentsStore {
        AttachmentsStore()
    }

    func sendMedia(_ items: [GalleryItem]) async {
        print("media!", items)
        // guard !ids.isEmpty else { return }
        // let items = galleryItems.filter { ids.contains($0.id) }
        // for item in items {
        //     await client.uploadMedia(item.url)
        // }
    }

    func sendCaptured(_ data: Data, _ type: GalleryMediaType) async {
        // save locally and make message
        let messageId = UUID().uuidString
        do {
            let (localName, msgType) = try await FileStore.shared.storeCaptured(messageId: messageId, data, type)
            let message = Message(
                id: UUID().uuidString,
                type: .chat,
                date: Date(),
                contentType: .attachment(
                    Attachment(
                        type: msgType,
                        localName: localName,
                        thumbnailName: nil,
                        remotePath: nil
                    )
                ),
                status: .pending,
                from: roster.bareJid,
                to: roster.contactBareJid,
                body: nil,
                subject: nil,
                thread: nil,
                oobUrl: nil
            )
            try await message.save()
        } catch {
            logIt(.error, "Can't save file for uploading: \(error)")
        }

        // upload and save
        upload(message: message)
    }

    func sendDocuments(_ data: [Data], _ extensions: [String]) async {
        // do {
        //     let newMessageId = UUID().uuidString
        //     let fileId = UUID().uuidString
        //     let localName = "\(newMessageId)_\(fileId).\(ext)"
        //     try await FileStore.shared.storeForUploading(data, localName)
        //
        // } catch {
        //     print("error", error)
        // }
        print("documents!", data, extensions)
        //
        //
        //
    }

    func sendContact(_ jidStr: String) async {
        await sendMessage("contact:\(jidStr)")
    }

    func sendLocation(_ lat: Double, _ lon: Double) async {
        await sendMessage("geo:\(lat),\(lon)")
    }

    private func upload(message: Message) async {
        let remotePath: String
        do {
            remotePath = try await client.uploadFile(localPath)
            message.contentType = .attachment(
                Attachment(
                    type: msgType,
                    localName: localName,
                    thumbnailName: nil,
                    remotePath: remotePath
                )
            )
            try await message.save()
        } catch {
            message.status = .error
            try? await message.save()
        }
    }
}

extension ConversationStore {
    var contacts: [Roster] {
        get async {
            do {
                let rosters = try await Database.shared.dbQueue.read { db in
                    try Roster
                        .filter(Column("locallyDeleted") == false)
                        .fetchAll(db)
                }
                return rosters
            } catch {
                return []
            }
        }
    }
}

private extension ConversationStore {
    func subscribe() {
        messagesCancellable = ValueObservation.tracking(Message
            .filter(
                (Column("to") == roster.bareJid && Column("from") == roster.contactBareJid) ||
                    (Column("from") == roster.bareJid && Column("to") == roster.contactBareJid)
            )
            .order(Column("date").desc)
            .fetchAll
        )
        .publisher(in: Database.shared.dbQueue, scheduling: .immediate)
        .receive(on: DispatchQueue.main)
        .sink { _ in
        } receiveValue: { [weak self] messages in
            self?.messages = messages
        }
    }
}