simplex-chat/apps/ios/Shared/Views/Chat/ChatItem/CIRcvDecryptionError.swift

//
//  CIRcvDecryptionError.swift
//  SimpleX (iOS)
//
//  Created by Evgeny on 15/04/2023.
//  Copyright © 2023 SimpleX Chat. All rights reserved.
//
// Spec: spec/client/chat-view.md

import SwiftUI
import SimpleXChat

let decryptErrorReason: LocalizedStringKey = "It can happen when you or your connection used the old database backup."

// Spec: spec/client/chat-view.md#CIRcvDecryptionError
struct CIRcvDecryptionError: View {
    @EnvironmentObject var m: ChatModel
    @EnvironmentObject var theme: AppTheme
    @ObservedObject var chat: Chat
    @Environment(\.showTimestamp) var showTimestamp: Bool
    var msgDecryptError: MsgDecryptError
    var msgCount: UInt32
    var chatItem: ChatItem
    @State private var alert: CIRcvDecryptionErrorAlert?

    @AppStorage(DEFAULT_SHOW_SENT_VIA_RPOXY) private var showSentViaProxy = false

    enum CIRcvDecryptionErrorAlert: Identifiable {
        case syncAllowedAlert(_ syncConnection: () -> Void)
        case syncNotSupportedContactAlert
        case syncNotSupportedMemberAlert
        case decryptionErrorAlert
        case error(title: LocalizedStringKey, error: LocalizedStringKey?)

        var id: String {
            switch self {
            case .syncAllowedAlert: return "syncAllowedAlert"
            case .syncNotSupportedContactAlert: return "syncNotSupportedContactAlert"
            case .syncNotSupportedMemberAlert: return "syncNotSupportedMemberAlert"
            case .decryptionErrorAlert: return "decryptionErrorAlert"
            case let .error(title, _): return "error \(title)"
            }
        }
    }

    var body: some View {
        ItemWithMeta {
            CIMetaView(chat: chat, chatItem: chatItem, metaColor: theme.colors.secondary)
        } content: { inlineMeta in
            viewBody(inlineMeta)
        }
            .onAppear {
                // for direct chat ConnectionStats are populated on opening chat, see ChatView onAppear
                if case let .group(groupInfo, _) = chat.chatInfo,
                   case let .groupRcv(groupMember) = chatItem.chatDir {
                    do {
                        let (member, stats) = try apiGroupMemberInfoSync(groupInfo.apiId, groupMember.groupMemberId)
                        if let s = stats {
                            m.updateGroupMemberConnectionStats(groupInfo, member, s)
                        }
                    } catch let error {
                        logger.error("apiGroupMemberInfo error: \(responseError(error))")
                    }
                }
            }
            .alert(item: $alert) { alertItem in
                switch(alertItem) {
                case let .syncAllowedAlert(syncConnection): return syncAllowedAlert(syncConnection)
                case .syncNotSupportedContactAlert: return Alert(title: Text("Fix not supported by contact"), message: message())
                case .syncNotSupportedMemberAlert: return Alert(title: Text("Fix not supported by group member"), message: message())
                case .decryptionErrorAlert: return Alert(title: Text("Decryption error"), message: message())
                case let .error(title, error): return mkAlert(title: title, message: error)
                }
            }
    }

    private func viewBody(_ inlineMeta: CIMetaView?) -> some View {
        Group {
            if case let .direct(contact) = chat.chatInfo,
               let contactStats = contact.activeConn?.connectionStats {
                if contactStats.ratchetSyncAllowed {
                    decryptionErrorItemFixButton(syncSupported: true, inlineMeta) {
                        alert = .syncAllowedAlert { syncContactConnection(contact) }
                    }
                } else if !contactStats.ratchetSyncSupported {
                    decryptionErrorItemFixButton(syncSupported: false, inlineMeta) {
                        alert = .syncNotSupportedContactAlert
                    }
                } else {
                    basicDecryptionErrorItem(inlineMeta)
                }
            } else if case let .group(groupInfo, _) = chat.chatInfo,
                      case let .groupRcv(groupMember) = chatItem.chatDir,
                      let mem = m.getGroupMember(groupMember.groupMemberId),
                      let memberStats = mem.wrapped.activeConn?.connectionStats {
                if memberStats.ratchetSyncAllowed {
                    decryptionErrorItemFixButton(syncSupported: true, inlineMeta) {
                        alert = .syncAllowedAlert { syncMemberConnection(groupInfo, groupMember) }
                    }
                } else if !memberStats.ratchetSyncSupported {
                    decryptionErrorItemFixButton(syncSupported: false, inlineMeta) {
                        alert = .syncNotSupportedMemberAlert
                    }
                } else {
                    basicDecryptionErrorItem(inlineMeta)
                }
            } else {
                basicDecryptionErrorItem(inlineMeta)
            }
        }
        .background { chatItemFrameColor(chatItem, theme).modifier(ChatTailPadding()) }
        .if(inlineMeta == nil) { $0.modifier(ChatItemClipped(chatItem, tailVisible: false)) }
    }

    private func basicDecryptionErrorItem(_ inlineMeta: CIMetaView?) -> some View {
        decryptionErrorItem(inlineMeta) { alert = .decryptionErrorAlert }
    }

    private func decryptionErrorItemFixButton(syncSupported: Bool, _ inlineMeta: CIMetaView?, _ onClick: @escaping (() -> Void)) -> some View {
        ZStack(alignment: .bottomTrailing) {
            VStack(alignment: .leading, spacing: 2) {
                HStack {
                    Text(chatItem.content.text)
                        .foregroundColor(.red)
                        .italic()
                }
                (
                    Text(Image(systemName: "exclamationmark.arrow.triangle.2.circlepath"))
                        .foregroundColor(syncSupported ? theme.colors.primary : theme.colors.secondary)
                        .font(.callout)
                    + textSpace
                    + Text("Fix connection")
                        .foregroundColor(syncSupported ? theme.colors.primary : theme.colors.secondary)
                        .font(.callout)
                    + metaReserve(inlineMeta)
                )
            }
            .padding(.horizontal, 12)
            if let inlineMeta {
                inlineMeta
                    .padding(.horizontal, 12)
            }
        }
        .simultaneousGesture(TapGesture().onEnded(onClick))
        .padding(.vertical, 6)
        .textSelection(.disabled)
    }

    private func decryptionErrorItem(_ inlineMeta: CIMetaView?, _ onClick: @escaping (() -> Void)) -> some View {
        return ZStack(alignment: .bottomTrailing) {
            HStack {
                Text(chatItem.content.text)
                    .foregroundColor(.red)
                    .italic()
                + metaReserve(inlineMeta)
            }
            .padding(.horizontal, 12)
            if let inlineMeta {
                inlineMeta
                    .padding(.horizontal, 12)
            }
        }
        .simultaneousGesture(TapGesture().onEnded(onClick))
        .padding(.vertical, 6)
        .textSelection(.disabled)
    }

    private func metaReserve(_ inlineMeta: CIMetaView?) -> Text {
        inlineMeta == nil
        ? Text(verbatim: "")
        : Text(verbatim: "   ") + ciMetaText(chatItem.meta, chatTTL: nil, encrypted: nil, colorMode: .transparent, showViaProxy: showSentViaProxy, showTimesamp: showTimestamp)
    }

    private func message() -> Text {
        var message: Text
        let why = Text(decryptErrorReason)
        switch msgDecryptError {
        case .ratchetHeader:
            message = Text("\(msgCount) messages failed to decrypt.") + textNewLine + why
        case .tooManySkipped:
            message = Text("\(msgCount) messages skipped.") + textNewLine + why
        case .ratchetEarlier:
            message = Text("\(msgCount) messages failed to decrypt.") + textNewLine + why
        case .other:
            message = Text("\(msgCount) messages failed to decrypt.") + textNewLine + why
        case .ratchetSync:
            message = Text("Encryption re-negotiation failed.")
        }
        return message
    }

    private func syncMemberConnection(_ groupInfo: GroupInfo, _ member: GroupMember) {
        Task {
            do {
                let (mem, stats) = try apiSyncGroupMemberRatchet(groupInfo.apiId, member.groupMemberId, false)
                await MainActor.run {
                    m.updateGroupMemberConnectionStats(groupInfo, mem, stats)
                }
            } catch let error {
                logger.error("syncMemberConnection apiSyncGroupMemberRatchet error: \(responseError(error))")
                await MainActor.run {
                    showErrorAlert(error, NSLocalizedString("Error synchronizing connection", comment: ""))
                }
            }
        }
    }

    private func syncContactConnection(_ contact: Contact) {
        Task {
            do {
                let stats = try apiSyncContactRatchet(contact.apiId, false)
                await MainActor.run {
                    m.updateContactConnectionStats(contact, stats)
                }
            } catch let error {
                logger.error("syncContactConnection apiSyncContactRatchet error: \(responseError(error))")
                await MainActor.run {
                    showErrorAlert(error, NSLocalizedString("Error synchronizing connection", comment: ""))
                }
            }
        }
    }

    private func syncAllowedAlert(_ syncConnection: @escaping () -> Void) -> Alert {
        Alert(
            title: Text("Fix connection?"),
            message: message(),
            primaryButton: .default(Text("Fix"), action: syncConnection),
            secondaryButton: .cancel()
        )
    }
}

//struct CIRcvDecryptionError_Previews: PreviewProvider {
//    static var previews: some View {
//        CIRcvDecryptionError(msgDecryptError: .ratchetHeader, msgCount: 1, chatItem: ChatItem.getIntegrityErrorSample())
//    }
//}