SharingThreadPickerViewController.swift

//
// Copyright 2021 Signal Messenger, LLC
// SPDX-License-Identifier: AGPL-3.0-only
//

import Foundation
import LibSignalClient
import SignalServiceKit
import SignalUI
import UIKit

class SharingThreadPickerViewController: ConversationPickerViewController {

    weak var shareViewDelegate: ShareViewDelegate?

    private var sendProgressSheet: SharingThreadPickerProgressSheet?

    /// It can take a while to fully process attachments, and until we do, we
    /// aren't fully sure if the attachments are stories-compatible. To speed
    /// things up, we do some fast pre-checks and store the result here.
    ///
    /// True if these pre-checks determine all attachments are
    /// stories-compatible. If this is true, we show stories forever, even if
    /// the attachments end up being incompatible, because it would be weird to
    /// have the stories destinations disappear. Instead, we show an error when
    /// actually sending if stories are selected.
    let areAttachmentStoriesCompatPrecheck: Bool

    private let attachmentLimits: OutgoingAttachmentLimits

    var typedItems: [TypedItem] {
        didSet {
            owsPrecondition(typedItems.count <= 1 || typedItems.allSatisfy(\.isVisualMedia))
            updateStoriesState()
            updateApprovalMode()
        }
    }

    private var mentionCandidates: [Aci] = []

    private var selectedConversations: [ConversationItem] { selection.conversations }

    init(
        areAttachmentStoriesCompatPrecheck: Bool,
        attachmentLimits: OutgoingAttachmentLimits,
        shareViewDelegate: ShareViewDelegate,
    ) {
        self.typedItems = []
        self.areAttachmentStoriesCompatPrecheck = areAttachmentStoriesCompatPrecheck
        self.attachmentLimits = attachmentLimits
        self.shareViewDelegate = shareViewDelegate

        super.init(selection: ConversationPickerSelection())

        shouldBatchUpdateIdentityKeys = true
        pickerDelegate = self

        self.updateStoriesState()
        self.updateApprovalMode()
    }

    func presentActionSheetOnNavigationController(_ alert: ActionSheetController) {
        if let navigationController = shareViewDelegate?.shareViewNavigationController {
            navigationController.presentActionSheet(alert)
        } else {
            self.presentActionSheet(alert)
        }
    }

    private func updateMentionCandidates() {
        AssertIsOnMainThread()

        guard
            selectedConversations.count == 1,
            case .group(let groupThreadId) = selectedConversations.first?.messageRecipient
        else {
            mentionCandidates = []
            return
        }

        let databaseStorage = SSKEnvironment.shared.databaseStorageRef
        self.mentionCandidates = databaseStorage.read { tx in
            let groupThread = TSGroupThread.fetchGroupThreadViaCache(uniqueId: groupThreadId, transaction: tx)
            owsAssertDebug(groupThread != nil)
            if let groupThread, groupThread.allowsMentionSend {
                return groupThread.recipientAddresses(with: tx).compactMap(\.aci)
            } else {
                return []
            }
        }
    }

    private func updateStoriesState() {
        if areAttachmentStoriesCompatPrecheck || canSendTypedItemsToStory() {
            sectionOptions.insert(.stories)
        } else {
            sectionOptions.remove(.stories)
        }
    }

    private func canSendTypedItemsToStory() -> Bool {
        return !typedItems.isEmpty && typedItems.allSatisfy(\.isStoriesCompatible)
    }

    // MARK: - Approval

    func approve() {
        do {
            let vc = try buildApprovalViewController(withCancelButton: false)
            navigationController?.pushViewController(vc, animated: true)
        } catch {
            shareViewDelegate?.shareViewFailed(error: error)
        }
    }

    func buildApprovalViewController(for thread: TSThread) throws -> UIViewController {
        AssertIsOnMainThread()
        loadViewIfNeeded()
        guard let conversationItem = conversation(for: thread) else {
            throw OWSAssertionError("Unexpectedly missing conversation for selected thread")
        }
        selection.add(conversationItem)
        return try buildApprovalViewController(withCancelButton: true)
    }

    func buildApprovalViewController(withCancelButton: Bool) throws -> UIViewController {
        guard let anyItem = typedItems.first else {
            throw OWSAssertionError("Unexpectedly missing attachments")
        }

        let approvalVC: UIViewController

        switch anyItem {
        case .text(let inlineMessageText):
            let approvalView = TextApprovalViewController(
                messageBody: MessageBody(text: inlineMessageText.filteredValue.rawValue, ranges: .empty),
            )
            approvalVC = approvalView
            approvalView.delegate = self

        case .contact(let contactData):
            let cnContact = try SystemContact.parseVCardData(contactData)
            let contactShareDraft = SSKEnvironment.shared.databaseStorageRef.read { tx in
                return ContactShareDraft.load(
                    cnContact: cnContact,
                    signalContact: SystemContact(cnContact: cnContact),
                    contactManager: SSKEnvironment.shared.contactManagerRef,
                    phoneNumberUtil: SSKEnvironment.shared.phoneNumberUtilRef,
                    profileManager: SSKEnvironment.shared.profileManagerRef,
                    recipientManager: DependenciesBridge.shared.recipientManager,
                    tsAccountManager: DependenciesBridge.shared.tsAccountManager,
                    tx: tx,
                )
            }
            let approvalView = ContactShareViewController(contactShareDraft: contactShareDraft)
            approvalVC = approvalView
            approvalView.shareDelegate = self

        case .other:
            // We know that the first element of typedItems isn't .text or .contact
            // (see prior cases); the others must be visual media (see the precondition
            // on `typedItems`), so they also can't be .text or .contact.
            let approvalItems = typedItems.map {
                switch $0 {
                case .text, .contact:
                    owsFail("not possible")
                case .other(let attachment):
                    return AttachmentApprovalItem(attachment: attachment, canSave: false)
                }
            }
            var approvalVCOptions: AttachmentApprovalViewControllerOptions = withCancelButton ? [.hasCancel] : []
            if self.selection.conversations.contains(where: \.isStory) {
                approvalVCOptions.insert(.disallowViewOnce)
            }
            let approvalView = AttachmentApprovalViewController.loadWithSneakyTransaction(
                attachmentApprovalItems: approvalItems,
                attachmentLimits: attachmentLimits,
                options: approvalVCOptions,
            )
            approvalVC = approvalView
            approvalView.approvalDelegate = self
            approvalView.approvalDataSource = self
        }

        return approvalVC
    }

    // MARK: - Sending

    private enum ApprovedSend {
        case text(messageBody: MessageBody, linkPreview: OWSLinkPreviewDraft?)
        case contact(contactShare: ContactShareDraft)
        case other(attachments: ApprovedAttachments, messageBody: MessageBody?)
    }

    private func send(_ approvedSend: ApprovedSend) {
        // Start presenting empty; the attachments will get set later.
        self.presentOrUpdateSendProgressSheet(attachmentIds: [])

        self.shareViewDelegate?.shareViewWillSend()

        Task {
            switch await tryToSend(
                selectedConversations: selectedConversations,
                approvedSend: approvedSend,
            ) {
            case nil:
                self.dismissSendProgressSheet {}
                self.shareViewDelegate?.shareViewWasCompleted()
            case .some(let failure):
                self.dismissSendProgressSheet { self.showSendFailure(failure) }
            }
        }
    }

    private struct SendFailure {
        let outgoingMessages: [PreparedOutgoingMessage]
        let error: Error
    }

    private func tryToSend(
        selectedConversations: [ConversationItem],
        approvedSend: ApprovedSend,
    ) async -> SendFailure? {
        switch approvedSend {
        case .text(let messageBody, let linkPreview):
            guard !messageBody.text.isEmpty else {
                return SendFailure(outgoingMessages: [], error: OWSAssertionError("Missing body."))
            }

            let linkPreviewDataSource: LinkPreviewDataSource?
            if let linkPreview {
                let linkPreviewManager = DependenciesBridge.shared.linkPreviewManager
                linkPreviewDataSource = try? await linkPreviewManager.buildDataSource(from: linkPreview)
            } else {
                linkPreviewDataSource = nil
            }

            return await self.sendToOutgoingMessageThreads(
                selectedConversations: selectedConversations,
                messageBody: messageBody,
                messageBlock: { destination, tx in
                    let unpreparedMessage = UnpreparedOutgoingMessage.build(
                        thread: destination.thread,
                        messageBody: destination.messageBody,
                        quotedReplyDraft: nil,
                        linkPreviewDataSource: linkPreviewDataSource,
                        transaction: tx,
                    )
                    return try unpreparedMessage.prepare(tx: tx)
                },
                enqueueStory: { conversations in
                    // Send the text message to any selected story recipients
                    // as a text story with default styling.
                    try await StorySharing.enqueueTextStory(
                        with: messageBody,
                        linkPreviewDraft: linkPreview,
                        to: conversations,
                    )
                },
            )
        case .contact(let contactShare):
            let contactShareForSending: ContactShareDraft.ForSending
            do {
                let contactShareManager = DependenciesBridge.shared.contactShareManager
                contactShareForSending = try await contactShareManager.validateAndPrepare(draft: contactShare)
            } catch {
                return SendFailure(outgoingMessages: [], error: error)
            }
            return await self.sendToOutgoingMessageThreads(
                selectedConversations: selectedConversations,
                messageBody: nil,
                messageBlock: { destination, tx in
                    let dmConfigurationStore = DependenciesBridge.shared.disappearingMessagesConfigurationStore
                    let builder: TSOutgoingMessageBuilder = .withDefaultValues(
                        thread: destination.thread,
                        expiresInSeconds: dmConfigurationStore.durationSeconds(
                            for: destination.thread,
                            tx: tx,
                        ),
                    )
                    let message = builder.build(transaction: tx)
                    let unpreparedMessage = UnpreparedOutgoingMessage.forMessage(
                        message,
                        body: nil,
                        contactShareDraft: contactShareForSending,
                    )
                    return try unpreparedMessage.prepare(tx: tx)
                },
                // We don't send contact shares to stories
                enqueueStory: { _ in [] },
            )
        case .other(let attachments, let messageBody):
            // This method will also add threads to the profile whitelist.
            let enqueueResults: [AttachmentMultisend.EnqueueResult]
            do {
                enqueueResults = try await AttachmentMultisend.enqueueApprovedMedia(
                    conversations: selectedConversations,
                    approvedMessageBody: messageBody,
                    approvedAttachments: attachments,
                    attachmentLimits: attachmentLimits,
                )
            } catch {
                return SendFailure(outgoingMessages: [], error: error)
            }

            self.presentOrUpdateSendProgressSheet(outgoingMessages: enqueueResults.map(\.preparedMessage))

            do {
                try await withThrowingTaskGroup { taskGroup in
                    for sendPromise in enqueueResults.map(\.sendPromise) {
                        taskGroup.addTask { try await sendPromise.awaitable() }
                    }
                    try await taskGroup.waitForAll()
                }
            } catch {
                return SendFailure(outgoingMessages: enqueueResults.map(\.preparedMessage), error: error)
            }

            return nil
        }
    }

    private func presentOrUpdateSendProgressSheet(outgoingMessages: [PreparedOutgoingMessage]) {
        let attachmentIds = SSKEnvironment.shared.databaseStorageRef.read { tx in
            return outgoingMessages.attachmentIdsForUpload(tx: tx)
        }
        presentOrUpdateSendProgressSheet(attachmentIds: attachmentIds)
    }

    private func presentOrUpdateSendProgressSheet(attachmentIds: [Attachment.IDType]) {
        AssertIsOnMainThread()

        if let sendProgressSheet {
            // Update the existing sheet.
            sendProgressSheet.updateSendingAttachmentIds(attachmentIds)
            return
        } else {
            let actionSheet = SharingThreadPickerProgressSheet(
                attachmentIds: attachmentIds,
                delegate: self.shareViewDelegate,
            )
            presentActionSheetOnNavigationController(actionSheet)
            self.sendProgressSheet = actionSheet
        }
    }

    private func dismissSendProgressSheet(_ completion: (() -> Void)?) {
        if let sendProgressSheet {
            sendProgressSheet.dismiss(animated: true, completion: completion)
            self.sendProgressSheet = nil
        } else {
            completion?()
        }
    }

    private func sendToOutgoingMessageThreads(
        selectedConversations: [ConversationItem],
        messageBody: MessageBody?,
        messageBlock: (AttachmentMultisend.Destination, DBWriteTransaction) throws -> PreparedOutgoingMessage,
        enqueueStory: (_ conversations: [ConversationItem]) async throws -> [AttachmentMultisend.EnqueueResult],
    ) async -> SendFailure? {
        let databaseStorage = SSKEnvironment.shared.databaseStorageRef

        let conversations = selectedConversations.filter { $0.outgoingMessageType == .message }

        let preparedNonStoryMessages: [PreparedOutgoingMessage]
        let nonStorySendPromises: [Promise<Void>]
        do {
            let destinations = try await AttachmentMultisend.prepareDestinations(
                forSendingMessageBody: messageBody,
                toConversations: conversations,
            )

            (preparedNonStoryMessages, nonStorySendPromises) = try await databaseStorage.awaitableWrite { tx in
                let preparedMessages = try destinations.map { destination in
                    return try messageBlock(destination, tx)
                }

                // We're sending a message to this thread, approve any pending message request
                destinations.forEach { destination in
                    ThreadUtil.addThreadToProfileWhitelistIfEmptyOrPendingRequest(
                        destination.thread,
                        setDefaultTimerIfNecessary: true,
                        tx: tx,
                    )
                }

                let sendPromises = preparedMessages.map {
                    ThreadUtil.enqueueMessagePromise(
                        message: $0,
                        transaction: tx,
                    )
                }
                return (preparedMessages, sendPromises)
            }
        } catch {
            return SendFailure(outgoingMessages: [], error: error)
        }

        let enqueueStoryResults: [AttachmentMultisend.EnqueueResult]
        do {
            enqueueStoryResults = try await enqueueStory(selectedConversations)
        } catch let error {
            return SendFailure(outgoingMessages: [], error: error)
        }

        let preparedMessages = preparedNonStoryMessages + enqueueStoryResults.map(\.preparedMessage)
        self.presentOrUpdateSendProgressSheet(outgoingMessages: preparedMessages)

        do {
            try await withThrowingTaskGroup { taskGroup in
                for sendPromise in nonStorySendPromises + enqueueStoryResults.map(\.sendPromise) {
                    taskGroup.addTask { try await sendPromise.awaitable() }
                }
                try await taskGroup.waitForAll()
            }
        } catch {
            return SendFailure(outgoingMessages: preparedMessages, error: error)
        }

        return nil
    }

    private nonisolated func threads(for conversationItems: [ConversationItem], tx: DBWriteTransaction) -> [TSThread] {
        return conversationItems.compactMap { conversation in
            guard let thread = conversation.getOrCreateThread(transaction: tx) else {
                owsFailDebug("Missing thread for conversation")
                return nil
            }
            return thread
        }
    }

    private func showSendFailure(_ failure: SendFailure) {
        AssertIsOnMainThread()

        Logger.warn("\(failure.error)")

        let cancelAction = ActionSheetAction(
            title: CommonStrings.cancelButton,
            style: .cancel,
        ) { [weak self] _ in
            guard let self else { return }
            SSKEnvironment.shared.databaseStorageRef.write { transaction in
                for message in failure.outgoingMessages {
                    // If we sent the message to anyone, mark it as failed
                    message.updateWithAllSendingRecipientsMarkedAsFailed(tx: transaction)
                }
            }
            self.shareViewDelegate?.shareViewWasCancelled()
        }

        let failureTitle = OWSLocalizedString("SHARE_EXTENSION_SENDING_FAILURE_TITLE", comment: "Alert title")

        if let untrustedIdentityError = failure.error as? UntrustedIdentityError {
            let untrustedServiceId = untrustedIdentityError.serviceId
            let failureFormat = OWSLocalizedString(
                "SHARE_EXTENSION_FAILED_SENDING_BECAUSE_UNTRUSTED_IDENTITY_FORMAT",
                comment: "alert body when sharing file failed because of untrusted/changed identity keys",
            )
            let displayName = SSKEnvironment.shared.databaseStorageRef.read { tx in
                return SSKEnvironment.shared.contactManagerRef.displayName(for: SignalServiceAddress(untrustedServiceId), tx: tx).resolvedValue()
            }
            let failureMessage = String.nonPluralLocalizedStringWithFormat(failureFormat, displayName)

            let actionSheet = ActionSheetController(title: failureTitle, message: failureMessage)
            actionSheet.addAction(cancelAction)

            // Capture the identity key before showing the prompt about it.
            let identityKey = SSKEnvironment.shared.databaseStorageRef.read { tx in
                let identityManager = DependenciesBridge.shared.identityManager
                return identityManager.identityKey(for: SignalServiceAddress(untrustedServiceId), tx: tx)
            }

            let confirmAction = ActionSheetAction(
                title: SafetyNumberStrings.confirmSendButton,
                style: .default,
            ) { [weak self] _ in
                guard let self else { return }

                // Confirm Identity
                SSKEnvironment.shared.databaseStorageRef.write { transaction in
                    let identityManager = DependenciesBridge.shared.identityManager
                    let verificationState = identityManager.verificationState(
                        for: SignalServiceAddress(untrustedServiceId),
                        tx: transaction,
                    )
                    switch verificationState {
                    case .verified:
                        owsFailDebug("Unexpected state")
                    case .noLongerVerified, .implicit(isAcknowledged: _):
                        Logger.info("marked recipient: \(untrustedServiceId) as default verification status.")
                        guard let identityKey else {
                            owsFailDebug("Can't be untrusted unless there's already an identity key.")
                            return
                        }
                        _ = identityManager.setVerificationState(
                            .implicit(isAcknowledged: true),
                            of: identityKey,
                            for: SignalServiceAddress(untrustedServiceId),
                            isUserInitiatedChange: true,
                            tx: transaction,
                        )
                    }
                }

                // Resend
                self.resendMessages(failure.outgoingMessages)
            }
            actionSheet.addAction(confirmAction)

            presentActionSheetOnNavigationController(actionSheet)
        } else {
            let actionSheet = ActionSheetController(title: failureTitle)
            actionSheet.addAction(cancelAction)

            let retryAction = ActionSheetAction(title: CommonStrings.retryButton, style: .default) { [weak self] _ in
                self?.resendMessages(failure.outgoingMessages)
            }
            actionSheet.addAction(retryAction)

            presentActionSheetOnNavigationController(actionSheet)
        }
    }

    func resendMessages(_ outgoingMessages: [PreparedOutgoingMessage]) {
        AssertIsOnMainThread()
        owsAssertDebug(!outgoingMessages.isEmpty)

        let databaseStorage = SSKEnvironment.shared.databaseStorageRef
        let messageSenderJobQueue = SSKEnvironment.shared.messageSenderJobQueueRef

        var promises = [Promise<Void>]()
        databaseStorage.write { tx in
            for message in outgoingMessages {
                promises.append(messageSenderJobQueue.add(.promise, message: message, transaction: tx))
            }
        }

        self.presentOrUpdateSendProgressSheet(outgoingMessages: outgoingMessages)
        Promise.when(fulfilled: promises).done {
            self.dismissSendProgressSheet {}
            self.shareViewDelegate?.shareViewWasCompleted()
        }.catch { error in
            self.dismissSendProgressSheet {
                self.showSendFailure(SendFailure(outgoingMessages: outgoingMessages, error: error))
            }
        }
    }
}

// MARK: -

extension SharingThreadPickerViewController: ConversationPickerDelegate {
    func conversationPickerSelectionDidChange(_ conversationPickerViewController: ConversationPickerViewController) {
        updateMentionCandidates()
    }

    func conversationPickerDidCompleteSelection(_ conversationPickerViewController: ConversationPickerViewController) {
        approve()
    }

    func conversationPickerCanCancel(_ conversationPickerViewController: ConversationPickerViewController) -> Bool {
        return true
    }

    func conversationPickerDidCancel(_ conversationPickerViewController: ConversationPickerViewController) {
        shareViewDelegate?.shareViewWasCancelled()
    }

    func approvalMode(_ conversationPickerViewController: ConversationPickerViewController) -> ApprovalMode {
        return typedItems.isEmpty ? .loading : .next
    }

    func conversationPickerDidBeginEditingText() {}

    func conversationPickerSearchBarActiveDidChange(_ conversationPickerViewController: ConversationPickerViewController) {}
}

// MARK: -

extension SharingThreadPickerViewController: TextApprovalViewControllerDelegate {
    func textApproval(_ textApproval: TextApprovalViewController, didApproveMessage messageBody: MessageBody, linkPreviewDraft: OWSLinkPreviewDraft?) {
        assert(messageBody.text.nilIfEmpty != nil)
        send(.text(messageBody: messageBody, linkPreview: linkPreviewDraft))
    }

    func textApprovalDidCancel(_ textApproval: TextApprovalViewController) {
        shareViewDelegate?.shareViewWasCancelled()
    }

    func textApprovalCustomTitle(_ textApproval: TextApprovalViewController) -> String? {
        return nil
    }

    func textApprovalRecipientsDescription(_ textApproval: TextApprovalViewController) -> String? {
        let conversations = selectedConversations
        guard conversations.count > 0 else {
            return nil
        }
        return conversations.map { $0.titleWithSneakyTransaction }.joined(separator: ", ")
    }

    func textApprovalMode(_ textApproval: TextApprovalViewController) -> ApprovalMode {
        return .send
    }
}

// MARK: -

extension SharingThreadPickerViewController: ContactShareViewControllerDelegate {

    func contactShareViewController(_ viewController: ContactShareViewController, didApproveContactShare contactShare: ContactShareDraft) {
        send(.contact(contactShare: contactShare))
    }

    func contactShareViewControllerDidCancel(_ viewController: ContactShareViewController) {
        shareViewDelegate?.shareViewWasCancelled()
    }

    func titleForContactShareViewController(_ viewController: ContactShareViewController) -> String? {
        return nil
    }

    func recipientsDescriptionForContactShareViewController(_ viewController: ContactShareViewController) -> String? {
        let conversations = selectedConversations
        guard conversations.count > 0 else {
            return nil
        }
        return conversations.map { $0.titleWithSneakyTransaction }.joined(separator: ", ")
    }

    func approvalModeForContactShareViewController(_ viewController: ContactShareViewController) -> SignalUI.ApprovalMode {
        return .send
    }
}

// MARK: -

extension SharingThreadPickerViewController: AttachmentApprovalViewControllerDelegate {

    func attachmentApproval(_ attachmentApproval: AttachmentApprovalViewController, didChangeMessageBody newMessageBody: MessageBody?) {
        // We can ignore this event.
    }

    func attachmentApproval(_ attachmentApproval: AttachmentApprovalViewController, didChangeViewOnceState isViewOnce: Bool) {
        // We can ignore this event.
    }

    func attachmentApproval(_ attachmentApproval: AttachmentApprovalViewController, didRemoveAttachment attachmentApprovalItem: AttachmentApprovalItem) {
        // We can ignore this event.
    }

    func attachmentApproval(
        _ attachmentApproval: AttachmentApprovalViewController,
        didApproveAttachments approvedAttachments: ApprovedAttachments,
        messageBody: MessageBody?,
    ) {
        send(.other(attachments: approvedAttachments, messageBody: messageBody))
    }

    func attachmentApprovalDidCancel() {
        shareViewDelegate?.shareViewWasCancelled()
    }

    func attachmentApprovalDidTapAddMore(_ attachmentApproval: AttachmentApprovalViewController) {
        owsFailDebug("Cannot add more to message forwards.")
    }
}

// MARK: -

extension SharingThreadPickerViewController: AttachmentApprovalViewControllerDataSource {

    var attachmentApprovalTextInputContextIdentifier: String? {
        return nil
    }

    var attachmentApprovalRecipientNames: [String] {
        selectedConversations.map { $0.titleWithSneakyTransaction }
    }

    func attachmentApprovalMentionableAcis(tx: DBReadTransaction) -> [Aci] {
        mentionCandidates
    }

    func attachmentApprovalMentionCacheInvalidationKey() -> String {
        return "\(mentionCandidates.hashValue)"
    }
}