Merge commit '7621e2f8dec938cf48181c8b10afc9b01f444e68' into beta

submodules/TelegramUI/Sources/Chat/ChatControllerFrozenAccount.swift

@@ -0,0 +1,34 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import AccountContext
+
+extension ChatControllerImpl {
+    func presentAccountFrozenInfoIfNeeded(delay: Bool = false) -> Bool {
+        if self.context.isFrozen {
+            let accountFreezeConfiguration = AccountFreezeConfiguration.with(appConfiguration: self.context.currentAppConfiguration.with { $0 })
+            if let freezeAppealUrl = accountFreezeConfiguration.freezeAppealUrl {
+                let components = freezeAppealUrl.components(separatedBy: "/")
+                if let username = components.last, let peer = self.presentationInterfaceState.renderedPeer?.peer, peer.addressName == username {
+                    return false
+                }
+            }
+            let present = {
+                self.push(self.context.sharedContext.makeAccountFreezeInfoScreen(context: self.context))
+            }
+            if delay {
+                Queue.mainQueue().after(0.3) {
+                    present()
+                }
+            } else {
+                present()
+            }
+            return true
+        }
+        return false
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerMediaRecording.swift

@@ -0,0 +1,777 @@
+import Foundation
+import UIKit
+import Postbox
+import SwiftSignalKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SafariServices
+import MobileCoreServices
+import Intents
+import LegacyComponents
+import TelegramPresentationData
+import TelegramUIPreferences
+import DeviceAccess
+import TextFormat
+import TelegramBaseController
+import AccountContext
+import TelegramStringFormatting
+import OverlayStatusController
+import DeviceLocationManager
+import ShareController
+import UrlEscaping
+import ContextUI
+import ComposePollUI
+import AlertUI
+import PresentationDataUtils
+import UndoUI
+import TelegramCallsUI
+import TelegramNotices
+import GameUI
+import ScreenCaptureDetection
+import GalleryUI
+import OpenInExternalAppUI
+import LegacyUI
+import InstantPageUI
+import LocationUI
+import BotPaymentsUI
+import DeleteChatPeerActionSheetItem
+import HashtagSearchUI
+import LegacyMediaPickerUI
+import Emoji
+import PeerAvatarGalleryUI
+import PeerInfoUI
+import RaiseToListen
+import UrlHandling
+import AvatarNode
+import AppBundle
+import LocalizedPeerData
+import PhoneNumberFormat
+import SettingsUI
+import UrlWhitelist
+import TelegramIntents
+import TooltipUI
+import StatisticsUI
+import MediaResources
+import LocalMediaResources
+import GalleryData
+import ChatInterfaceState
+import InviteLinksUI
+import Markdown
+import TelegramPermissionsUI
+import Speak
+import TranslateUI
+import UniversalMediaPlayer
+import WallpaperBackgroundNode
+import ChatListUI
+import CalendarMessageScreen
+import ReactionSelectionNode
+import ReactionListContextMenuContent
+import AttachmentUI
+import AttachmentTextInputPanelNode
+import MediaPickerUI
+import ChatPresentationInterfaceState
+import Pasteboard
+import ChatSendMessageActionUI
+import ChatTextLinkEditUI
+import WebUI
+import PremiumUI
+import ImageTransparency
+import StickerPackPreviewUI
+import TextNodeWithEntities
+import EntityKeyboard
+import ChatTitleView
+import EmojiStatusComponent
+import ChatTimerScreen
+import MediaPasteboardUI
+import ChatListHeaderComponent
+import ChatControllerInteraction
+import FeaturedStickersScreen
+import ChatEntityKeyboardInputNode
+import StorageUsageScreen
+import AvatarEditorScreen
+import ChatScheduleTimeController
+import ICloudResources
+import StoryContainerScreen
+import MoreHeaderButton
+import VolumeButtons
+import ChatAvatarNavigationNode
+import ChatContextQuery
+import PeerReportScreen
+import PeerSelectionController
+import SaveToCameraRoll
+import ChatMessageDateAndStatusNode
+import ReplyAccessoryPanelNode
+import TextSelectionNode
+import ChatMessagePollBubbleContentNode
+import ChatMessageItem
+import ChatMessageItemImpl
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatMessageAnimatedStickerItemNode
+import ChatMessageBubbleItemNode
+import ChatNavigationButton
+import WebsiteType
+import PeerInfoScreen
+import MediaEditorScreen
+import WallpaperGalleryScreen
+import WallpaperGridScreen
+import VideoMessageCameraScreen
+import TopMessageReactions
+import AudioWaveform
+import PeerNameColorScreen
+import ChatEmptyNode
+import ChatMediaInputStickerGridItem
+import AdsInfoScreen
+
+extension ChatControllerImpl {
+    func requestAudioRecorder(beginWithTone: Bool, existingDraft: ChatInterfaceMediaDraftState.Audio? = nil) {
+        if self.audioRecorderValue == nil {
+            if self.recorderFeedback == nil && existingDraft == nil {
+                self.recorderFeedback = HapticFeedback()
+                self.recorderFeedback?.prepareImpact(.light)
+            }
+            
+            var resumeData: AudioRecorderResumeData?
+            if let existingDraft, let path = self.context.account.postbox.mediaBox.completedResourcePath(existingDraft.resource), let compressedData = try? Data(contentsOf: URL(fileURLWithPath: path), options: [.mappedIfSafe]), let recorderResumeData = existingDraft.resumeData {
+                resumeData = AudioRecorderResumeData(compressedData: compressedData, resumeData: recorderResumeData)
+            }
+            
+            self.audioRecorder.set(
+                self.context.sharedContext.mediaManager.audioRecorder(
+                    resumeData: resumeData,
+                    beginWithTone: beginWithTone,
+                    applicationBindings: self.context.sharedContext.applicationBindings,
+                    beganWithTone: { _ in
+                    }
+                )
+            )
+        }
+    }
+    
+    func requestVideoRecorder() {
+        if self.videoRecorderValue == nil {
+            if let currentInputPanelFrame = self.chatDisplayNode.currentInputPanelFrame() {
+                if self.recorderFeedback == nil {
+                    self.recorderFeedback = HapticFeedback()
+                    self.recorderFeedback?.prepareImpact(.light)
+                }
+                
+                var isScheduledMessages = false
+                if case .scheduledMessages = self.presentationInterfaceState.subject {
+                    isScheduledMessages = true
+                }
+                
+                var isBot = false
+                
+                var allowLiveUpload = false
+                var viewOnceAvailable = false
+                if let peerId = self.chatLocation.peerId {
+                    allowLiveUpload = peerId.namespace != Namespaces.Peer.SecretChat
+                    viewOnceAvailable = !isScheduledMessages && peerId.namespace == Namespaces.Peer.CloudUser && peerId != self.context.account.peerId && !isBot && self.presentationInterfaceState.sendPaidMessageStars == nil
+                } else if case .customChatContents = self.chatLocation {
+                    allowLiveUpload = true
+                }
+                
+                if let user = self.presentationInterfaceState.renderedPeer?.peer as? TelegramUser, user.botInfo != nil {
+                    isBot = true
+                }
+                
+                let controller = VideoMessageCameraScreen(
+                    context: self.context,
+                    updatedPresentationData: self.updatedPresentationData,
+                    allowLiveUpload: allowLiveUpload,
+                    viewOnceAvailable: viewOnceAvailable,
+                    inputPanelFrame: (currentInputPanelFrame, self.chatDisplayNode.inputNode != nil),
+                    chatNode: self.chatDisplayNode.historyNode,
+                    completion: { [weak self] message, silentPosting, scheduleTime in
+                        guard let self, let videoController = self.videoRecorderValue else {
+                            return
+                        }
+                        
+                        guard var message else {
+                            self.recorderFeedback?.error()
+                            self.recorderFeedback = nil
+                            self.videoRecorder.set(.single(nil))
+                            return
+                        }
+                        
+                        let replyMessageSubject = self.presentationInterfaceState.interfaceState.replyMessageSubject
+                        let correlationId = Int64.random(in: 0 ..< Int64.max)
+                        message = message
+                            .withUpdatedReplyToMessageId(replyMessageSubject?.subjectModel)
+                            .withUpdatedCorrelationId(correlationId)
+                        
+                        var shouldAnimateMessageTransition = self.chatDisplayNode.shouldAnimateMessageTransition
+                        if self.chatLocation.threadId == nil, let channel = self.presentationInterfaceState.renderedPeer?.peer as? TelegramChannel, channel.isMonoForum, let linkedMonoforumId = channel.linkedMonoforumId, let mainChannel = self.presentationInterfaceState.renderedPeer?.peers[linkedMonoforumId] as? TelegramChannel, mainChannel.hasPermission(.manageDirect) {
+                            shouldAnimateMessageTransition = false
+                        }
+                        
+                        var usedCorrelationId = false
+                        if scheduleTime == nil, shouldAnimateMessageTransition, let extractedView = videoController.extractVideoSnapshot() {
+                            usedCorrelationId = true
+                            self.chatDisplayNode.messageTransitionNode.add(correlationId: correlationId, source:  .videoMessage(ChatMessageTransitionNodeImpl.Source.VideoMessage(view: extractedView)), initiated: { [weak videoController, weak self] in
+                                videoController?.hideVideoSnapshot()
+                                guard let self else {
+                                    return
+                                }
+                                self.videoRecorder.set(.single(nil))
+                            })
+                        } else {
+                            self.videoRecorder.set(.single(nil))
+                        }
+                        
+                        self.chatDisplayNode.setupSendActionOnViewUpdate({ [weak self] in
+                            if let self {
+                                self.chatDisplayNode.collapseInput()
+                                
+                                self.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                                    $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedSendMessageEffect(nil).withUpdatedMediaDraftState(nil).withUpdatedPostSuggestionState(nil) }
+                                })
+                            }
+                        }, usedCorrelationId ? correlationId : nil)
+                        
+                        let messages = [message]
+                        let transformedMessages: [EnqueueMessage]
+                        if let silentPosting {
+                            transformedMessages = self.transformEnqueueMessages(messages, silentPosting: silentPosting)
+                        } else if let scheduleTime {
+                            transformedMessages = self.transformEnqueueMessages(messages, silentPosting: false, scheduleTime: scheduleTime)
+                        } else {
+                            transformedMessages = self.transformEnqueueMessages(messages)
+                        }
+                        
+                        self.sendMessages(transformedMessages)
+                    }
+                )
+                controller.onResume = { [weak self] in
+                    guard let self else {
+                        return
+                    }
+                    self.resumeMediaRecorder()
+                }
+                self.videoRecorder.set(.single(controller))
+            }
+        }
+    }
+    
+    func dismissMediaRecorder(_ action: ChatFinishMediaRecordingAction) {
+        var updatedAction = action
+        var isScheduledMessages = false
+        if case .scheduledMessages = self.presentationInterfaceState.subject {
+            isScheduledMessages = true
+        }
+        
+        if let _ = self.presentationInterfaceState.slowmodeState, !isScheduledMessages {
+            updatedAction = .preview
+        }
+        
+        var sendImmediately = false
+        if let _ = self.presentationInterfaceState.sendPaidMessageStars, case .send = action {
+            updatedAction = .preview
+            sendImmediately = true
+        }
+        
+        if let audioRecorderValue = self.audioRecorderValue {
+            switch action {
+            case .pause:
+                audioRecorderValue.pause()
+            default:
+                audioRecorderValue.stop()
+            }
+            
+            self.dismissAllTooltips()
+            
+            switch updatedAction {
+            case .dismiss:
+                self.recorderDataDisposable.set(nil)
+                self.chatDisplayNode.updateRecordedMediaDeleted(true)
+                self.audioRecorder.set(.single(nil))
+            case .preview, .pause:
+                self.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                    $0.updatedInputTextPanelState { panelState in
+                        return panelState.withUpdatedMediaRecordingState(.waitingForPreview)
+                    }
+                })
+                
+                var resource: LocalFileMediaResource?
+                self.recorderDataDisposable.set(
+                    (audioRecorderValue.takenRecordedData()
+                     |> deliverOnMainQueue).startStrict(
+                        next: { [weak self] data in
+                            if let strongSelf = self, let data = data {
+                                if data.duration < 0.5 {
+                                    strongSelf.recorderFeedback?.error()
+                                    strongSelf.recorderFeedback = nil
+                                    strongSelf.audioRecorder.set(.single(nil))
+                                    strongSelf.recorderDataDisposable.set(nil)
+                                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                        $0.updatedInputTextPanelState { panelState in
+                                            return panelState.withUpdatedMediaRecordingState(nil)
+                                        }
+                                    })
+                                } else if let waveform = data.waveform {
+                                    if resource == nil {
+                                        resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max), size: Int64(data.compressedData.count))
+                                        strongSelf.context.account.postbox.mediaBox.storeResourceData(resource!.id, data: data.compressedData)
+                                    }
+                                    
+                                    let audioWaveform: AudioWaveform
+                                    if let recordedMediaPreview = strongSelf.presentationInterfaceState.interfaceState.mediaDraftState, case let .audio(audio) = recordedMediaPreview {
+                                        audioWaveform = audio.waveform
+                                    } else {
+                                        audioWaveform = AudioWaveform(bitstream: waveform, bitsPerSample: 5)
+                                    }
+                                    
+                                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                        $0.updatedInterfaceState {
+                                            $0.withUpdatedMediaDraftState(.audio(
+                                                ChatInterfaceMediaDraftState.Audio(
+                                                    resource: resource!,
+                                                    fileSize: Int32(data.compressedData.count),
+                                                    duration: data.duration,
+                                                    waveform: audioWaveform,
+                                                    trimRange: data.trimRange,
+                                                    resumeData: data.resumeData
+                                                )
+                                            ))
+                                        }.updatedInputTextPanelState { panelState in
+                                            return panelState.withUpdatedMediaRecordingState(nil)
+                                        }
+                                    })
+                                    strongSelf.recorderFeedback = nil
+                                    strongSelf.updateDownButtonVisibility()
+                                    
+                                    if sendImmediately {
+                                        strongSelf.interfaceInteraction?.sendRecordedMedia(false, false)
+                                    }
+                                }
+                            }
+                        })
+                )
+            case let .send(viewOnce):
+                self.chatDisplayNode.updateRecordedMediaDeleted(false)
+                self.recorderDataDisposable.set((audioRecorderValue.takenRecordedData()
+                |> deliverOnMainQueue).startStrict(next: { [weak self] data in
+                    if let strongSelf = self, let data = data {
+                        if data.duration < 0.5 {
+                            strongSelf.recorderFeedback?.error()
+                            strongSelf.recorderFeedback = nil
+                            strongSelf.audioRecorder.set(.single(nil))
+                            strongSelf.recorderDataDisposable.set(nil)
+                        } else {
+                            let randomId = Int64.random(in: Int64.min ... Int64.max)
+                            
+                            let resource = LocalFileMediaResource(fileId: randomId)
+                            strongSelf.context.account.postbox.mediaBox.storeResourceData(resource.id, data: data.compressedData)
+                            
+                            let waveformBuffer: Data? = data.waveform
+                            
+                            let correlationId = Int64.random(in: 0 ..< Int64.max)
+                            var usedCorrelationId = false
+                            
+                            var shouldAnimateMessageTransition = strongSelf.chatDisplayNode.shouldAnimateMessageTransition
+                            if strongSelf.chatLocation.threadId == nil, let channel = strongSelf.presentationInterfaceState.renderedPeer?.peer as? TelegramChannel, channel.isMonoForum, let linkedMonoforumId = channel.linkedMonoforumId, let mainChannel = strongSelf.presentationInterfaceState.renderedPeer?.peers[linkedMonoforumId] as? TelegramChannel, mainChannel.hasPermission(.manageDirect) {
+                                shouldAnimateMessageTransition = false
+                            }
+                            
+                            if shouldAnimateMessageTransition, let textInputPanelNode = strongSelf.chatDisplayNode.textInputPanelNode, let micButton = textInputPanelNode.micButton {
+                                usedCorrelationId = true
+                                strongSelf.chatDisplayNode.messageTransitionNode.add(correlationId: correlationId, source: .audioMicInput(ChatMessageTransitionNodeImpl.Source.AudioMicInput(micButton: micButton)), initiated: {
+                                    guard let strongSelf = self else {
+                                        return
+                                    }
+                                    strongSelf.audioRecorder.set(.single(nil))
+                                })
+                            } else {
+                                strongSelf.audioRecorder.set(.single(nil))
+                            }
+                            
+                            strongSelf.chatDisplayNode.setupSendActionOnViewUpdate({
+                                if let strongSelf = self {
+                                    strongSelf.chatDisplayNode.collapseInput()
+                                    
+                                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                                        $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedSendMessageEffect(nil).withUpdatedPostSuggestionState(nil) }
+                                    })
+                                }
+                            }, usedCorrelationId ? correlationId : nil)
+                            
+                            var attributes: [MessageAttribute] = []
+                            if viewOnce {
+                                attributes.append(AutoremoveTimeoutMessageAttribute(timeout: viewOnceTimeout, countdownBeginTime: nil))
+                            }
+                            
+                            strongSelf.sendMessages([.message(text: "", attributes: attributes, inlineStickers: [:], mediaReference: .standalone(media: TelegramMediaFile(fileId: MediaId(namespace: Namespaces.Media.LocalFile, id: randomId), partialReference: nil, resource: resource, previewRepresentations: [], videoThumbnails: [], immediateThumbnailData: nil, mimeType: "audio/ogg", size: Int64(data.compressedData.count), attributes: [.Audio(isVoice: true, duration: Int(data.duration), title: nil, performer: nil, waveform: waveformBuffer)], alternativeRepresentations: [])), threadId: strongSelf.chatLocation.threadId, replyToMessageId: strongSelf.presentationInterfaceState.interfaceState.replyMessageSubject?.subjectModel, replyToStoryId: nil, localGroupingKey: nil, correlationId: correlationId, bubbleUpEmojiOrStickersets: [])])
+                            
+                            strongSelf.recorderFeedback?.tap()
+                            strongSelf.recorderFeedback = nil
+                            strongSelf.recorderDataDisposable.set(nil)
+                        }
+                    }
+                }))
+            }
+        } else if let videoRecorderValue = self.videoRecorderValue {
+            if case .send = updatedAction {
+                self.chatDisplayNode.updateRecordedMediaDeleted(false)
+                videoRecorderValue.sendVideoRecording()
+                self.recorderDataDisposable.set(nil)
+            } else {
+                if case .dismiss = updatedAction {
+                    self.chatDisplayNode.updateRecordedMediaDeleted(true)
+                    self.recorderDataDisposable.set(nil)
+                }
+                
+                switch updatedAction {
+                case .preview, .pause:
+                    if videoRecorderValue.stopVideoRecording() {
+                        self.recorderDataDisposable.set((videoRecorderValue.takenRecordedData()
+                        |> deliverOnMainQueue).startStrict(next: { [weak self] data in
+                            if let strongSelf = self, let data = data {
+                                if data.duration < 1.0 {
+                                    strongSelf.recorderFeedback?.error()
+                                    strongSelf.recorderFeedback = nil
+                                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                        $0.updatedInputTextPanelState { panelState in
+                                            return panelState.withUpdatedMediaRecordingState(nil)
+                                        }
+                                    })
+                                    strongSelf.recorderDataDisposable.set(nil)
+                                    strongSelf.videoRecorder.set(.single(nil))
+                                } else {
+                                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                        $0.updatedInterfaceState {
+                                            $0.withUpdatedMediaDraftState(.video(
+                                                ChatInterfaceMediaDraftState.Video(
+                                                    duration: data.duration,
+                                                    frames: data.frames,
+                                                    framesUpdateTimestamp: data.framesUpdateTimestamp,
+                                                    trimRange: data.trimRange
+                                                )
+                                            ))
+                                        }.updatedInputTextPanelState { panelState in
+                                            return panelState.withUpdatedMediaRecordingState(nil)
+                                        }
+                                    })
+                                    strongSelf.recorderFeedback = nil
+                                    strongSelf.updateDownButtonVisibility()
+                                }
+                            }
+                        }))
+                    }
+                default:
+                    self.recorderDataDisposable.set(nil)
+                    self.videoRecorder.set(.single(nil))
+                }
+            }
+        }
+    }
+    
+    func stopMediaRecorder(pause: Bool = false) {
+        if let audioRecorderValue = self.audioRecorderValue {
+            if let _ = self.presentationInterfaceState.inputTextPanelState.mediaRecordingState {
+                self.dismissMediaRecorder(pause ? .pause : .preview)
+            } else {
+                audioRecorderValue.stop()
+                self.audioRecorder.set(.single(nil))
+            }
+        } else if let _ = self.videoRecorderValue {
+            if let _ = self.presentationInterfaceState.inputTextPanelState.mediaRecordingState {
+                self.dismissMediaRecorder(pause ? .pause : .preview)
+            } else {
+                self.videoRecorder.set(.single(nil))
+            }
+        }
+    }
+    
+    func resumeMediaRecorder() {
+        self.recorderDataDisposable.set(nil)
+        
+        self.context.sharedContext.mediaManager.playlistControl(.playback(.pause), type: nil)
+        
+        if let videoRecorderValue = self.videoRecorderValue {
+            self.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                $0.updatedInputTextPanelState { panelState in
+                    let recordingStatus = videoRecorderValue.recordingStatus
+                    return panelState.withUpdatedMediaRecordingState(.video(status: .recording(InstantVideoControllerRecordingStatus(micLevel: recordingStatus.micLevel, duration: recordingStatus.duration)), isLocked: true))
+                }.updatedInterfaceState { $0.withUpdatedMediaDraftState(nil) }
+            })
+        } else {
+            let proceed = {
+                self.withAudioRecorder(resuming: true, { audioRecorder in
+                    audioRecorder.resume()
+                    
+                    self.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                        $0.updatedInputTextPanelState { panelState in
+                            return panelState.withUpdatedMediaRecordingState(.audio(recorder: audioRecorder, isLocked: true))
+                        }.updatedInterfaceState { $0.withUpdatedMediaDraftState(nil) }
+                    })
+                })
+            }
+            
+            let _ = (ApplicationSpecificNotice.getVoiceMessagesResumeTrimWarning(accountManager: self.context.sharedContext.accountManager)
+            |> deliverOnMainQueue).start(next: { [weak self] count in
+                guard let self else {
+                    return
+                }
+                if count > 0 {
+                    proceed()
+                    return
+                }
+                if let recordedMediaPreview = self.presentationInterfaceState.interfaceState.mediaDraftState, case let .audio(audio) = recordedMediaPreview, let trimRange = audio.trimRange, trimRange.lowerBound > 0.1 || trimRange.upperBound < audio.duration {
+                    self.present(
+                        textAlertController(
+                            context: self.context,
+                            title: self.presentationData.strings.Chat_TrimVoiceMessageToResume_Title,
+                            text: self.presentationData.strings.Chat_TrimVoiceMessageToResume_Text,
+                            actions: [
+                                TextAlertAction(type: .genericAction, title: self.presentationData.strings.Common_Cancel, action: {}),
+                                TextAlertAction(type: .defaultAction, title: self.presentationData.strings.Chat_TrimVoiceMessageToResume_Proceed, action: {
+                                    proceed()
+                                    let _ = ApplicationSpecificNotice.incrementVoiceMessagesResumeTrimWarning(accountManager: self.context.sharedContext.accountManager).start()
+                                })
+                            ]
+                        ), in: .window(.root)
+                    )
+                } else {
+                    proceed()
+                }
+            })
+        }
+    }
+    
+    func lockMediaRecorder() {
+        if self.presentationInterfaceState.inputTextPanelState.mediaRecordingState != nil {
+            self.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                return $0.updatedInputTextPanelState { panelState in
+                    return panelState.withUpdatedMediaRecordingState(panelState.mediaRecordingState?.withLocked(true))
+                }
+            })
+        }
+        
+        if let _ = self.audioRecorderValue {
+            self.maybePresentAudioPauseTooltip()
+        } else if let videoRecorderValue = self.videoRecorderValue {
+            videoRecorderValue.lockVideoRecording()
+        }
+    }
+    
+    func deleteMediaRecording() {
+        if let _ = self.audioRecorderValue {
+            self.audioRecorder.set(.single(nil))
+        } else if let _ = self.videoRecorderValue {
+            self.videoRecorder.set(.single(nil))
+        }
+        
+        self.recorderDataDisposable.set(nil)
+        self.chatDisplayNode.updateRecordedMediaDeleted(true)
+        self.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+            $0.updatedInterfaceState { $0.withUpdatedMediaDraftState(nil) }
+        })
+        self.updateDownButtonVisibility()
+        
+        self.dismissAllTooltips()
+    }
+    
+    private func maybePresentAudioPauseTooltip() {
+        let _ = (ApplicationSpecificNotice.getVoiceMessagesPauseSuggestion(accountManager: self.context.sharedContext.accountManager)
+        |> deliverOnMainQueue).startStandalone(next: { [weak self] pauseCounter in
+            guard let self else {
+                return
+            }
+            
+            if pauseCounter >= 3 {
+                return
+            } else {
+                Queue.mainQueue().after(0.3) {
+                    self.displayPauseTooltip(text: self.presentationData.strings.Chat_PauseVoiceMessageTooltip)
+                }
+                let _ = ApplicationSpecificNotice.incrementVoiceMessagesPauseSuggestion(accountManager: self.context.sharedContext.accountManager).startStandalone()
+            }
+        })
+    }
+    
+    private func displayPauseTooltip(text: String) {
+        guard let layout = self.validLayout else {
+            return
+        }
+        
+        self.dismissAllTooltips()
+        
+        let insets = layout.insets(options: [.input])
+        var screenWidth = layout.size.width
+        if layout.metrics.isTablet {
+            if layout.size.height == layout.deviceMetrics.screenSize.width {
+                screenWidth = layout.deviceMetrics.screenSize.height
+            } else {
+                screenWidth = layout.deviceMetrics.screenSize.width
+            }
+        }
+        
+        let location = CGRect(origin: CGPoint(x: screenWidth - layout.safeInsets.right - 50.0, y: layout.size.height - insets.bottom - 128.0), size: CGSize())
+        
+        let tooltipController = TooltipScreen(
+            account: self.context.account,
+            sharedContext: self.context.sharedContext,
+            text: .markdown(text: text),
+            balancedTextLayout: true,
+            constrainWidth: 240.0,
+            style: .customBlur(UIColor(rgb: 0x18181a), 0.0),
+            arrowStyle: .small,
+            icon: nil,
+            location: .point(location, .right),
+            displayDuration: .default,
+            inset: 8.0,
+            cornerRadius: 8.0,
+            shouldDismissOnTouch: { _, _ in
+                return .ignore
+            }
+        )
+        self.present(tooltipController, in: .window(.root))
+    }
+    
+    private func withAudioRecorder(resuming: Bool, _ f: (ManagedAudioRecorder) -> Void) {
+        if let audioRecorder = self.audioRecorderValue {
+            f(audioRecorder)
+        } else if let recordedMediaPreview = self.presentationInterfaceState.interfaceState.mediaDraftState, case let .audio(audio) = recordedMediaPreview {
+            self.requestAudioRecorder(beginWithTone: false, existingDraft: audio)
+            if let audioRecorder = self.audioRecorderValue {
+                f(audioRecorder)
+                
+                if !resuming {
+                    self.recorderDataDisposable.set(
+                        (audioRecorder.takenRecordedData()
+                         |> deliverOnMainQueue).startStrict(
+                            next: { [weak self] data in
+                                if let strongSelf = self, let data = data {
+                                    let audioWaveform = audio.waveform
+                                   
+                                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                        $0.updatedInterfaceState {
+                                            $0.withUpdatedMediaDraftState(.audio(
+                                                ChatInterfaceMediaDraftState.Audio(
+                                                    resource: audio.resource,
+                                                    fileSize: Int32(data.compressedData.count),
+                                                    duration: data.duration,
+                                                    waveform: audioWaveform,
+                                                    trimRange: data.trimRange,
+                                                    resumeData: data.resumeData
+                                                )
+                                            ))
+                                        }.updatedInputTextPanelState { panelState in
+                                            return panelState.withUpdatedMediaRecordingState(nil)
+                                        }
+                                    })
+                                    strongSelf.updateDownButtonVisibility()
+                                }
+                            })
+                    )
+                }
+            }
+        }
+    }
+    
+    func updateTrimRange(start: Double, end: Double, updatedEnd: Bool, apply: Bool) {
+        if let videoRecorder = self.videoRecorderValue {
+            videoRecorder.updateTrimRange(start: start, end: end, updatedEnd: updatedEnd, apply: apply)
+        } else {
+            self.withAudioRecorder(resuming: false, { audioRecorder in
+                audioRecorder.updateTrimRange(start: start, end: end, updatedEnd: updatedEnd, apply: apply)
+            })
+        }
+    }
+    
+    func sendMediaRecording(
+        silentPosting: Bool? = nil,
+        scheduleTime: Int32? = nil,
+        repeatPeriod: Int32? = nil,
+        viewOnce: Bool = false,
+        messageEffect: ChatSendMessageEffect? = nil,
+        postpone: Bool = false
+    ) {
+        self.chatDisplayNode.updateRecordedMediaDeleted(false)
+        
+        guard let recordedMediaPreview = self.presentationInterfaceState.interfaceState.mediaDraftState else {
+            return
+        }
+        
+        switch recordedMediaPreview {
+        case let .audio(audio):
+            self.audioRecorder.set(.single(nil))
+            
+            var isScheduledMessages = false
+            if case .scheduledMessages = self.presentationInterfaceState.subject {
+                isScheduledMessages = true
+            }
+            
+            if let _ = self.presentationInterfaceState.slowmodeState, !isScheduledMessages {
+                if let rect = self.chatDisplayNode.frameForInputActionButton() {
+                    self.interfaceInteraction?.displaySlowmodeTooltip(self.chatDisplayNode.view, rect)
+                }
+                return
+            }
+            
+            self.chatDisplayNode.setupSendActionOnViewUpdate({ [weak self] in
+                if let strongSelf = self {
+                    strongSelf.chatDisplayNode.collapseInput()
+                    
+                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                        $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedMediaDraftState(nil).withUpdatedSendMessageEffect(nil).withUpdatedPostSuggestionState(nil) }
+                    })
+
+                    strongSelf.updateDownButtonVisibility()
+                }
+            }, nil)
+            
+            var attributes: [MessageAttribute] = []
+            if viewOnce {
+                attributes.append(AutoremoveTimeoutMessageAttribute(timeout: viewOnceTimeout, countdownBeginTime: nil))
+            }
+            if let messageEffect {
+                attributes.append(EffectMessageAttribute(id: messageEffect.id))
+            }
+            
+            let resource: TelegramMediaResource
+            var waveform = audio.waveform
+            var finalDuration: Int = Int(audio.duration)
+            if let trimRange = audio.trimRange, trimRange.lowerBound > 0.0 || trimRange.upperBound < Double(audio.duration)  {
+                let randomId = Int64.random(in: Int64.min ... Int64.max)
+                let tempPath = NSTemporaryDirectory() + "\(Int64.random(in: 0 ..< .max)).ogg"
+                resource = LocalFileAudioMediaResource(randomId: randomId, path: tempPath, trimRange: trimRange)
+                self.context.account.postbox.mediaBox.moveResourceData(audio.resource.id, toTempPath: tempPath)
+                waveform = waveform.subwaveform(from: trimRange.lowerBound / Double(audio.duration), to: trimRange.upperBound / Double(audio.duration))
+                finalDuration = Int(trimRange.upperBound - trimRange.lowerBound)
+            } else {
+                resource = audio.resource
+            }
+            
+            let waveformBuffer = waveform.makeBitstream()
+            
+            let messages: [EnqueueMessage] = [.message(text: "", attributes: attributes, inlineStickers: [:], mediaReference: .standalone(media: TelegramMediaFile(fileId: MediaId(namespace: Namespaces.Media.LocalFile, id: Int64.random(in: Int64.min ... Int64.max)), partialReference: nil, resource: resource, previewRepresentations: [], videoThumbnails: [], immediateThumbnailData: nil, mimeType: "audio/ogg", size: Int64(audio.fileSize), attributes: [.Audio(isVoice: true, duration: finalDuration, title: nil, performer: nil, waveform: waveformBuffer)], alternativeRepresentations: [])), threadId: self.chatLocation.threadId, replyToMessageId: self.presentationInterfaceState.interfaceState.replyMessageSubject?.subjectModel, replyToStoryId: nil, localGroupingKey: nil, correlationId: nil, bubbleUpEmojiOrStickersets: [])]
+            
+            let transformedMessages: [EnqueueMessage]
+            if let silentPosting = silentPosting {
+                transformedMessages = self.transformEnqueueMessages(messages, silentPosting: silentPosting, postpone: postpone)
+            } else if let scheduleTime = scheduleTime {
+                transformedMessages = self.transformEnqueueMessages(messages, silentPosting: false, scheduleTime: scheduleTime, repeatPeriod: repeatPeriod, postpone: postpone)
+            } else {
+                transformedMessages = self.transformEnqueueMessages(messages)
+            }
+            
+            guard let peerId = self.chatLocation.peerId else {
+                return
+            }
+            
+            let _ = (enqueueMessages(account: self.context.account, peerId: peerId, messages: transformedMessages)
+            |> deliverOnMainQueue).startStandalone(next: { [weak self] _ in
+                if let strongSelf = self, strongSelf.presentationInterfaceState.subject != .scheduledMessages {
+                    strongSelf.chatDisplayNode.historyNode.scrollToEndOfHistory()
+                }
+            })
+            
+            donateSendMessageIntent(account: self.context.account, sharedContext: self.context.sharedContext, intentContext: .chat, peerIds: [peerId])
+        case .video:
+            self.videoRecorderValue?.sendVideoRecording(silentPosting: silentPosting, scheduleTime: scheduleTime, messageEffect: messageEffect)
+        }
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerNavigateToMessage.swift

@@ -0,0 +1,586 @@
+import Foundation
+import UIKit
+import Postbox
+import TelegramCore
+import SwiftSignalKit
+import Display
+import ChatPresentationInterfaceState
+import AccountContext
+import ChatControllerInteraction
+import OverlayStatusController
+import TelegramPresentationData
+import PresentationDataUtils
+import UndoUI
+
+extension ChatControllerImpl {
+    func navigateToMessage(
+        fromId: MessageId,
+        id: MessageId,
+        params: NavigateToMessageParams
+    ) {
+        var id = id
+        if case let .replyThread(message) = self.chatLocation, let effectiveMessageId = message.effectiveMessageId {
+            if let channelMessageId = message.channelMessageId, id == channelMessageId {
+                id = effectiveMessageId
+            }
+        }
+        
+        let continueNavigation: () -> Void = { [weak self] in
+            guard let self else {
+                return
+            }
+            self.navigateToMessage(from: fromId, to: .id(id, params), forceInCurrentChat: fromId.peerId == id.peerId && !params.forceNew, forceNew: params.forceNew, progress: params.progress)
+        }
+        
+        let _ = (self.context.engine.data.get(
+            TelegramEngine.EngineData.Item.Peer.Peer(id: id.peerId)
+        )
+        |> deliverOnMainQueue).startStandalone(next: { [weak self] toPeer in
+            guard let self else {
+                return
+            }
+            
+            if params.quote != nil {
+                if let toPeer {
+                    switch toPeer {
+                    case let .channel(channel):
+                        if channel.username == nil && channel.usernames.isEmpty {
+                            switch channel.participationStatus {
+                            case .kicked, .left:
+                                self.controllerInteraction?.attemptedNavigationToPrivateQuote(toPeer._asPeer())
+                                return
+                            case .member:
+                                break
+                            }
+                        }
+                    default:
+                        break
+                    }
+                } else {
+                    self.controllerInteraction?.attemptedNavigationToPrivateQuote(nil)
+                    return
+                }
+            }
+            
+            continueNavigation()
+        })
+    }
+    
+    func navigateToMessage(
+        from fromId: MessageId?,
+        to messageLocation: NavigateToMessageLocation,
+        scrollPosition: ListViewScrollPosition = .center(.bottom),
+        rememberInStack: Bool = true,
+        forceInCurrentChat: Bool = false,
+        forceNew: Bool = false,
+        dropStack: Bool = false,
+        animated: Bool = true,
+        completion: (() -> Void)? = nil,
+        customPresentProgress: ((ViewController, Any?) -> Void)? = nil,
+        progress: Promise<Bool>? = nil,
+        statusSubject: ChatLoadingMessageSubject = .generic
+    ) {
+        if !self.isNodeLoaded {
+            completion?()
+            return
+        }
+        var fromIndex: MessageIndex?
+        
+        var fromMessage: Message?
+        if let fromId = fromId, let message = self.chatDisplayNode.historyNode.messageInCurrentHistoryView(fromId) {
+            fromIndex = message.index
+            fromMessage = message
+        } else {
+            if let message = self.chatDisplayNode.historyNode.anchorMessageInCurrentHistoryView() {
+                fromIndex = message.index
+            }
+        }
+        
+        var isScheduledMessages = false
+        var isPinnedMessages = false
+        if case .scheduledMessages = self.presentationInterfaceState.subject {
+            isScheduledMessages = true
+        } else if case .pinnedMessages = self.presentationInterfaceState.subject {
+            isPinnedMessages = true
+        }
+        
+        var forceInCurrentChat = forceInCurrentChat
+        if case let .peer(peerId) = self.chatLocation, messageLocation.peerId == peerId, !isPinnedMessages, !isScheduledMessages {
+            forceInCurrentChat = true
+        }
+        if case .customChatContents = self.chatLocation, !forceNew {
+            forceInCurrentChat = true
+        }
+        
+        if isPinnedMessages || forceNew, let messageId = messageLocation.messageId {
+            let peerSignal: Signal<EnginePeer?, NoError>
+            if forceNew, let fromMessage, let peer = fromMessage.peers[fromMessage.id.peerId] {
+                peerSignal = .single(EnginePeer(peer))
+            } else {
+                peerSignal = self.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: messageId.peerId))
+            }
+            let _ = (combineLatest(
+                peerSignal,
+                self.context.engine.messages.getMessagesLoadIfNecessary([messageId], strategy: forceNew ? .cloud(skipLocal: false) : .local)
+                |> `catch` { _ in
+                    return .single(.result([]))
+                }
+                |> mapToSignal { result -> Signal<[Message], NoError> in
+                    guard case let .result(result) = result else {
+                        return .complete()
+                    }
+                    return .single(result)
+                }
+            )
+            |> deliverOnMainQueue).startStandalone(next: { [weak self] peer, messages in
+                guard let self, let peer = peer else {
+                    return
+                }
+                guard let navigationController = self.effectiveNavigationController else {
+                    return
+                }
+                
+                self.dismiss()
+                
+                let navigateToLocation: NavigateToChatControllerParams.Location
+                if let message = messages.first, let threadId = message.threadId, let channel = message.peers[message.id.peerId] as? TelegramChannel, channel.isForumOrMonoForum {
+                    navigateToLocation = .replyThread(ChatReplyThreadMessage(peerId: peer.id, threadId: threadId, channelMessageId: nil, isChannelPost: false, isForumPost: true, isMonoforumPost: false,maxMessage: nil, maxReadIncomingMessageId: nil, maxReadOutgoingMessageId: nil, unreadCount: 0, initialFilledHoles: IndexSet(), initialAnchor: .automatic, isNotAvailable: false))
+                } else {
+                    navigateToLocation = .peer(peer)
+                }
+                self.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: self.context, chatLocation: navigateToLocation, subject: .message(id: .id(messageId), highlight: ChatControllerSubject.MessageHighlight(quote: nil), timecode: nil, setupReply: false), keepStack: .always))
+                
+                completion?()
+            })
+        } else if case let .peer(peerId) = self.chatLocation, let messageId = messageLocation.messageId, (messageId.peerId != peerId && !forceInCurrentChat) || (isScheduledMessages && messageId.id != 0 && !Namespaces.Message.allNonRegular.contains(messageId.namespace)) {
+            let _ = (self.context.engine.data.get(
+                TelegramEngine.EngineData.Item.Peer.Peer(id: messageId.peerId),
+                TelegramEngine.EngineData.Item.Messages.Message(id: messageId)
+            )
+            |> deliverOnMainQueue).startStandalone(next: { [weak self] peer, message in
+                guard let self, let peer = peer else {
+                    return
+                }
+                
+                var quote: ChatControllerSubject.MessageHighlight.Quote?
+                if case let .id(_, params) = messageLocation {
+                    quote = params.quote.flatMap { quote in ChatControllerSubject.MessageHighlight.Quote(string: quote.string, offset: quote.offset) }
+                }
+                var progressValue: Promise<Bool>?
+                if let value = progress {
+                    progressValue = value
+                } else if case let .id(_, params) = messageLocation {
+                    progressValue = params.progress
+                }
+                self.loadingMessage.set(.single(statusSubject) |> delay(0.1, queue: .mainQueue()))
+                
+                var chatLocation: NavigateToChatControllerParams.Location = .peer(peer)
+                var preloadChatLocation: ChatLocation = .peer(id: peer.id)
+                var displayMessageNotFoundToast = false
+                if case let .channel(channel) = peer, channel.isForumOrMonoForum {
+                    if let message = message, let threadId = message.threadId {
+                        let replyThreadMessage = ChatReplyThreadMessage(peerId: peer.id, threadId: threadId, channelMessageId: nil, isChannelPost: false, isForumPost: true, isMonoforumPost: false, maxMessage: nil, maxReadIncomingMessageId: nil, maxReadOutgoingMessageId: nil, unreadCount: 0, initialFilledHoles: IndexSet(), initialAnchor: .automatic, isNotAvailable: false)
+                        chatLocation = .replyThread(replyThreadMessage)
+                        preloadChatLocation = .replyThread(message: replyThreadMessage)
+                    } else {
+                        displayMessageNotFoundToast = true
+                    }
+                }
+                
+                let searchLocation: ChatHistoryInitialSearchLocation
+                switch messageLocation {
+                case let .id(id, _):
+                    if case let .replyThread(message) = chatLocation, id == message.effectiveMessageId {
+                        searchLocation = .index(.absoluteLowerBound())
+                    } else {
+                        searchLocation = .id(id)
+                    }
+                case let .index(index):
+                    searchLocation = .index(index)
+                case .upperBound:
+                    searchLocation = .index(MessageIndex.upperBound(peerId: chatLocation.peerId))
+                }
+                var historyView: Signal<ChatHistoryViewUpdate, NoError>
+                
+                let subject: ChatControllerSubject = .message(id: .id(messageId), highlight: ChatControllerSubject.MessageHighlight(quote: quote), timecode: nil, setupReply: false)
+                
+                historyView = preloadedChatHistoryViewForLocation(ChatHistoryLocationInput(content: .InitialSearch(subject: MessageHistoryInitialSearchSubject(location: searchLocation), count: 50, highlight: true, setupReply: false), id: 0), context: self.context, chatLocation: preloadChatLocation, subject: subject, chatLocationContextHolder: Atomic<ChatLocationContextHolder?>(value: nil), fixedCombinedReadStates: nil, tag: nil, additionalData: [])
+                
+                var signal: Signal<(MessageIndex?, Bool), NoError>
+                signal = historyView
+                |> mapToSignal { historyView -> Signal<(MessageIndex?, Bool), NoError> in
+                    switch historyView {
+                    case .Loading:
+                        return .single((nil, true))
+                    case let .HistoryView(view, _, _, _, _, _, _):
+                        for entry in view.entries {
+                            if entry.message.id == messageLocation.messageId {
+                                return .single((entry.message.index, false))
+                            }
+                        }
+                        if case let .index(index) = searchLocation {
+                            return .single((index, false))
+                        }
+                        return .single((nil, false))
+                    }
+                }
+                |> take(until: { index in
+                    return SignalTakeAction(passthrough: true, complete: !index.1)
+                })
+                
+                /*#if DEBUG
+                signal = .single((nil, true)) |> then(signal |> delay(2.0, queue: .mainQueue()))
+                #endif*/
+                
+                var cancelImpl: (() -> Void)?
+                let presentationData = self.presentationData
+                let displayTime = CACurrentMediaTime()
+                let progressSignal = Signal<Never, NoError> { [weak self] subscriber in
+                    if let progressValue {
+                        progressValue.set(.single(true))
+                        return ActionDisposable {
+                            Queue.mainQueue().async() {
+                                progressValue.set(.single(false))
+                            }
+                        }
+                    } else if case .generic = statusSubject {
+                        let controller = OverlayStatusController(theme: presentationData.theme, type: .loading(cancelled: {
+                            if CACurrentMediaTime() - displayTime > 1.5 {
+                                cancelImpl?()
+                            }
+                        }))
+                        if let customPresentProgress = customPresentProgress {
+                            customPresentProgress(controller, nil)
+                        } else {
+                            self?.present(controller, in: .window(.root))
+                        }
+                        return ActionDisposable { [weak controller] in
+                            Queue.mainQueue().async() {
+                                controller?.dismiss()
+                            }
+                        }
+                    } else {
+                        return EmptyDisposable
+                    }
+                }
+                |> runOn(Queue.mainQueue())
+                |> delay(progressValue == nil ? 0.05 : 0.0, queue: Queue.mainQueue())
+                let progressDisposable = MetaDisposable()
+                var progressStarted = false
+                self.messageIndexDisposable.set((signal
+                |> afterDisposed {
+                    Queue.mainQueue().async {
+                        progressDisposable.dispose()
+                    }
+                }
+                |> deliverOnMainQueue).startStrict(next: { [weak self] index in
+                    guard let self else {
+                        return
+                    }
+                    
+                    if let index = index.0 {
+                        let _ = index
+                        //strongSelf.chatDisplayNode.historyNode.scrollToMessage(from: scrollFromIndex, to: index, animated: animated, quote: quote, scrollPosition: scrollPosition)
+                    } else if index.1 {
+                        if !progressStarted {
+                            progressStarted = true
+                            progressDisposable.set(progressSignal.start())
+                        }
+                        return
+                    }
+                    
+                    if let navigationController = self.effectiveNavigationController {
+                        let context = self.context
+                        self.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: self.context, chatLocation: chatLocation, subject: subject, keepStack: .always, chatListCompletion: { chatListController in
+                            if displayMessageNotFoundToast {
+                                let presentationData = context.sharedContext.currentPresentationData.with({ $0 })
+                                chatListController.present(UndoOverlayController(presentationData: presentationData, content: .info(title: nil, text: presentationData.strings.Conversation_MessageDoesntExist, timeout: nil, customUndoText: nil), elevatedLayout: false, animateInAsReplacement: false, action: { _ in
+                                    return true
+                                }), in: .current)
+                            }
+                        }))
+                    }
+                }, completed: { [weak self] in
+                    if let strongSelf = self {
+                        strongSelf.loadingMessage.set(.single(nil))
+                    }
+                    completion?()
+                }))
+                cancelImpl = { [weak self] in
+                    if let strongSelf = self {
+                        strongSelf.loadingMessage.set(.single(nil))
+                        strongSelf.messageIndexDisposable.set(nil)
+                    }
+                }
+                
+                completion?()
+            })
+        } else if forceInCurrentChat {
+            if let _ = fromId, let fromIndex = fromIndex, rememberInStack {
+                self.contentData?.historyNavigationStack.add(fromIndex)
+            }
+            
+            let scrollFromIndex: MessageIndex?
+            if let fromIndex = fromIndex {
+                scrollFromIndex = fromIndex
+            } else if let message = self.chatDisplayNode.historyNode.lastVisbleMesssage() {
+                scrollFromIndex = message.index
+            } else {
+                scrollFromIndex = nil
+            }
+            
+            if let scrollFromIndex = scrollFromIndex {
+                if let messageId = messageLocation.messageId, let message = self.chatDisplayNode.historyNode.messageInCurrentHistoryView(messageId) {
+                    self.loadingMessage.set(.single(nil))
+                    self.messageIndexDisposable.set(nil)
+                    
+                    var delayCompletion = true
+                    if self.chatDisplayNode.historyNode.isMessageVisible(id: messageId) {
+                        delayCompletion = false
+                    }
+                    
+                    var quote: (string: String, offset: Int?)?
+                    var todoTaskId: Int32?
+                    var setupReply = false
+                    if case let .id(_, params) = messageLocation {
+                        quote = params.quote.flatMap { quote in (string: quote.string, offset: quote.offset) }
+                        setupReply = params.setupReply
+                        todoTaskId = params.todoTaskId
+                    }
+
+                    self.chatDisplayNode.historyNode.scrollToMessage(from: scrollFromIndex, to: message.index, animated: animated, quote: quote, todoTaskId: todoTaskId, scrollPosition: scrollPosition, setupReply: setupReply)
+                    
+                    if delayCompletion {
+                        Queue.mainQueue().after(0.25, {
+                            completion?()
+                        })
+                    } else {
+                        Queue.mainQueue().justDispatch({
+                            completion?()
+                        })
+                    }
+                    
+                    if case let .id(_, params) = messageLocation, let timecode = params.timestamp {
+                        let _ = self.controllerInteraction?.openMessage(message, OpenMessageParams(mode: .timecode(timecode)))
+                    }
+                } else if case let .index(index) = messageLocation, index.id.id == 0, index.timestamp > 0, case .scheduledMessages = self.presentationInterfaceState.subject {
+                    self.chatDisplayNode.historyNode.scrollToMessage(from: scrollFromIndex, to: index, animated: animated, scrollPosition: scrollPosition)
+                } else {
+                    var setupReply = false
+                    var quote: (string: String, offset: Int?)?
+                    if case let .id(messageId, params) = messageLocation {
+                        if params.timestamp != nil {
+                            self.scheduledScrollToMessageId = (messageId, params)
+                        }
+                        quote = params.quote.flatMap { ($0.string, $0.offset) }
+                        setupReply = params.setupReply
+                    }
+                    var progress: Promise<Bool>?
+                    if case let .id(_, params) = messageLocation {
+                        progress = params.progress
+                    }
+                    self.loadingMessage.set(.single(statusSubject) |> delay(0.1, queue: .mainQueue()))
+                    
+                    let searchLocation: ChatHistoryInitialSearchLocation
+                    switch messageLocation {
+                    case let .id(id, _):
+                        if case let .replyThread(message) = self.chatLocation, id == message.effectiveMessageId {
+                            searchLocation = .index(.absoluteLowerBound())
+                        } else {
+                            searchLocation = .id(id)
+                        }
+                    case let .index(index):
+                        searchLocation = .index(index)
+                    case .upperBound:
+                        if let peerId = self.chatLocation.peerId {
+                            searchLocation = .index(MessageIndex.upperBound(peerId: peerId))
+                        } else {
+                            searchLocation = .index(.absoluteUpperBound())
+                        }
+                    }
+                    var historyView: Signal<ChatHistoryViewUpdate, NoError>
+                    historyView = preloadedChatHistoryViewForLocation(ChatHistoryLocationInput(content: .InitialSearch(subject: MessageHistoryInitialSearchSubject(location: searchLocation), count: 50, highlight: true, setupReply: setupReply), id: 0), context: self.context, chatLocation: self.chatLocation, subject: self.subject, chatLocationContextHolder: self.chatLocationContextHolder, fixedCombinedReadStates: nil, tag: nil, additionalData: [])
+                    
+                    var signal: Signal<(MessageIndex?, Bool), NoError>
+                    signal = historyView
+                    |> mapToSignal { historyView -> Signal<(MessageIndex?, Bool), NoError> in
+                        switch historyView {
+                            case .Loading:
+                                return .single((nil, true))
+                            case let .HistoryView(view, _, _, _, _, _, _):
+                                for entry in view.entries {
+                                    if entry.message.id == messageLocation.messageId {
+                                        return .single((entry.message.index, false))
+                                    }
+                                }
+                                if case let .index(index) = searchLocation {
+                                    return .single((index, false))
+                                }
+                                return .single((nil, false))
+                        }
+                    }
+                    |> take(until: { index in
+                        return SignalTakeAction(passthrough: true, complete: !index.1)
+                    })
+                    
+                    /*#if DEBUG
+                    signal = .single((nil, true)) |> then(signal |> delay(2.0, queue: .mainQueue()))
+                    #endif*/
+                    
+                    var cancelImpl: (() -> Void)?
+                    let presentationData = self.presentationData
+                    let displayTime = CACurrentMediaTime()
+                    let progressSignal = Signal<Never, NoError> { [weak self] subscriber in
+                        if let progress {
+                            progress.set(.single(true))
+                            return ActionDisposable {
+                                Queue.mainQueue().async() {
+                                    progress.set(.single(false))
+                                }
+                            }
+                        } else if case .generic = statusSubject {
+                            let controller = OverlayStatusController(theme: presentationData.theme, type: .loading(cancelled: {
+                                if CACurrentMediaTime() - displayTime > 1.5 {
+                                    cancelImpl?()
+                                }
+                            }))
+                            if let customPresentProgress = customPresentProgress {
+                                customPresentProgress(controller, nil)
+                            } else {
+                                self?.present(controller, in: .window(.root))
+                            }
+                            return ActionDisposable { [weak controller] in
+                                Queue.mainQueue().async() {
+                                    controller?.dismiss()
+                                }
+                            }
+                        } else {
+                            return EmptyDisposable
+                        }
+                    }
+                    |> runOn(Queue.mainQueue())
+                    |> delay(0.05, queue: Queue.mainQueue())
+                    let progressDisposable = MetaDisposable()
+                    var progressStarted = false
+                    self.messageIndexDisposable.set((signal
+                    |> afterDisposed {
+                        Queue.mainQueue().async {
+                            progressDisposable.dispose()
+                        }
+                    }
+                    |> deliverOnMainQueue).startStrict(next: { [weak self] index in
+                        if let strongSelf = self, let index = index.0 {
+                            strongSelf.chatDisplayNode.historyNode.scrollToMessage(from: scrollFromIndex, to: index, animated: animated, quote: quote, scrollPosition: scrollPosition, setupReply: setupReply)
+                        } else if index.1 {
+                            if !progressStarted {
+                                progressStarted = true
+                                progressDisposable.set(progressSignal.start())
+                            }
+                        } else if let strongSelf = self {
+                            strongSelf.controllerInteraction?.displayUndo(.info(title: nil, text: strongSelf.presentationData.strings.Conversation_MessageDoesntExist, timeout: nil, customUndoText: nil))
+                        }
+                    }, completed: { [weak self] in
+                        if let strongSelf = self {
+                            strongSelf.loadingMessage.set(.single(nil))
+                        }
+                        completion?()
+                    }))
+                    cancelImpl = { [weak self] in
+                        if let strongSelf = self {
+                            strongSelf.loadingMessage.set(.single(nil))
+                            strongSelf.messageIndexDisposable.set(nil)
+                        }
+                    }
+                }
+            } else {
+                completion?()
+            }
+        } else {
+            if let fromIndex = fromIndex {
+                let searchLocation: ChatHistoryInitialSearchLocation
+                switch messageLocation {
+                    case let .id(id, _):
+                        searchLocation = .id(id)
+                    case let .index(index):
+                        searchLocation = .index(index)
+                    case .upperBound:
+                        return
+                }
+                if let _ = fromId, rememberInStack {
+                    self.contentData?.historyNavigationStack.add(fromIndex)
+                }
+                self.loadingMessage.set(.single(statusSubject) |> delay(0.1, queue: .mainQueue()))
+                
+                var quote: ChatControllerSubject.MessageHighlight.Quote?
+                var todoTaskId: Int32?
+                var setupReply = false
+                if case let .id(_, params) = messageLocation {
+                    quote = params.quote.flatMap { quote in ChatControllerSubject.MessageHighlight.Quote(string: quote.string, offset: quote.offset) }
+                    todoTaskId = params.todoTaskId
+                    setupReply = params.setupReply
+                }
+                
+                let historyView = preloadedChatHistoryViewForLocation(ChatHistoryLocationInput(content: .InitialSearch(subject: MessageHistoryInitialSearchSubject(location: searchLocation, quote: quote.flatMap { quote in MessageHistoryInitialSearchSubject.Quote(string: quote.string, offset: quote.offset) }, todoTaskId: todoTaskId), count: 50, highlight: true, setupReply: setupReply), id: 0), context: self.context, chatLocation: self.chatLocation, subject: self.subject, chatLocationContextHolder: self.chatLocationContextHolder, fixedCombinedReadStates: nil, tag: nil, additionalData: [])
+                var signal: Signal<MessageIndex?, NoError>
+                signal = historyView
+                |> mapToSignal { historyView -> Signal<MessageIndex?, NoError> in
+                    switch historyView {
+                        case .Loading:
+                            return .complete()
+                        case let .HistoryView(view, _, _, _, _, _, _):
+                            for entry in view.entries {
+                                if entry.message.id == messageLocation.messageId {
+                                    return .single(entry.message.index)
+                                }
+                            }
+                            return .single(nil)
+                    }
+                }
+                |> take(1)
+                
+                self.messageIndexDisposable.set((signal |> deliverOnMainQueue).startStrict(next: { [weak self] index in
+                    if let strongSelf = self {
+                        if let index = index {
+                            strongSelf.chatDisplayNode.historyNode.scrollToMessage(from: fromIndex, to: index, animated: animated, scrollPosition: scrollPosition)
+                            completion?()
+                        } else {
+                            let _ = (strongSelf.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: messageLocation.peerId))
+                            |> deliverOnMainQueue).startStandalone(next: { peer in
+                                guard let strongSelf = self, let peer = peer else {
+                                    return
+                                }
+                                
+                                if let navigationController = strongSelf.effectiveNavigationController {
+                                    var quote: ChatControllerSubject.MessageHighlight.Quote?
+                                    var setupReply = false
+                                    if case let .id(_, params) = messageLocation {
+                                        quote = params.quote.flatMap { quote in ChatControllerSubject.MessageHighlight.Quote(string: quote.string, offset: quote.offset) }
+                                        setupReply = params.setupReply
+                                    }
+                                    
+                                    strongSelf.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: strongSelf.context, chatLocation: .peer(peer), subject: messageLocation.messageId.flatMap { .message(id: .id($0), highlight: ChatControllerSubject.MessageHighlight(quote: quote), timecode: nil, setupReply: setupReply) }, keepStack: .always))
+                                }
+                            })
+                            completion?()
+                        }
+                    }
+                }, completed: { [weak self] in
+                    if let strongSelf = self {
+                        strongSelf.loadingMessage.set(.single(nil))
+                    }
+                }))
+            } else {
+                let _ = (self.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: messageLocation.peerId))
+                |> deliverOnMainQueue).startStandalone(next: { [weak self] peer in
+                    guard let self, let peer = peer else {
+                        return
+                    }
+                    if let navigationController = self.effectiveNavigationController {
+                        self.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: self.context, chatLocation: .peer(peer), subject: messageLocation.messageId.flatMap { .message(id: .id($0), highlight: ChatControllerSubject.MessageHighlight(quote: nil), timecode: nil, setupReply: false) }))
+                    }
+                    completion?()
+                })
+            }
+        }
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerNavigationButtonAction.swift

@@ -0,0 +1,705 @@
+import Foundation
+import UIKit
+import Postbox
+import SwiftSignalKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SafariServices
+import MobileCoreServices
+import Intents
+import LegacyComponents
+import TelegramPresentationData
+import TelegramUIPreferences
+import DeviceAccess
+import TextFormat
+import TelegramBaseController
+import AccountContext
+import TelegramStringFormatting
+import OverlayStatusController
+import DeviceLocationManager
+import ShareController
+import UrlEscaping
+import ContextUI
+import ComposePollUI
+import AlertUI
+import PresentationDataUtils
+import UndoUI
+import TelegramCallsUI
+import TelegramNotices
+import GameUI
+import ScreenCaptureDetection
+import GalleryUI
+import OpenInExternalAppUI
+import LegacyUI
+import InstantPageUI
+import LocationUI
+import BotPaymentsUI
+import DeleteChatPeerActionSheetItem
+import HashtagSearchUI
+import LegacyMediaPickerUI
+import Emoji
+import PeerAvatarGalleryUI
+import PeerInfoUI
+import RaiseToListen
+import UrlHandling
+import AvatarNode
+import AppBundle
+import LocalizedPeerData
+import PhoneNumberFormat
+import SettingsUI
+import UrlWhitelist
+import TelegramIntents
+import TooltipUI
+import StatisticsUI
+import MediaResources
+import GalleryData
+import ChatInterfaceState
+import InviteLinksUI
+import Markdown
+import TelegramPermissionsUI
+import Speak
+import TranslateUI
+import UniversalMediaPlayer
+import WallpaperBackgroundNode
+import ChatListUI
+import CalendarMessageScreen
+import ReactionSelectionNode
+import ReactionListContextMenuContent
+import AttachmentUI
+import AttachmentTextInputPanelNode
+import MediaPickerUI
+import ChatPresentationInterfaceState
+import Pasteboard
+import ChatSendMessageActionUI
+import ChatTextLinkEditUI
+import WebUI
+import PremiumUI
+import ImageTransparency
+import StickerPackPreviewUI
+import TextNodeWithEntities
+import EntityKeyboard
+import ChatTitleView
+import EmojiStatusComponent
+import ChatTimerScreen
+import MediaPasteboardUI
+import ChatListHeaderComponent
+import ChatControllerInteraction
+import FeaturedStickersScreen
+import ChatEntityKeyboardInputNode
+import StorageUsageScreen
+import AvatarEditorScreen
+import ChatScheduleTimeController
+import ICloudResources
+import StoryContainerScreen
+import MoreHeaderButton
+import VolumeButtons
+import ChatAvatarNavigationNode
+import ChatContextQuery
+import PeerReportScreen
+import PeerSelectionController
+import SaveToCameraRoll
+import ChatMessageDateAndStatusNode
+import ReplyAccessoryPanelNode
+import TextSelectionNode
+import ChatMessagePollBubbleContentNode
+import ChatMessageItem
+import ChatMessageItemImpl
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatMessageAnimatedStickerItemNode
+import ChatMessageBubbleItemNode
+import ChatNavigationButton
+import WebsiteType
+import PeerInfoScreen
+import MediaEditorScreen
+import WallpaperGalleryScreen
+import WallpaperGridScreen
+import VideoMessageCameraScreen
+import TopMessageReactions
+import AudioWaveform
+import PeerNameColorScreen
+import ChatEmptyNode
+import ChatMediaInputStickerGridItem
+import AdsInfoScreen
+
+extension ChatControllerImpl {
+    func navigationButtonAction(_ action: ChatNavigationButtonAction) {
+        switch action {
+        case .spacer, .toggleInfoPanel:
+            break
+        case .cancelMessageSelection:
+            self.updateChatPresentationInterfaceState(animated: true, interactive: true, { $0.updatedInterfaceState { $0.withoutSelectionState() } })
+        case .clearHistory:
+            guard !self.presentAccountFrozenInfoIfNeeded() else {
+                return
+            }
+            
+            if case let .peer(peerId) = self.chatLocation {
+                let beginClear: (InteractiveHistoryClearingType) -> Void = { [weak self] type in
+                    self?.beginClearHistory(type: type)
+                }
+                
+                let context = self.context
+                let _ = (self.context.engine.data.get(
+                    TelegramEngine.EngineData.Item.Peer.ParticipantCount(id: peerId),
+                    TelegramEngine.EngineData.Item.Peer.CanDeleteHistory(id: peerId)
+                )
+                |> map { participantCount, canDeleteHistory -> (isLargeGroupOrChannel: Bool, canClearChannel: Bool) in
+                    if let participantCount = participantCount {
+                        return (participantCount > 1000, canDeleteHistory)
+                    } else {
+                        return (false, false)
+                    }
+                }
+                |> deliverOnMainQueue).startStandalone(next: { [weak self] parameters in
+                    guard let strongSelf = self else {
+                        return
+                    }
+                    
+                    let (isLargeGroupOrChannel, canClearChannel) = parameters
+                    
+                    guard let peer = strongSelf.presentationInterfaceState.renderedPeer, let chatPeer = peer.peers[peer.peerId], let mainPeer = peer.chatMainPeer else {
+                        return
+                    }
+                    
+                    enum ClearType {
+                        case savedMessages
+                        case secretChat
+                        case group
+                        case channel
+                        case user
+                    }
+                    
+                    let canClearCache: Bool
+                    let canClearForMyself: ClearType?
+                    let canClearForEveryone: ClearType?
+                    
+                    if peerId == strongSelf.context.account.peerId {
+                        canClearCache = false
+                        canClearForMyself = .savedMessages
+                        canClearForEveryone = nil
+                    } else if chatPeer is TelegramSecretChat {
+                        canClearCache = false
+                        canClearForMyself = .secretChat
+                        canClearForEveryone = nil
+                    } else if let group = chatPeer as? TelegramGroup {
+                        canClearCache = false
+                        
+                        switch group.role {
+                        case .creator:
+                            canClearForMyself = .group
+                            canClearForEveryone = nil
+                        case .admin, .member:
+                            canClearForMyself = .group
+                            canClearForEveryone = nil
+                        }
+                    } else if let channel = chatPeer as? TelegramChannel {
+                        if let username = channel.addressName, !username.isEmpty {
+                            if isLargeGroupOrChannel {
+                                canClearCache = true
+                                canClearForMyself = nil
+                                canClearForEveryone = canClearChannel ? .channel : nil
+                            } else {
+                                canClearCache = true
+                                canClearForMyself = nil
+                                
+                                switch channel.info {
+                                case .broadcast:
+                                    if channel.flags.contains(.isCreator) {
+                                        canClearForEveryone = canClearChannel ? .channel : nil
+                                    } else {
+                                        canClearForEveryone = canClearChannel ? .channel : nil
+                                    }
+                                case .group:
+                                    if channel.flags.contains(.isCreator) {
+                                        canClearForEveryone = canClearChannel ? .channel : nil
+                                    } else {
+                                        canClearForEveryone = canClearChannel ? .channel : nil
+                                    }
+                                }
+                            }
+                        } else {
+                            if isLargeGroupOrChannel {
+                                switch channel.info {
+                                case .broadcast:
+                                    canClearCache = true
+                                    
+                                    canClearForMyself = .channel
+                                    canClearForEveryone = nil
+                                case .group:
+                                    canClearCache = false
+                                    
+                                    canClearForMyself = .channel
+                                    canClearForEveryone = nil
+                                }
+                            } else {
+                                switch channel.info {
+                                case .broadcast:
+                                    canClearCache = true
+                                    
+                                    if channel.flags.contains(.isCreator) {
+                                        canClearForMyself = .channel
+                                        canClearForEveryone = nil
+                                    } else {
+                                        canClearForMyself = .channel
+                                        canClearForEveryone = nil
+                                    }
+                                case .group:
+                                    canClearCache = false
+                                    
+                                    if channel.flags.contains(.isCreator) {
+                                        canClearForMyself = .group
+                                        canClearForEveryone = nil
+                                    } else {
+                                        canClearForMyself = .group
+                                        canClearForEveryone = nil
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        canClearCache = false
+                        canClearForMyself = .user
+                        
+                        if let user = chatPeer as? TelegramUser, user.botInfo != nil {
+                            canClearForEveryone = nil
+                        } else {
+                            canClearForEveryone = .user
+                        }
+                    }
+                    
+                    let actionSheet = ActionSheetController(presentationData: strongSelf.presentationData)
+                    var items: [ActionSheetItem] = []
+                    
+                    if case .scheduledMessages = strongSelf.presentationInterfaceState.subject {
+                        items.append(ActionSheetButtonItem(title: strongSelf.presentationData.strings.ScheduledMessages_ClearAllConfirmation, color: .destructive, action: { [weak actionSheet] in
+                            actionSheet?.dismissAnimated()
+                            
+                            guard let strongSelf = self else {
+                                return
+                            }
+                            
+                            strongSelf.present(standardTextAlertController(theme: AlertControllerTheme(presentationData: strongSelf.presentationData), title: strongSelf.presentationData.strings.ChatList_DeleteSavedMessagesConfirmationTitle, text: strongSelf.presentationData.strings.ChatList_DeleteSavedMessagesConfirmationText, actions: [
+                                TextAlertAction(type: .genericAction, title: strongSelf.presentationData.strings.Common_Cancel, action: {
+                                }),
+                                TextAlertAction(type: .destructiveAction, title: strongSelf.presentationData.strings.ChatList_DeleteSavedMessagesConfirmationAction, action: {
+                                    beginClear(.scheduledMessages)
+                                })
+                            ], parseMarkdown: true), in: .window(.root))
+                        }))
+                    } else {
+                        if let _ = canClearForMyself ?? canClearForEveryone {
+                            items.append(DeleteChatPeerActionSheetItem(context: strongSelf.context, peer: EnginePeer(mainPeer), chatPeer: EnginePeer(chatPeer), action: .clearHistory(canClearCache: canClearCache), strings: strongSelf.presentationData.strings, nameDisplayOrder: strongSelf.presentationData.nameDisplayOrder))
+                            
+                            if let canClearForEveryone = canClearForEveryone {
+                                let text: String
+                                let confirmationText: String
+                                switch canClearForEveryone {
+                                case .user:
+                                    text = strongSelf.presentationData.strings.ChatList_DeleteForEveryone(EnginePeer(mainPeer).compactDisplayTitle).string
+                                    confirmationText = strongSelf.presentationData.strings.ChatList_DeleteForEveryoneConfirmationText
+                                default:
+                                    text = strongSelf.presentationData.strings.Conversation_DeleteMessagesForEveryone
+                                    confirmationText = strongSelf.presentationData.strings.ChatList_DeleteForAllMembersConfirmationText
+                                }
+                                items.append(ActionSheetButtonItem(title: text, color: .destructive, action: { [weak actionSheet] in
+                                    actionSheet?.dismissAnimated()
+                                    
+                                    guard let strongSelf = self else {
+                                        return
+                                    }
+                                    
+                                    strongSelf.present(standardTextAlertController(theme: AlertControllerTheme(presentationData: strongSelf.presentationData), title: strongSelf.presentationData.strings.ChatList_DeleteForEveryoneConfirmationTitle, text: confirmationText, actions: [
+                                        TextAlertAction(type: .genericAction, title: strongSelf.presentationData.strings.Common_Cancel, action: {
+                                        }),
+                                        TextAlertAction(type: .destructiveAction, title: strongSelf.presentationData.strings.ChatList_DeleteForEveryoneConfirmationAction, action: {
+                                            beginClear(.forEveryone)
+                                        })
+                                    ], parseMarkdown: true), in: .window(.root))
+                                }))
+                            }
+                            if let canClearForMyself = canClearForMyself {
+                                let text: String
+                                switch canClearForMyself {
+                                case .savedMessages, .secretChat:
+                                    text = strongSelf.presentationData.strings.Conversation_ClearAll
+                                default:
+                                    text = strongSelf.presentationData.strings.ChatList_DeleteForCurrentUser
+                                }
+                                items.append(ActionSheetButtonItem(title: text, color: .destructive, action: { [weak self, weak actionSheet] in
+                                    actionSheet?.dismissAnimated()
+                                    if mainPeer.id == context.account.peerId, let strongSelf = self {
+                                        strongSelf.present(standardTextAlertController(theme: AlertControllerTheme(presentationData: strongSelf.presentationData), title: strongSelf.presentationData.strings.ChatList_DeleteSavedMessagesConfirmationTitle, text: strongSelf.presentationData.strings.ChatList_DeleteSavedMessagesConfirmationText, actions: [
+                                            TextAlertAction(type: .genericAction, title: strongSelf.presentationData.strings.Common_Cancel, action: {
+                                            }),
+                                            TextAlertAction(type: .destructiveAction, title: strongSelf.presentationData.strings.ChatList_DeleteSavedMessagesConfirmationAction, action: {
+                                                beginClear(.forLocalPeer)
+                                            })
+                                        ], parseMarkdown: true), in: .window(.root))
+                                    } else {
+                                        beginClear(.forLocalPeer)
+                                    }
+                                }))
+                            }
+                        }
+                        
+                        if canClearCache {
+                            items.append(ActionSheetButtonItem(title: strongSelf.presentationData.strings.Conversation_ClearCache, color: .accent, action: { [weak actionSheet] in
+                                actionSheet?.dismissAnimated()
+                                
+                                guard let strongSelf = self else {
+                                    return
+                                }
+                                
+                                strongSelf.navigationButtonAction(.clearCache)
+                            }))
+                        }
+                        
+                        if chatPeer.canSetupAutoremoveTimeout(accountPeerId: strongSelf.context.account.peerId) {
+                            items.append(ActionSheetButtonItem(title: strongSelf.presentationInterfaceState.autoremoveTimeout == nil ? strongSelf.presentationData.strings.Conversation_AutoremoveActionEnable : strongSelf.presentationData.strings.Conversation_AutoremoveActionEdit, color: .accent, action: { [weak actionSheet] in
+                                guard let actionSheet = actionSheet else {
+                                    return
+                                }
+                                guard let strongSelf = self else {
+                                    return
+                                }
+                                
+                                actionSheet.dismissAnimated()
+                                
+                                strongSelf.presentAutoremoveSetup()
+                            }))
+                        }
+                    }
+
+                    actionSheet.setItemGroups([ActionSheetItemGroup(items: items), ActionSheetItemGroup(items: [
+                        ActionSheetButtonItem(title: strongSelf.presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
+                            actionSheet?.dismissAnimated()
+                        })
+                    ])])
+                    
+                    strongSelf.chatDisplayNode.dismissInput()
+                    strongSelf.present(actionSheet, in: .window(.root))
+                })
+            }
+        case let .openChatInfo(expandAvatar, section):
+            let _ = self.presentVoiceMessageDiscardAlert(action: { [weak self] in
+                guard let self else {
+                    return
+                }
+                guard let contentData = self.contentData else {
+                    return
+                }
+                
+                switch contentData.chatLocationInfoData {
+                case let .peer(peerView):
+                    self.navigationActionDisposable.set((peerView.get()
+                    |> take(1)
+                    |> deliverOnMainQueue).startStrict(next: { [weak self] peerView in
+                        guard let self else {
+                            return
+                        }
+                        guard var peer = peerView.peers[peerView.peerId] else {
+                            return
+                        }
+                        if let channel = peer as? TelegramChannel, channel.isMonoForum, let linkedMonoforumId = channel.linkedMonoforumId, let mainPeer = peerView.peers[linkedMonoforumId] as? TelegramChannel {
+                            peer = mainPeer
+                            
+                            guard let navigationController = self.effectiveNavigationController else {
+                                return
+                            }
+                            self.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(
+                                navigationController: navigationController,
+                                context: self.context,
+                                chatLocation: .peer(.channel(mainPeer)),
+                                chatLocationContextHolder: Atomic(value: nil),
+                                keepStack: .always,
+                                useExisting: false,
+                                animated: true
+                            ))
+                            return
+                        }
+                        
+                        if peer.restrictionText(platform: "ios", contentSettings: self.context.currentContentSettings.with { $0 }) == nil && !self.presentationInterfaceState.isNotAccessible {
+                            if peer.id == self.context.account.peerId {
+                                if let peer = self.presentationInterfaceState.renderedPeer?.chatMainPeer, let infoController = self.context.sharedContext.makePeerInfoController(context: self.context, updatedPresentationData: self.updatedPresentationData, peer: peer, mode: .generic, avatarInitiallyExpanded: false, fromChat: true, requestsContext: nil) {
+                                    self.effectiveNavigationController?.pushViewController(infoController)
+                                }
+                            } else {
+                                var expandAvatar = expandAvatar
+                                if peer.smallProfileImage == nil {
+                                    expandAvatar = false
+                                }
+                                if let validLayout = self.validLayout, validLayout.deviceMetrics.type == .tablet {
+                                    expandAvatar = false
+                                }
+                                let mode: PeerInfoControllerMode
+                                switch section {
+                                case .groupsInCommon:
+                                    mode = .groupsInCommon
+                                case .recommendedChannels:
+                                    mode = .recommendedChannels
+                                default:
+                                    mode = .generic
+                                }
+                                if let infoController = self.context.sharedContext.makePeerInfoController(context: self.context, updatedPresentationData: self.updatedPresentationData, peer: peer, mode: mode, avatarInitiallyExpanded: expandAvatar, fromChat: true, requestsContext: self.contentData?.inviteRequestsContext) {
+                                    self.effectiveNavigationController?.pushViewController(infoController)
+                                }
+                            }
+                            
+                            let _ = self.dismissPreviewing?(false)
+                        }
+                    }))
+                case .replyThread:
+                    if let peer = self.presentationInterfaceState.renderedPeer?.peer, case let .replyThread(replyThreadMessage) = self.chatLocation, replyThreadMessage.peerId == self.context.account.peerId {
+                        if let infoController = self.context.sharedContext.makePeerInfoController(context: self.context, updatedPresentationData: self.updatedPresentationData, peer: peer, mode: .forumTopic(thread: replyThreadMessage), avatarInitiallyExpanded: false, fromChat: true, requestsContext: nil) {
+                            self.effectiveNavigationController?.pushViewController(infoController)
+                        }
+                    } else if let monoforumPeer = self.presentationInterfaceState.renderedPeer?.peer, case let .replyThread(replyThreadMessage) = self.chatLocation, monoforumPeer.isMonoForum {
+                        let context = self.context
+                        if #available(iOS 13.0, *) {
+                            Task { @MainActor [weak self] in
+                                guard let peer = await context.engine.data.get(
+                                    TelegramEngine.EngineData.Item.Peer.Peer(id: PeerId(replyThreadMessage.threadId))
+                                ).get() else {
+                                    return
+                                }
+                                guard let self else {
+                                    return
+                                }
+                                if let infoController = self.context.sharedContext.makePeerInfoController(context: self.context, updatedPresentationData: self.updatedPresentationData, peer: peer._asPeer(), mode: .monoforum(monoforumPeer.id), avatarInitiallyExpanded: false, fromChat: true, requestsContext: nil) {
+                                    self.effectiveNavigationController?.pushViewController(infoController)
+                                }
+                            }
+                        }
+                    } else if let channel = self.presentationInterfaceState.renderedPeer?.peer as? TelegramChannel, channel.isForumOrMonoForum, case let .replyThread(message) = self.chatLocation {
+                        if let infoController = self.context.sharedContext.makePeerInfoController(context: self.context, updatedPresentationData: self.updatedPresentationData, peer: channel, mode: .forumTopic(thread: message), avatarInitiallyExpanded: false, fromChat: true, requestsContext: self.contentData?.inviteRequestsContext) {
+                            self.effectiveNavigationController?.pushViewController(infoController)
+                        }
+                    }
+                case .customChatContents:
+                    break
+                }
+            })
+        case .search:
+            self.interfaceInteraction?.beginMessageSearch(.everything, "")
+        case .dismiss:
+            if self.attemptNavigation({}) {
+                self.dismiss()
+            }
+        case .clearCache:
+            guard let contentData = self.contentData else {
+                return
+            }
+            
+            let controller = OverlayStatusController(theme: self.presentationData.theme, type: .loading(cancelled: nil))
+            self.present(controller, in: .window(.root))
+            
+            let disposable: MetaDisposable
+            if let currentDisposable = self.clearCacheDisposable {
+                disposable = currentDisposable
+            } else {
+                disposable = MetaDisposable()
+                self.clearCacheDisposable = disposable
+            }
+        
+            switch contentData.chatLocationInfoData {
+            case let .peer(peerView):
+                self.navigationActionDisposable.set((peerView.get()
+                |> take(1)
+                |> deliverOnMainQueue).startStrict(next: { [weak self] peerView in
+                    guard let strongSelf = self, let peer = peerView.peers[peerView.peerId] else {
+                        return
+                    }
+                    let peerId = peer.id
+                    
+                    let _ = (strongSelf.context.engine.resources.collectCacheUsageStats(peerId: peer.id)
+                    |> deliverOnMainQueue).startStandalone(next: { [weak self, weak controller] result in
+                        controller?.dismiss()
+                        
+                        guard let strongSelf = self, case let .result(stats) = result, let categories = stats.media[peer.id] else {
+                            return
+                        }
+                        let presentationData = strongSelf.presentationData
+                        let controller = ActionSheetController(presentationData: presentationData)
+                        let dismissAction: () -> Void = { [weak controller] in
+                            controller?.dismissAnimated()
+                        }
+                        
+                        var sizeIndex: [PeerCacheUsageCategory: (Bool, Int64)] = [:]
+                        
+                        var itemIndex = 1
+                        
+                        var selectedSize: Int64 = 0
+                        let updateTotalSize: () -> Void = { [weak controller] in
+                            controller?.updateItem(groupIndex: 0, itemIndex: itemIndex, { item in
+                                let title: String
+                                let filteredSize = sizeIndex.values.reduce(0, { $0 + ($1.0 ? $1.1 : 0) })
+                                selectedSize = filteredSize
+                                
+                                if filteredSize == 0 {
+                                    title = presentationData.strings.Cache_ClearNone
+                                } else {
+                                    title = presentationData.strings.Cache_Clear("\(dataSizeString(filteredSize, formatting: DataSizeStringFormatting(presentationData: presentationData)))").string
+                                }
+                                
+                                if let item = item as? ActionSheetButtonItem {
+                                    return ActionSheetButtonItem(title: title, color: filteredSize != 0 ? .accent : .disabled, enabled: filteredSize != 0, action: item.action)
+                                }
+                                return item
+                            })
+                        }
+                        
+                        let toggleCheck: (PeerCacheUsageCategory, Int) -> Void = { [weak controller] category, itemIndex in
+                            if let (value, size) = sizeIndex[category] {
+                                sizeIndex[category] = (!value, size)
+                            }
+                            controller?.updateItem(groupIndex: 0, itemIndex: itemIndex, { item in
+                                if let item = item as? ActionSheetCheckboxItem {
+                                    return ActionSheetCheckboxItem(title: item.title, label: item.label, value: !item.value, action: item.action)
+                                }
+                                return item
+                            })
+                            updateTotalSize()
+                        }
+                        var items: [ActionSheetItem] = []
+                        
+                        items.append(DeleteChatPeerActionSheetItem(context: strongSelf.context, peer: EnginePeer(peer), chatPeer: EnginePeer(peer), action: .clearCache, strings: presentationData.strings, nameDisplayOrder: presentationData.nameDisplayOrder))
+                        
+                        let validCategories: [PeerCacheUsageCategory] = [.image, .video, .audio, .file]
+                        
+                        var totalSize: Int64 = 0
+                        
+                        func stringForCategory(strings: PresentationStrings, category: PeerCacheUsageCategory) -> String {
+                            switch category {
+                                case .image:
+                                    return strings.Cache_Photos
+                                case .video:
+                                    return strings.Cache_Videos
+                                case .audio:
+                                    return strings.Cache_Music
+                                case .file:
+                                    return strings.Cache_Files
+                            }
+                        }
+                        
+                        for categoryId in validCategories {
+                            if let media = categories[categoryId] {
+                                var categorySize: Int64 = 0
+                                for (_, size) in media {
+                                    categorySize += size
+                                }
+                                sizeIndex[categoryId] = (true, categorySize)
+                                totalSize += categorySize
+                                if categorySize > 1024 {
+                                    let index = itemIndex
+                                    items.append(ActionSheetCheckboxItem(title: stringForCategory(strings: presentationData.strings, category: categoryId), label: dataSizeString(categorySize, formatting: DataSizeStringFormatting(presentationData: presentationData)), value: true, action: { value in
+                                        toggleCheck(categoryId, index)
+                                    }))
+                                    itemIndex += 1
+                                }
+                            }
+                        }
+                        selectedSize = totalSize
+                        
+                        if items.isEmpty {
+                            strongSelf.presentClearCacheSuggestion()
+                        } else {
+                            items.append(ActionSheetButtonItem(title: presentationData.strings.Cache_Clear("\(dataSizeString(totalSize, formatting: DataSizeStringFormatting(presentationData: presentationData)))").string, action: {
+                                let clearCategories = sizeIndex.keys.filter({ sizeIndex[$0]!.0 })
+                                var clearMediaIds = Set<MediaId>()
+                                
+                                var media = stats.media
+                                if var categories = media[peerId] {
+                                    for category in clearCategories {
+                                        if let contents = categories[category] {
+                                            for (mediaId, _) in contents {
+                                                clearMediaIds.insert(mediaId)
+                                            }
+                                        }
+                                        categories.removeValue(forKey: category)
+                                    }
+                                    
+                                    media[peerId] = categories
+                                }
+                                
+                                var clearResourceIds = Set<MediaResourceId>()
+                                for id in clearMediaIds {
+                                    if let ids = stats.mediaResourceIds[id] {
+                                        for resourceId in ids {
+                                            clearResourceIds.insert(resourceId)
+                                        }
+                                    }
+                                }
+                                
+                                var signal = strongSelf.context.engine.resources.clearCachedMediaResources(mediaResourceIds: clearResourceIds)
+                                
+                                var cancelImpl: (() -> Void)?
+                                let presentationData = strongSelf.context.sharedContext.currentPresentationData.with { $0 }
+                                let progressSignal = Signal<Never, NoError> { subscriber in
+                                    let controller = OverlayStatusController(theme: presentationData.theme,  type: .loading(cancelled: {
+                                        cancelImpl?()
+                                    }))
+                                    strongSelf.present(controller, in: .window(.root), with: ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+                                    return ActionDisposable { [weak controller] in
+                                        Queue.mainQueue().async() {
+                                            controller?.dismiss()
+                                        }
+                                    }
+                                }
+                                |> runOn(Queue.mainQueue())
+                                |> delay(0.15, queue: Queue.mainQueue())
+                                let progressDisposable = progressSignal.startStrict()
+                                
+                                signal = signal
+                                |> afterDisposed {
+                                    Queue.mainQueue().async {
+                                        progressDisposable.dispose()
+                                    }
+                                }
+                                cancelImpl = {
+                                    disposable.set(nil)
+                                }
+                                disposable.set((signal
+                                |> deliverOnMainQueue).startStrict(completed: { [weak self] in
+                                    if let strongSelf = self, let _ = strongSelf.validLayout {
+                                        strongSelf.present(UndoOverlayController(presentationData: presentationData, content: .succeed(text: presentationData.strings.ClearCache_Success("\(dataSizeString(selectedSize, formatting: DataSizeStringFormatting(presentationData: presentationData)))", stringForDeviceType()).string, timeout: nil, customUndoText: nil), elevatedLayout: false, action: { _ in return false }), in: .current)
+                                    }
+                                }))
+
+                                dismissAction()
+                                strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, { $0.updatedInterfaceState({ $0.withoutSelectionState() }) })
+                            }))
+                            
+                            items.append(ActionSheetButtonItem(title: presentationData.strings.ClearCache_StorageUsage, action: { [weak self] in
+                                dismissAction()
+                                strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, { $0.updatedInterfaceState({ $0.withoutSelectionState() }) })
+                                
+                                if let strongSelf = self {
+                                    let context = strongSelf.context
+                                    let controller = StorageUsageScreen(context: context, makeStorageUsageExceptionsScreen: { category in
+                                        return storageUsageExceptionsScreen(context: context, category: category)
+                                    })
+                                    strongSelf.present(controller, in: .window(.root), with: ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+                                }
+                            }))
+                            
+                            controller.setItemGroups([
+                                ActionSheetItemGroup(items: items),
+                                ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+                            ])
+                            strongSelf.chatDisplayNode.dismissInput()
+                            strongSelf.present(controller, in: .window(.root))
+                        }
+                    })
+                }))
+            case .replyThread:
+                break
+            case .customChatContents:
+                break
+            }
+        case .edit:
+            self.editChat()
+        }
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenBankCardContextMenu.swift

@@ -0,0 +1,85 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatControllerInteraction
+
+extension ChatControllerImpl {
+    func openBankCardContextMenu(number: String, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let message = params.message, let contentNode = params.contentNode else {
+            return
+        }
+                
+        guard let messages = self.chatDisplayNode.historyNode.messageGroupInCurrentHistoryView(message.id) else {
+            return
+        }
+        
+        var updatedMessages = messages
+        for i in 0 ..< updatedMessages.count {
+            if updatedMessages[i].id == message.id {
+                let message = updatedMessages.remove(at: i)
+                updatedMessages.insert(message, at: 0)
+                break
+            }
+        }
+        
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+                                           
+        let source: ContextContentSource
+//                if let location = location {
+//                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: messageNode.view.convert(messageNode.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+//                } else {
+            source = .extracted(ChatMessageLinkContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode))
+//                }
+        
+        params.progress?.set(.single(true))
+        
+        let _ = (self.context.engine.payments.getBankCardInfo(cardNumber: number)
+        |> deliverOnMainQueue).start(next: { [weak self] info in
+            guard let self else {
+                return
+            }
+            params.progress?.set(.single(false))
+            
+            var items: [ContextMenuItem] = []
+            
+            items.append(
+                .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Card_Copy, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                    f(.default)
+
+                    guard let self else {
+                        return
+                    }
+                    
+                    UIPasteboard.general.string = number
+
+                    self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: presentationData.strings.Conversation_CardNumberCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+                }))
+            )
+            
+            if let info {
+                items.append(.separator)
+                let emptyAction: ((ContextMenuActionItem.Action) -> Void)? = nil
+                items.append(.action(ContextMenuActionItem(text: info.title, textLayout: .multiline, textFont: .small, icon: { _ in return nil }, action: emptyAction)))
+            }
+             
+            self.canReadHistory.set(false)
+            
+            let controller = ContextController(presentationData: self.presentationData, source: source, items: .single(ContextController.Items(content: .list(items))), recognizer: recognizer, gesture: gesture, disableScreenshots: false)
+            controller.dismissed = { [weak self] in
+                self?.canReadHistory.set(true)
+            }
+            
+            self.window?.presentInGlobalOverlay(controller)
+        })
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenCommandContextMenu.swift

@@ -0,0 +1,69 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatControllerInteraction
+
+extension ChatControllerImpl {
+    func openCommandContextMenu(command: String, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let message = params.message, let contentNode = params.contentNode else {
+            return
+        }
+        
+        guard let messages = self.chatDisplayNode.historyNode.messageGroupInCurrentHistoryView(message.id) else {
+            return
+        }
+            
+        var updatedMessages = messages
+        for i in 0 ..< updatedMessages.count {
+            if updatedMessages[i].id == message.id {
+                let message = updatedMessages.remove(at: i)
+                updatedMessages.insert(message, at: 0)
+                break
+            }
+        }
+               
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+        
+        let source: ContextContentSource
+//                if let location = location {
+//                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: messageNode.view.convert(messageNode.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+//                } else {
+            source = .extracted(ChatMessageLinkContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode))
+//                }
+        
+        var items: [ContextMenuItem] = []
+
+        items.append(
+            .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Command_Copy, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                f(.default)
+
+                guard let self else {
+                    return
+                }
+                
+                UIPasteboard.general.string = command
+
+                self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: presentationData.strings.Conversation_TextCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+            }))
+        )
+         
+        self.canReadHistory.set(false)
+        
+        let controller = ContextController(presentationData: self.presentationData, source: source, items: .single(ContextController.Items(content: .list(items))), recognizer: recognizer, gesture: gesture, disableScreenshots: false)
+        controller.dismissed = { [weak self] in
+            self?.canReadHistory.set(true)
+        }
+        
+        self.window?.presentInGlobalOverlay(controller)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenHashtagContextMenu.swift

@@ -0,0 +1,79 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatControllerInteraction
+
+extension ChatControllerImpl {
+    func openHashtagContextMenu(hashtag: String, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let message = params.message, let contentNode = params.contentNode else {
+            return
+        }
+        
+        guard let messages = self.chatDisplayNode.historyNode.messageGroupInCurrentHistoryView(message.id) else {
+            return
+        }
+            
+        var updatedMessages = messages
+        for i in 0 ..< updatedMessages.count {
+            if updatedMessages[i].id == message.id {
+                let message = updatedMessages.remove(at: i)
+                updatedMessages.insert(message, at: 0)
+                break
+            }
+        }
+               
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+        
+        let source: ContextContentSource
+//                if let location = location {
+//                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: messageNode.view.convert(messageNode.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+//                } else {
+            source = .extracted(ChatMessageLinkContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode))
+//                }
+        
+        var items: [ContextMenuItem] = []
+
+        items.append(
+            .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Hashtag_Search, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Search"), color: theme.contextMenu.primaryColor) }, action: { [weak self] _, f in
+                guard let self else {
+                    return
+                }
+                f(.default)
+                self.controllerInteraction?.openHashtag(nil, hashtag)
+            }))
+        )
+        
+        items.append(
+            .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Hashtag_Copy, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                f(.default)
+
+                guard let self else {
+                    return
+                }
+                
+                UIPasteboard.general.string = hashtag
+
+                self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: presentationData.strings.Conversation_HashtagCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+            }))
+        )
+         
+        self.canReadHistory.set(false)
+        
+        let controller = ContextController(presentationData: self.presentationData, source: source, items: .single(ContextController.Items(content: .list(items))), recognizer: recognizer, gesture: gesture, disableScreenshots: false)
+        controller.dismissed = { [weak self] in
+            self?.canReadHistory.set(true)
+        }
+        
+        self.window?.presentInGlobalOverlay(controller)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenLinkContextMenu.swift

@@ -0,0 +1,207 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import MessageUI
+import ChatControllerInteraction
+import UrlWhitelist
+import OpenInExternalAppUI
+import SafariServices
+
+extension ChatControllerImpl {
+    func openLinkContextMenu(url: String, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let message = params.message, let contentNode = params.contentNode else {
+            var (cleanUrl, _) = parseUrl(url: url, wasConcealed: false)
+            var canAddToReadingList = true
+            var canOpenIn = availableOpenInOptions(context: self.context, item: .url(url: url)).count > 1
+            let mailtoString = "mailto:"
+            let telString = "tel:"
+            var openText = self.presentationData.strings.Conversation_LinkDialogOpen
+            var phoneNumber: String?
+            
+            var isPhoneNumber = false
+            var isEmail = false
+            var hasOpenAction = true
+            
+            if cleanUrl.hasPrefix(mailtoString) {
+                canAddToReadingList = false
+                cleanUrl = String(cleanUrl[cleanUrl.index(cleanUrl.startIndex, offsetBy: mailtoString.distance(from: mailtoString.startIndex, to: mailtoString.endIndex))...])
+                isEmail = true
+            } else if cleanUrl.hasPrefix(telString) {
+                canAddToReadingList = false
+                phoneNumber = String(cleanUrl[cleanUrl.index(cleanUrl.startIndex, offsetBy: telString.distance(from: telString.startIndex, to: telString.endIndex))...])
+                cleanUrl = phoneNumber!
+                openText = self.presentationData.strings.UserInfo_PhoneCall
+                canOpenIn = false
+                isPhoneNumber = true
+                
+                if cleanUrl.hasPrefix("+888") {
+                    hasOpenAction = false
+                }
+            } else if canOpenIn {
+                openText = self.presentationData.strings.Conversation_FileOpenIn
+            }
+            
+            let actionSheet = ActionSheetController(presentationData: self.presentationData)
+            var items: [ActionSheetItem] = []
+            items.append(ActionSheetTextItem(title: cleanUrl))
+            if hasOpenAction {
+                items.append(ActionSheetButtonItem(title: openText, color: .accent, action: { [weak self, weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                    if let strongSelf = self {
+                        if canOpenIn {
+                            strongSelf.openUrlIn(url)
+                        } else {
+                            strongSelf.openUrl(url, concealed: false)
+                        }
+                    }
+                }))
+            }
+            if let phoneNumber = phoneNumber {
+                items.append(ActionSheetButtonItem(title: self.presentationData.strings.Conversation_AddContact, color: .accent, action: { [weak self, weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                    if let strongSelf = self {
+                        strongSelf.controllerInteraction?.addContact(phoneNumber)
+                    }
+                }))
+            }
+            items.append(ActionSheetButtonItem(title: canAddToReadingList ? self.presentationData.strings.ShareMenu_CopyShareLink : self.presentationData.strings.Conversation_ContextMenuCopy, color: .accent, action: { [weak actionSheet, weak self] in
+                actionSheet?.dismissAnimated()
+                guard let self else {
+                    return
+                }
+                UIPasteboard.general.string = cleanUrl
+                
+                let content: UndoOverlayContent
+                if isPhoneNumber {
+                    content = .copy(text: self.presentationData.strings.Conversation_PhoneCopied)
+                } else if isEmail {
+                    content = .copy(text: self.presentationData.strings.Conversation_EmailCopied)
+                } else if canAddToReadingList {
+                    content = .linkCopied(title: nil, text: self.presentationData.strings.Conversation_LinkCopied)
+                } else {
+                    content = .copy(text: self.presentationData.strings.Conversation_TextCopied)
+                }
+                self.present(UndoOverlayController(presentationData: self.presentationData, content: content, elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+            }))
+            if canAddToReadingList {
+                items.append(ActionSheetButtonItem(title: self.presentationData.strings.Conversation_AddToReadingList, color: .accent, action: { [weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                    if let link = URL(string: url) {
+                        let _ = try? SSReadingList.default()?.addItem(with: link, title: nil, previewText: nil)
+                    }
+                }))
+            }
+            actionSheet.setItemGroups([ActionSheetItemGroup(items: items), ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: self.presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                })
+            ])])
+            self.chatDisplayNode.dismissInput()
+            self.present(actionSheet, in: .window(.root))
+            
+            return
+        }
+        
+        guard let messages = self.chatDisplayNode.historyNode.messageGroupInCurrentHistoryView(message.id) else {
+            return
+        }
+        
+        var updatedMessages = messages
+        for i in 0 ..< updatedMessages.count {
+            if updatedMessages[i].id == message.id {
+                let message = updatedMessages.remove(at: i)
+                updatedMessages.insert(message, at: 0)
+                break
+            }
+        }
+        
+        var (cleanUrl, _) = parseUrl(url: url, wasConcealed: false)
+        var canAddToReadingList = true
+        let canOpenIn = availableOpenInOptions(context: self.context, item: .url(url: url)).count > 1
+        
+        var isEmail = false
+        let mailtoString = "mailto:"
+        var openText = self.presentationData.strings.Conversation_LinkDialogOpen
+        var copyText = self.presentationData.strings.Conversation_ContextMenuCopyLink
+        if cleanUrl.hasPrefix(mailtoString) {
+            canAddToReadingList = false
+            cleanUrl = String(cleanUrl[cleanUrl.index(cleanUrl.startIndex, offsetBy: mailtoString.distance(from: mailtoString.startIndex, to: mailtoString.endIndex))...])
+            copyText = self.presentationData.strings.Conversation_ContextMenuCopyEmail
+            isEmail = true
+        } else if canOpenIn {
+            openText = self.presentationData.strings.Conversation_FileOpenIn
+        }
+            
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+        
+        let source: ContextContentSource
+//                if let location = location {
+//                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: messageNode.view.convert(messageNode.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+//                } else {
+            source = .extracted(ChatMessageLinkContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode))
+//                }
+        
+        var items: [ContextMenuItem] = []
+        
+        items.append(
+            .action(ContextMenuActionItem(text: openText, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Browser"), color: theme.contextMenu.primaryColor) }, action: { [weak self] _, f in
+                guard let self else {
+                    return
+                }
+                f(.default)
+                
+                if canOpenIn {
+                    self.openUrlIn(url)
+                }
+                else {
+                    self.openUrl(url, concealed: false)
+                }
+            }))
+        )
+        
+        items.append(
+            .action(ContextMenuActionItem(text: copyText, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                f(.default)
+
+                guard let self else {
+                    return
+                }
+                
+                UIPasteboard.general.string = cleanUrl
+
+                self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: isEmail ? presentationData.strings.Conversation_EmailCopied : presentationData.strings.Conversation_LinkCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+            }))
+        )
+        
+        if canAddToReadingList {
+            items.append(
+                .action(ContextMenuActionItem(text: self.presentationData.strings.Conversation_AddToReadingList, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/ReadingList"), color: theme.contextMenu.primaryColor) }, action: { _, f in
+                    f(.default)
+                    
+                    if let link = URL(string: url) {
+                        let _ = try? SSReadingList.default()?.addItem(with: link, title: nil, previewText: nil)
+                    }
+                }))
+            )
+        }
+        
+        self.canReadHistory.set(false)
+        
+        let controller = ContextController(presentationData: self.presentationData, source: source, items: .single(ContextController.Items(content: .list(items))), recognizer: recognizer, gesture: gesture, disableScreenshots: false)
+        controller.dismissed = { [weak self] in
+            self?.canReadHistory.set(true)
+        }
+        
+        self.window?.presentInGlobalOverlay(controller)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenLinkLongTap.swift

@@ -0,0 +1,40 @@
+import Foundation
+import Display
+import ChatControllerInteraction
+import AccountContext
+
+extension ChatControllerImpl {
+    func openLinkLongTap(_ action: ChatControllerInteractionLongTapAction, params: ChatControllerInteraction.LongTapParams?) {
+        if self.presentationInterfaceState.interfaceState.selectionState != nil {
+            return
+        }
+        
+        self.dismissAllTooltips()
+        
+        (self.view.window as? WindowHost)?.cancelInteractiveKeyboardGestures()
+        self.chatDisplayNode.cancelInteractiveKeyboardGestures()
+        self.chatDisplayNode.messageTransitionNode.dismissMessageReactionContexts()
+        
+        guard let params else {
+            return
+        }
+        switch action {
+        case let .url(url):
+            self.openLinkContextMenu(url: url, params: params)
+        case let .mention(mention):
+            self.openMentionContextMenu(username: mention, peerId: nil, params: params)
+        case let .peerMention(peerId, mention):
+            self.openMentionContextMenu(username: mention, peerId: peerId, params: params)
+        case let .command(command):
+            self.openCommandContextMenu(command: command, params: params)
+        case let .hashtag(hashtag):
+            self.openHashtagContextMenu(hashtag: hashtag, params: params)
+        case let .timecode(value, timecode):
+            self.openTimecodeContextMenu(timecode: timecode, value: value, params: params)
+        case let .bankCard(number):
+            self.openBankCardContextMenu(number: number, params: params)
+        case let .phone(number):
+            self.openPhoneContextMenu(number: number, params: params)
+        }
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenMessageContextMenu.swift

@@ -0,0 +1,666 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import TelegramNotices
+import ContextUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ReactionSelectionNode
+import EntityKeyboard
+import TextNodeWithEntities
+import PremiumUI
+import TooltipUI
+import TopMessageReactions
+import TelegramNotices
+
+extension ChatControllerImpl {
+    func openMessageContextMenu(message: Message, selectAll: Bool, node: ASDisplayNode, frame: CGRect, anyRecognizer: UIGestureRecognizer?, location: CGPoint?) -> Void {
+        if self.presentationInterfaceState.interfaceState.selectionState != nil {
+            return
+        }
+        let presentationData = self.presentationData
+        
+        self.dismissAllTooltips()
+        
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = anyRecognizer as? ContextGesture
+        if let messages = self.chatDisplayNode.historyNode.messageGroupInCurrentHistoryView(message.id) {
+            (self.view.window as? WindowHost)?.cancelInteractiveKeyboardGestures()
+            self.chatDisplayNode.cancelInteractiveKeyboardGestures()
+            var updatedMessages = messages
+            for i in 0 ..< updatedMessages.count {
+                if updatedMessages[i].id == message.id {
+                    let message = updatedMessages.remove(at: i)
+                    updatedMessages.insert(message, at: 0)
+                    break
+                }
+            }
+            
+            guard let topMessage = messages.first else {
+                return
+            }
+            
+            let _ = combineLatest(queue: .mainQueue(),
+                self.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: self.context.account.peerId)),
+                contextMenuForChatPresentationInterfaceState(chatPresentationInterfaceState: self.presentationInterfaceState, context: self.context, messages: updatedMessages, controllerInteraction: self.controllerInteraction, selectAll: selectAll, interfaceInteraction: self.interfaceInteraction, messageNode: node as? ChatMessageItemView),
+                peerMessageAllowedReactions(context: self.context, message: topMessage),
+                peerMessageSelectedReactions(context: self.context, message: topMessage),
+                topMessageReactions(context: self.context, message: topMessage, subPeerId: self.chatLocation.threadId.flatMap(EnginePeer.Id.init)),
+                ApplicationSpecificNotice.getChatTextSelectionTips(accountManager: self.context.sharedContext.accountManager)
+            ).startStandalone(next: { [weak self] peer, actions, allowedReactionsAndStars, selectedReactions, topReactions, chatTextSelectionTips in
+                guard let self else {
+                    return
+                }
+                
+                var (allowedReactions, _) = allowedReactionsAndStars
+                
+                var actions = actions
+                switch actions.content {
+                case let .list(itemList):
+                    if itemList.isEmpty {
+                        return
+                    }
+                case .custom, .twoLists:
+                    break
+                }
+                
+                if allowedReactions != nil, case let .customChatContents(customChatContents) = self.presentationInterfaceState.subject {
+                    if case let .hashTagSearch(publicPosts) = customChatContents.kind, publicPosts {
+                        allowedReactions = nil
+                    }
+                }
+
+                var tip: ContextController.Tip?
+                
+                if tip == nil {
+                    let isAd = message.adAttribute != nil
+                        
+                    var isAction = false
+                    for media in message.media {
+                        if media is TelegramMediaAction {
+                            isAction = true
+                            break
+                        }
+                    }
+                    if self.presentationInterfaceState.copyProtectionEnabled && !isAction && !isAd {
+                        if case .scheduledMessages = self.subject {
+                        } else {
+                            var isChannel = false
+                            if let channel = self.presentationInterfaceState.renderedPeer?.peer as? TelegramChannel, case .broadcast = channel.info {
+                                isChannel = true
+                            }
+                            tip = .messageCopyProtection(isChannel: isChannel)
+                        }
+                    } else {
+                        let numberOfComponents = message.text.components(separatedBy: CharacterSet.whitespacesAndNewlines).count
+                        let displayTextSelectionTip = numberOfComponents >= 3 && !message.text.isEmpty && chatTextSelectionTips < 3 && !isAd
+                        if displayTextSelectionTip {
+                            let _ = ApplicationSpecificNotice.incrementChatTextSelectionTips(accountManager: self.context.sharedContext.accountManager).startStandalone()
+                            tip = .textSelection
+                        }
+                    }
+                }
+                
+                if messages.contains(where: { $0.pendingProcessingAttribute != nil }) {
+                    tip = .videoProcessing
+                }
+
+                if actions.tip == nil {
+                    actions.tip = tip
+                }
+                
+                actions.context = self.context
+                actions.animationCache = self.controllerInteraction?.presentationContext.animationCache
+                                                         
+                if canAddMessageReactions(message: topMessage), let allowedReactions = allowedReactions, !topReactions.isEmpty {
+                    actions.reactionItems = topReactions.map { ReactionContextItem.reaction(item: $0, icon: .none) }
+                    actions.selectedReactionItems = selectedReactions.reactions
+                    if message.areReactionsTags(accountPeerId: self.context.account.peerId) {
+                        if self.presentationInterfaceState.isPremium {
+                            actions.reactionsTitle = presentationData.strings.Chat_ContextMenuTagsTitle
+                        } else {
+                            actions.reactionsTitle = presentationData.strings.Chat_MessageContextMenu_NonPremiumTagsTitle
+                            actions.reactionsLocked = true
+                            actions.selectedReactionItems = Set()
+                        }
+                        actions.allPresetReactionsAreAvailable = true
+                    }
+                    
+                    if let channel = self.presentationInterfaceState.renderedPeer?.peer as? TelegramChannel, case .broadcast = channel.info {
+                        actions.alwaysAllowPremiumReactions = true
+                    }
+                    
+                    if !actions.reactionItems.isEmpty {
+                        let reactionItems: [EmojiComponentReactionItem] = actions.reactionItems.compactMap { item -> EmojiComponentReactionItem? in
+                            switch item {
+                            case let .reaction(reaction, _):
+                                return EmojiComponentReactionItem(reaction: reaction.reaction.rawValue, file: reaction.stillAnimation)
+                            default:
+                                return nil
+                            }
+                        }
+                        
+                        var allReactionsAreAvailable = false
+                        switch allowedReactions {
+                        case .set:
+                            allReactionsAreAvailable = false
+                        case .all:
+                            allReactionsAreAvailable = true
+                        }
+                        
+                        if let channel = self.presentationInterfaceState.renderedPeer?.chatMainPeer as? TelegramChannel, case .broadcast = channel.info {
+                            allReactionsAreAvailable = false
+                        }
+                        
+                        let premiumConfiguration = PremiumConfiguration.with(appConfiguration: context.currentAppConfiguration.with { $0 })
+                        if premiumConfiguration.isPremiumDisabled {
+                            allReactionsAreAvailable = false
+                        }
+                        
+                        if allReactionsAreAvailable {
+                            actions.getEmojiContent = { [weak self] animationCache, animationRenderer in
+                                guard let self else {
+                                    preconditionFailure()
+                                }
+                                
+                                return EmojiPagerContentComponent.emojiInputData(
+                                    context: self.context,
+                                    animationCache: animationCache,
+                                    animationRenderer: animationRenderer,
+                                    isStandalone: false,
+                                    subject: message.areReactionsTags(accountPeerId: self.context.account.peerId) ? .messageTag : .reaction(onlyTop: false),
+                                    hasTrending: false,
+                                    topReactionItems: reactionItems,
+                                    areUnicodeEmojiEnabled: false,
+                                    areCustomEmojiEnabled: true,
+                                    chatPeerId: self.chatLocation.peerId,
+                                    selectedItems: selectedReactions.files
+                                )
+                            }
+                        } else if reactionItems.count > 16 {
+                            actions.getEmojiContent = { [weak self] animationCache, animationRenderer in
+                                guard let self else {
+                                    preconditionFailure()
+                                }
+                                
+                                return EmojiPagerContentComponent.emojiInputData(
+                                    context: self.context,
+                                    animationCache: animationCache,
+                                    animationRenderer: animationRenderer,
+                                    isStandalone: false,
+                                    subject: .reaction(onlyTop: true),
+                                    hasTrending: false,
+                                    topReactionItems: reactionItems,
+                                    areUnicodeEmojiEnabled: false,
+                                    areCustomEmojiEnabled: false,
+                                    chatPeerId: self.chatLocation.peerId,
+                                    selectedItems: selectedReactions.files
+                                )
+                            }
+                        }
+                    }
+                }
+                
+                self.chatDisplayNode.messageTransitionNode.dismissMessageReactionContexts()
+                
+                let presentationContext = self.controllerInteraction?.presentationContext
+                
+                var disableTransitionAnimations = false
+                var actionsSignal: Signal<ContextController.Items, NoError> = .single(actions)
+                if let entitiesAttribute = message.textEntitiesAttribute {
+                    var emojiFileIds: [Int64] = []
+                    for entity in entitiesAttribute.entities {
+                        if case let .CustomEmoji(_, fileId) = entity.type {
+                            emojiFileIds.append(fileId)
+                        }
+                    }
+                    
+                    let premiumConfiguration = PremiumConfiguration.with(appConfiguration: context.currentAppConfiguration.with { $0 })
+                    
+                    if !emojiFileIds.isEmpty && !premiumConfiguration.isPremiumDisabled {
+                        tip = .animatedEmoji(text: nil, arguments: nil, file: nil, action: nil)
+                        actions.tip = tip
+                        disableTransitionAnimations = true
+                        
+                        let context = self.context
+                        actionsSignal = .single(actions)
+                        |> then(
+                            context.engine.stickers.resolveInlineStickers(fileIds: emojiFileIds)
+                            |> mapToSignal { files -> Signal<ContextController.Items, NoError> in
+                                var packReferences: [StickerPackReference] = []
+                                var existingIds = Set<Int64>()
+                                for (_, file) in files {
+                                    loop: for attribute in file.attributes {
+                                        if case let .CustomEmoji(_, _, _, packReference) = attribute, let packReference = packReference {
+                                            if case let .id(id, _) = packReference, !existingIds.contains(id) {
+                                                packReferences.append(packReference)
+                                                existingIds.insert(id)
+                                            }
+                                            break loop
+                                        }
+                                    }
+                                }
+                                
+                                let action = { [weak self] in
+                                    guard let self else {
+                                        return
+                                    }
+                                    self.presentEmojiList(references: packReferences)
+                                }
+                                
+                                if packReferences.count > 1 {
+                                    actions.tip = .animatedEmoji(text: presentationData.strings.ChatContextMenu_EmojiSet(Int32(packReferences.count)), arguments: nil, file: nil, action: action)
+                                    return .single(actions)
+                                } else if let reference = packReferences.first {
+                                    return context.engine.stickers.loadedStickerPack(reference: reference, forceActualized: false)
+                                    |> filter { result in
+                                        if case .result = result {
+                                            return true
+                                        } else {
+                                            return false
+                                        }
+                                    }
+                                    |> mapToSignal { result in
+                                        if case let .result(info, items, _) = result, let presentationContext = presentationContext {
+                                            actions.tip = .animatedEmoji(
+                                                text: presentationData.strings.ChatContextMenu_EmojiSetSingle(info.title).string,
+                                                arguments: TextNodeWithEntities.Arguments(
+                                                    context: context,
+                                                    cache: presentationContext.animationCache,
+                                                    renderer: presentationContext.animationRenderer,
+                                                    placeholderColor: .clear,
+                                                    attemptSynchronous: true
+                                                ),
+                                                file: items.first?.file._parse(),
+                                                action: action)
+                                            return .single(actions)
+                                        } else {
+                                            return .complete()
+                                        }
+                                    }
+                                } else {
+                                    actions.tip = nil
+                                    return .single(actions)
+                                }
+                            }
+                        )
+                    }
+                }
+                
+                var keepDefaultContentTouches = false
+                for media in message.media {
+                    if media is TelegramMediaImage {
+                        keepDefaultContentTouches = true
+                    } else if let file = media as? TelegramMediaFile, file.isVideo {
+                        keepDefaultContentTouches = true
+                    }
+                }
+                
+                let source: ContextContentSource
+                if let location = location {
+                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: node.view.convert(node.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+                } else {
+                    source = .extracted(ChatMessageContextExtractedContentSource(chatController: self, chatNode: self.chatDisplayNode, engine: self.context.engine, message: message, selectAll: selectAll, keepDefaultContentTouches: keepDefaultContentTouches))
+                }
+                
+                self.canReadHistory.set(false)
+                
+                var hideReactionPanelTail = false
+                for media in message.media {
+                    if let action = media as? TelegramMediaAction {
+                        switch action.action {
+                        case .phoneCall:
+                            break
+                        case .conferenceCall:
+                            break
+                        default:
+                            hideReactionPanelTail = true
+                        }
+                    }
+                }
+                
+                let isSecret = self.presentationInterfaceState.copyProtectionEnabled || self.chatLocation.peerId?.namespace == Namespaces.Peer.SecretChat
+                let controller = ContextController(presentationData: self.presentationData, source: source, items: actionsSignal, recognizer: recognizer, gesture: gesture, disableScreenshots: isSecret, hideReactionPanelTail: hideReactionPanelTail)
+                controller.dismissed = { [weak self] in
+                    self?.canReadHistory.set(true)
+                }
+                controller.immediateItemsTransitionAnimation = disableTransitionAnimations
+                self.currentContextController = controller
+                
+                controller.premiumReactionsSelected = { [weak self, weak controller] in
+                    guard let self else {
+                        return
+                    }
+                    
+                    controller?.dismissWithoutContent()
+                    guard !self.presentAccountFrozenInfoIfNeeded(delay: true) else {
+                        return
+                    }
+                    self.presentTagPremiumPaywall()
+                }
+                
+                controller.reactionSelected = { [weak self, weak controller] chosenUpdatedReaction, isLarge in
+                    guard let self else {
+                        return
+                    }
+                    
+                    guard !self.presentAccountFrozenInfoIfNeeded(delay: true) else {
+                        controller?.dismiss(completion: {})
+                        return
+                    }
+                    
+                    guard let message = messages.first else {
+                        return
+                    }
+                    
+                    controller?.view.endEditing(true)
+                    
+                    if case .stars = chosenUpdatedReaction.reaction {
+                        if isLarge {
+                            if let controller {
+                                controller.dismiss(completion: { [weak self] in
+                                    guard let self else {
+                                        return
+                                    }
+                                    self.openMessageSendStarsScreen(message: message)
+                                })
+                            }
+                            return
+                        }
+                        
+                        let isFirst = !"".isEmpty
+                        
+                        self.chatDisplayNode.historyNode.forEachItemNode { itemNode in
+                            if let itemNode = itemNode as? ChatMessageItemView, let item = itemNode.item {
+                                if item.message.id == message.id {
+                                    let chosenReaction: MessageReaction.Reaction = .stars
+                                    itemNode.awaitingAppliedReaction = (chosenReaction, { [weak self, weak itemNode] in
+                                        guard let self, let controller = controller else {
+                                            return
+                                        }
+                                        if let itemNode = itemNode, let targetView = itemNode.targetReactionView(value: chosenReaction) {
+                                            self.chatDisplayNode.messageTransitionNode.addMessageContextController(messageId: item.message.id, contextController: controller)
+                                            
+                                            var hideTargetButton: UIView?
+                                            if isFirst {
+                                                hideTargetButton = targetView.superview
+                                            }
+                                            
+                                            controller.dismissWithReaction(value: chosenReaction, targetView: targetView, hideNode: true, animateTargetContainer: hideTargetButton, addStandaloneReactionAnimation: { [weak self] standaloneReactionAnimation in
+                                                guard let self else {
+                                                    return
+                                                }
+                                                self.chatDisplayNode.messageTransitionNode.addMessageStandaloneReactionAnimation(messageId: item.message.id, standaloneReactionAnimation: standaloneReactionAnimation)
+                                                standaloneReactionAnimation.frame = self.chatDisplayNode.bounds
+                                                self.chatDisplayNode.addSubnode(standaloneReactionAnimation)
+                                            }, onHit: { [weak self, weak itemNode] in
+                                                guard let self else {
+                                                    return
+                                                }
+                                                if let itemNode = itemNode, let targetView = itemNode.targetReactionView(value: chosenReaction) {
+                                                    if !"".isEmpty {
+                                                        if self.context.sharedContext.energyUsageSettings.fullTranslucency {
+                                                            self.chatDisplayNode.wrappingNode.triggerRipple(at: targetView.convert(targetView.bounds.center, to: self.chatDisplayNode.view))
+                                                        }
+                                                    }
+                                                }
+                                            }, completion: {})
+                                        } else {
+                                            controller.dismiss()
+                                        }
+                                    })
+                                }
+                            }
+                        }
+                        
+                        guard let starsContext = self.context.starsContext else {
+                            return
+                        }
+                        let _ = (combineLatest(
+                            starsContext.state,
+                            self.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.ReactionSettings(id: message.id.peerId))
+                        )
+                        |> take(1)
+                        |> deliverOnMainQueue).start(next: { [weak self] state, reactionSettings in
+                            guard let strongSelf = self, let balance = state?.balance else {
+                                return
+                            }
+                            
+                            if case let .known(reactionSettings) = reactionSettings, let starsAllowed = reactionSettings.starsAllowed, !starsAllowed {
+                                if let peer = strongSelf.presentationInterfaceState.renderedPeer?.chatMainPeer {
+                                    strongSelf.present(standardTextAlertController(theme: AlertControllerTheme(presentationData: strongSelf.presentationData), title: nil, text: strongSelf.presentationData.strings.Chat_ToastStarsReactionsDisabled(peer.debugDisplayTitle).string, actions: [
+                                        TextAlertAction(type: .genericAction, title: strongSelf.presentationData.strings.Common_OK, action: {})
+                                    ]), in: .window(.root))
+                                }
+                                return
+                            }
+                            
+                            if balance < StarsAmount(value: 1, nanos: 0) {
+                                controller?.dismiss(completion: {
+                                    guard let strongSelf = self else {
+                                        return
+                                    }
+                                    
+                                    let _ = (strongSelf.context.engine.payments.starsTopUpOptions()
+                                    |> take(1)
+                                    |> deliverOnMainQueue).startStandalone(next: { [weak strongSelf] options in
+                                        guard let strongSelf else {
+                                            return
+                                        }
+                                        guard let starsContext = strongSelf.context.starsContext else {
+                                            return
+                                        }
+                                        
+                                        let purchaseScreen = strongSelf.context.sharedContext.makeStarsPurchaseScreen(context: strongSelf.context, starsContext: starsContext, options: options, purpose: .reactions(peerId: message.id.peerId, requiredStars: 1), targetPeerId: nil, customTheme: nil, completion: { result in
+                                            let _ = result
+                                        })
+                                        strongSelf.push(purchaseScreen)
+                                    })
+                                })
+                                
+                                return
+                            }
+                            
+                            let _ = (strongSelf.context.engine.messages.sendStarsReaction(id: message.id, count: 1, privacy: nil)
+                            |> deliverOnMainQueue).startStandalone(next: { privacy in
+                                guard let strongSelf = self else {
+                                    return
+                                }
+                                strongSelf.displayOrUpdateSendStarsUndo(messageId: message.id, count: 1, privacy: privacy)
+                            })
+                        })
+                    } else {
+                        let chosenReaction: MessageReaction.Reaction = chosenUpdatedReaction.reaction
+                        
+                        let currentReactions = mergedMessageReactions(attributes: message.attributes, isTags: message.areReactionsTags(accountPeerId: self.context.account.peerId))?.reactions ?? []
+                        var updatedReactions: [MessageReaction.Reaction] = currentReactions.filter(\.isSelected).map(\.value)
+                        var removedReaction: MessageReaction.Reaction?
+                        var isFirst = false
+                        
+                        if let index = updatedReactions.firstIndex(where: { $0 == chosenReaction }) {
+                            removedReaction = chosenReaction
+                            updatedReactions.remove(at: index)
+                        } else {
+                            updatedReactions.append(chosenReaction)
+                            isFirst = !currentReactions.contains(where: { $0.value == chosenReaction })
+                        }
+                        
+                        if message.areReactionsTags(accountPeerId: self.context.account.peerId) {
+                            if removedReaction == nil, !topReactions.contains(where: { $0.reaction.rawValue == chosenReaction }) {
+                                if !self.presentationInterfaceState.isPremium {
+                                    controller?.premiumReactionsSelected?()
+                                    return
+                                }
+                            }
+                        } else {
+                            if removedReaction == nil, case .custom = chosenReaction {
+                                if let peer = self.presentationInterfaceState.renderedPeer?.peer as? TelegramChannel, case .broadcast = peer.info {
+                                } else {
+                                    if !self.presentationInterfaceState.isPremium {
+                                        controller?.premiumReactionsSelected?()
+                                        return
+                                    }
+                                }
+                            }
+                        }
+                        
+                        self.chatDisplayNode.historyNode.forEachItemNode { itemNode in
+                            if let itemNode = itemNode as? ChatMessageItemView, let item = itemNode.item {
+                                if item.message.id == message.id {
+                                    if removedReaction == nil && !updatedReactions.isEmpty {
+                                        itemNode.awaitingAppliedReaction = (chosenReaction, { [weak self, weak itemNode] in
+                                            guard let self, let controller = controller else {
+                                                return
+                                            }
+                                            if let itemNode = itemNode, let targetView = itemNode.targetReactionView(value: chosenReaction) {
+                                                self.chatDisplayNode.messageTransitionNode.addMessageContextController(messageId: item.message.id, contextController: controller)
+                                                
+                                                var hideTargetButton: UIView?
+                                                if isFirst {
+                                                    hideTargetButton = targetView.superview
+                                                }
+                                                
+                                                controller.dismissWithReaction(value: chosenReaction, targetView: targetView, hideNode: true, animateTargetContainer: hideTargetButton, addStandaloneReactionAnimation: { [weak self] standaloneReactionAnimation in
+                                                    guard let self else {
+                                                        return
+                                                    }
+                                                    self.chatDisplayNode.messageTransitionNode.addMessageStandaloneReactionAnimation(messageId: item.message.id, standaloneReactionAnimation: standaloneReactionAnimation)
+                                                    standaloneReactionAnimation.frame = self.chatDisplayNode.bounds
+                                                    self.chatDisplayNode.addSubnode(standaloneReactionAnimation)
+                                                }, onHit: nil, completion: { [weak self, weak itemNode, weak targetView] in
+                                                    guard let self, let itemNode, let targetView else {
+                                                        return
+                                                    }
+                                                    
+                                                    if self.chatLocation.peerId == self.context.account.peerId {
+                                                        let _ = (ApplicationSpecificNotice.getSavedMessageTagLabelSuggestion(accountManager: self.context.sharedContext.accountManager)
+                                                                 |> take(1)
+                                                                 |> deliverOnMainQueue).startStandalone(next: { [weak self, weak targetView, weak itemNode] value in
+                                                            guard let self, let targetView, let itemNode else {
+                                                                return
+                                                            }
+                                                            if value >= 3 {
+                                                                return
+                                                            }
+                                                            
+                                                            let _ = itemNode
+                                                            
+                                                            let rect = self.chatDisplayNode.view.convert(targetView.bounds, from: targetView).insetBy(dx: -8.0, dy: -8.0)
+                                                            let tooltipScreen = TooltipScreen(account: self.context.account, sharedContext: self.context.sharedContext, text: .plain(text: self.presentationData.strings.Chat_TooltipAddTagLabel), location: .point(rect, .bottom), displayDuration: .manual, shouldDismissOnTouch: { _, _ in
+                                                                return .dismiss(consume: false)
+                                                            })
+                                                            self.present(tooltipScreen, in: .current)
+                                                            
+                                                            let _ = ApplicationSpecificNotice.incrementSavedMessageTagLabelSuggestion(accountManager: self.context.sharedContext.accountManager).startStandalone()
+                                                        })
+                                                    }
+                                                })
+                                            } else {
+                                                controller.dismiss()
+                                            }
+                                        })
+                                    } else {
+                                        itemNode.awaitingAppliedReaction = (nil, {
+                                            controller?.dismiss()
+                                        })
+                                    }
+                                }
+                            }
+                        }
+                        
+                        let mappedUpdatedReactions = updatedReactions.map { reaction -> UpdateMessageReaction in
+                            switch reaction {
+                            case let .builtin(value):
+                                return .builtin(value)
+                            case let .custom(fileId):
+                                var customFile: TelegramMediaFile?
+                                if case let .custom(customFileId, file) = chosenUpdatedReaction, fileId == customFileId {
+                                    customFile = file
+                                }
+                                return .custom(fileId: fileId, file: customFile)
+                            case .stars:
+                                return .stars
+                            }
+                        }
+                        
+                        let _ = updateMessageReactionsInteractively(account: self.context.account, messageIds: [message.id], reactions: mappedUpdatedReactions, isLarge: isLarge, storeAsRecentlyUsed: true).startStandalone()
+                    }
+                }
+
+                self.forEachController({ controller in
+                    if let controller = controller as? TooltipScreen {
+                        controller.dismiss()
+                    }
+                    return true
+                })
+                self.window?.presentInGlobalOverlay(controller)
+            })
+        }
+    }
+}
+
+final class ChatContextControllerContentSourceImpl: ContextControllerContentSource {
+    let controller: ViewController
+    weak var sourceNode: ASDisplayNode?
+    weak var sourceView: UIView?
+    let sourceRect: CGRect?
+    
+    let navigationController: NavigationController? = nil
+
+    let passthroughTouches: Bool
+    
+    init(controller: ViewController, sourceNode: ASDisplayNode?, sourceRect: CGRect? = nil, passthroughTouches: Bool) {
+        self.controller = controller
+        self.sourceNode = sourceNode
+        self.sourceRect = sourceRect
+        self.passthroughTouches = passthroughTouches
+    }
+    
+    init(controller: ViewController, sourceView: UIView?, sourceRect: CGRect? = nil, passthroughTouches: Bool) {
+        self.controller = controller
+        self.sourceView = sourceView
+        self.sourceRect = sourceRect
+        self.passthroughTouches = passthroughTouches
+    }
+    
+    func transitionInfo() -> ContextControllerTakeControllerInfo? {
+        let sourceView = self.sourceView
+        let sourceNode = self.sourceNode
+        let sourceRect = self.sourceRect
+        return ContextControllerTakeControllerInfo(contentAreaInScreenSpace: CGRect(origin: CGPoint(), size: CGSize(width: 10.0, height: 10.0)), sourceNode: { [weak sourceNode] in
+            if let sourceView = sourceView {
+                return (sourceView, sourceRect ?? sourceView.bounds)
+            } else if let sourceNode = sourceNode {
+                return (sourceNode.view, sourceRect ?? sourceNode.bounds)
+            } else {
+                return nil
+            }
+        })
+    }
+    
+    func animatedIn() {
+    }
+}
+
+final class ChatControllerContextReferenceContentSource: ContextReferenceContentSource {
+    let controller: ViewController
+    let sourceView: UIView
+    let insets: UIEdgeInsets
+    let contentInsets: UIEdgeInsets
+    
+    init(controller: ViewController, sourceView: UIView, insets: UIEdgeInsets, contentInsets: UIEdgeInsets = UIEdgeInsets()) {
+        self.controller = controller
+        self.sourceView = sourceView
+        self.insets = insets
+        self.contentInsets = contentInsets
+    }
+    
+    func transitionInfo() -> ContextControllerReferenceViewInfo? {
+        return ContextControllerReferenceViewInfo(referenceView: self.sourceView, contentAreaInScreenSpace: UIScreen.main.bounds.inset(by: self.insets), insets: self.contentInsets)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenMessageFactCheck.swift

@@ -0,0 +1,31 @@
+import Foundation
+import TelegramCore
+import FactCheckAlertController
+
+extension ChatControllerImpl {
+    func openEditMessageFactCheck(messageId: EngineMessage.Id) {
+        guard let message = self.chatDisplayNode.historyNode.messageInCurrentHistoryView(messageId) else {
+            return
+        }
+        var currentText: String = ""
+        var currentEntities: [MessageTextEntity] = []
+        for attribute in message.attributes {
+            if let attribute = attribute as? FactCheckMessageAttribute, case let .Loaded(text, entities, _) = attribute.content {
+                currentText = text
+                currentEntities = entities
+                break
+            }
+        }
+        let controller = factCheckAlertController(context: self.context, updatedPresentationData: self.updatedPresentationData, value: currentText, entities: currentEntities, apply: { [weak self] text, entities in
+            guard let self else {
+                return
+            }
+            if !currentText.isEmpty && text.isEmpty {
+                let _ = self.context.engine.messages.deleteMessageFactCheck(messageId: messageId).startStandalone()
+            } else {
+                let _ = self.context.engine.messages.editMessageFactCheck(messageId: messageId, text: text, entities: entities).startStandalone()
+            }
+        })
+        self.present(controller, in: .window(.root))
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenPeer.swift

@@ -0,0 +1,466 @@
+import Foundation
+import UIKit
+import Postbox
+import SwiftSignalKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SafariServices
+import MobileCoreServices
+import Intents
+import LegacyComponents
+import TelegramPresentationData
+import TelegramUIPreferences
+import DeviceAccess
+import TextFormat
+import TelegramBaseController
+import AccountContext
+import TelegramStringFormatting
+import OverlayStatusController
+import DeviceLocationManager
+import ShareController
+import UrlEscaping
+import ContextUI
+import ComposePollUI
+import AlertUI
+import PresentationDataUtils
+import UndoUI
+import TelegramCallsUI
+import TelegramNotices
+import GameUI
+import ScreenCaptureDetection
+import GalleryUI
+import OpenInExternalAppUI
+import LegacyUI
+import InstantPageUI
+import LocationUI
+import BotPaymentsUI
+import DeleteChatPeerActionSheetItem
+import HashtagSearchUI
+import LegacyMediaPickerUI
+import Emoji
+import PeerAvatarGalleryUI
+import PeerInfoUI
+import RaiseToListen
+import UrlHandling
+import AvatarNode
+import AppBundle
+import LocalizedPeerData
+import PhoneNumberFormat
+import SettingsUI
+import UrlWhitelist
+import TelegramIntents
+import TooltipUI
+import StatisticsUI
+import MediaResources
+import GalleryData
+import ChatInterfaceState
+import InviteLinksUI
+import Markdown
+import TelegramPermissionsUI
+import Speak
+import TranslateUI
+import UniversalMediaPlayer
+import WallpaperBackgroundNode
+import ChatListUI
+import CalendarMessageScreen
+import ReactionSelectionNode
+import ReactionListContextMenuContent
+import AttachmentUI
+import AttachmentTextInputPanelNode
+import MediaPickerUI
+import ChatPresentationInterfaceState
+import Pasteboard
+import ChatSendMessageActionUI
+import ChatTextLinkEditUI
+import WebUI
+import PremiumUI
+import ImageTransparency
+import StickerPackPreviewUI
+import TextNodeWithEntities
+import EntityKeyboard
+import ChatTitleView
+import EmojiStatusComponent
+import ChatTimerScreen
+import MediaPasteboardUI
+import ChatListHeaderComponent
+import ChatControllerInteraction
+import FeaturedStickersScreen
+import ChatEntityKeyboardInputNode
+import StorageUsageScreen
+import AvatarEditorScreen
+import ChatScheduleTimeController
+import ICloudResources
+import StoryContainerScreen
+import MoreHeaderButton
+import VolumeButtons
+import ChatAvatarNavigationNode
+import ChatContextQuery
+import PeerReportScreen
+import PeerSelectionController
+import SaveToCameraRoll
+import ChatMessageDateAndStatusNode
+import ReplyAccessoryPanelNode
+import TextSelectionNode
+import ChatMessagePollBubbleContentNode
+import ChatMessageItem
+import ChatMessageItemImpl
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatMessageAnimatedStickerItemNode
+import ChatMessageBubbleItemNode
+import ChatNavigationButton
+import WebsiteType
+import PeerInfoScreen
+import MediaEditorScreen
+import WallpaperGalleryScreen
+import WallpaperGridScreen
+import VideoMessageCameraScreen
+import TopMessageReactions
+import AudioWaveform
+import PeerNameColorScreen
+import ChatEmptyNode
+import ChatMediaInputStickerGridItem
+import AdsInfoScreen
+import FaceScanScreen
+import ForumCreateTopicScreen
+
+extension ChatControllerImpl {
+    func openPeer(peer: EnginePeer?, navigation: ChatControllerInteractionNavigateToPeer, fromMessage: MessageReference?, fromReactionMessageId: MessageId? = nil, expandAvatar: Bool = false, peerTypes: ReplyMarkupButtonAction.PeerTypes? = nil, skipAgeVerification: Bool = false) {
+        let _ = self.presentVoiceMessageDiscardAlert(action: {
+            if case let .peer(currentPeerId) = self.chatLocation, peer?.id == currentPeerId {
+                switch navigation {
+                    case let .info(params):
+                        var section: ChatNavigationButtonAction.ChatInfoSection?
+                        if let params {
+                            if params.switchToRecommendedChannels {
+                                section = .recommendedChannels
+                            } else if params.switchToGroupsInCommon {
+                                section = .groupsInCommon
+                            }
+                            if params.ignoreInSavedMessages && currentPeerId == self.context.account.peerId {
+                                self.playShakeAnimation()
+                                return
+                            }
+                        }
+                        self.navigationButtonAction(.openChatInfo(expandAvatar: expandAvatar, section: section))
+                    case let .chat(textInputState, _, _):
+                        if let textInputState = textInputState {
+                            self.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                return ($0.updatedInterfaceState {
+                                    return $0.withUpdatedComposeInputState(textInputState)
+                                }).updatedInputMode({ _ in
+                                    return .text
+                                })
+                            })
+                        } else {
+                            self.playShakeAnimation()
+                        }
+                    case let .withBotStartPayload(botStart):
+                        self.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                            $0.updatedBotStartPayload(botStart.payload)
+                        })
+                    case .withAttachBot:
+                        self.presentAttachmentMenu(subject: .default)
+                    default:
+                        break
+                }
+            } else {
+                if let peer = peer {
+                    do {
+                        var chatPeerId: PeerId?
+                        if let peer = self.presentationInterfaceState.renderedPeer?.chatMainPeer as? TelegramGroup {
+                            chatPeerId = peer.id
+                        } else if let peer = self.presentationInterfaceState.renderedPeer?.chatMainPeer as? TelegramChannel, case .group = peer.info, case .member = peer.participationStatus {
+                            chatPeerId = peer.id
+                        }
+                        
+                        switch navigation {
+                            case .info, .default:
+                                let peerSignal: Signal<Peer?, NoError>
+                                if let messageId = fromMessage?.id {
+                                    peerSignal = loadedPeerFromMessage(account: self.context.account, peerId: peer.id, messageId: messageId)
+                                } else {
+                                    peerSignal = self.context.account.postbox.loadedPeerWithId(peer.id) |> map(Optional.init)
+                                }
+                                self.navigationActionDisposable.set((peerSignal |> take(1) |> deliverOnMainQueue).startStrict(next: { [weak self] peer in
+                                    if let strongSelf = self, let peer = peer {
+                                        var mode: PeerInfoControllerMode = .generic
+                                        if let _ = fromMessage, let chatPeerId = chatPeerId {
+                                            mode = .group(chatPeerId)
+                                        }
+                                        if let fromReactionMessageId = fromReactionMessageId {
+                                            mode = .reaction(fromReactionMessageId)
+                                        }
+                                        if case let .info(params) = navigation, let params {
+                                            if params.switchToRecommendedChannels {
+                                                mode = .recommendedChannels
+                                            } else if params.switchToGroupsInCommon {
+                                                mode = .groupsInCommon
+                                            }
+                                        }
+                                        if peer.id == strongSelf.context.account.peerId {
+                                            mode = .myProfile
+                                        }
+                                        var expandAvatar = expandAvatar
+                                        if peer.smallProfileImage == nil {
+                                            expandAvatar = false
+                                        }
+                                        if let validLayout = strongSelf.validLayout, validLayout.deviceMetrics.type == .tablet {
+                                            expandAvatar = false
+                                        }
+                                        if let infoController = strongSelf.context.sharedContext.makePeerInfoController(context: strongSelf.context, updatedPresentationData: strongSelf.updatedPresentationData, peer: peer, mode: mode, avatarInitiallyExpanded: expandAvatar, fromChat: false, requestsContext: nil) {
+                                            strongSelf.effectiveNavigationController?.pushViewController(infoController)
+                                        }
+                                    }
+                                }))
+                            case let .chat(textInputState, subject, peekData):
+                                if let textInputState = textInputState {
+                                    let _ = (ChatInterfaceState.update(engine: self.context.engine, peerId: peer.id, threadId: nil, { currentState in
+                                        return currentState.withUpdatedComposeInputState(textInputState)
+                                    })
+                                    |> deliverOnMainQueue).startStandalone(completed: { [weak self] in
+                                        if let strongSelf = self, let navigationController = strongSelf.effectiveNavigationController {
+                                            strongSelf.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: strongSelf.context, chatLocation: .peer(peer), subject: subject, updateTextInputState: textInputState, peekData: peekData))
+                                        }
+                                    })
+                                } else {
+                                    let _ = (requireAgeVerification(context: self.context, peer: peer)
+                                    |> deliverOnMainQueue).start(next: { [weak self] require in
+                                        guard let self else {
+                                            return
+                                        }
+                                        if require && !skipAgeVerification {
+                                            presentAgeVerification(context: self.context, parentController: self, completion: {
+                                                self.openPeer(peer: peer, navigation: navigation, fromMessage: fromMessage, fromReactionMessageId: fromReactionMessageId, expandAvatar: expandAvatar, peerTypes: peerTypes)
+                                            })
+                                        } else {
+                                            if case let .channel(channel) = peer, channel.isForumOrMonoForum {
+                                                self.effectiveNavigationController?.pushViewController(ChatListControllerImpl(context: self.context, location: .forum(peerId: channel.id), controlsHistoryPreload: false, enableDebugActions: false))
+                                            } else {
+                                                self.effectiveNavigationController?.pushViewController(ChatControllerImpl(context: self.context, chatLocation: .peer(id: peer.id), subject: subject))
+                                            }
+                                        }
+                                    })
+                                }
+                            case let .withBotStartPayload(botStart):
+                                self.effectiveNavigationController?.pushViewController(ChatControllerImpl(context: self.context, chatLocation: .peer(id: peer.id), botStart: botStart))
+                            case let .withAttachBot(attachBotStart):
+                                if let navigationController = self.effectiveNavigationController {
+                                    self.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: self.context, chatLocation: .peer(peer), attachBotStart: attachBotStart))
+                                }
+                            case let .withBotApp(botAppStart):
+                                if let navigationController = self.effectiveNavigationController {
+                                    self.context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: self.context, chatLocation: .peer(peer), botAppStart: botAppStart))
+                                }
+                        }
+                    }
+                } else {
+                    switch navigation {
+                        case .info:
+                            break
+                        case let .chat(textInputState, _, _):
+                            if let textInputState = textInputState {
+                                let controller = self.context.sharedContext.makePeerSelectionController(PeerSelectionControllerParams(context: self.context, updatedPresentationData: self.updatedPresentationData, requestPeerType: peerTypes.flatMap { $0.requestPeerTypes }, selectForumThreads: true))
+                                controller.peerSelected = { [weak self, weak controller] peer, threadId in
+                                    let peerId = peer.id
+                                    
+                                    if let strongSelf = self, let strongController = controller {
+                                        if case let .peer(currentPeerId) = strongSelf.chatLocation, peerId == currentPeerId {
+                                            strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                                return ($0.updatedInterfaceState {
+                                                    return $0.withUpdatedComposeInputState(textInputState)
+                                                }).updatedInputMode({ _ in
+                                                    return .text
+                                                })
+                                            })
+                                            strongController.dismiss()
+                                        } else {
+                                            let _ = (ChatInterfaceState.update(engine: strongSelf.context.engine, peerId: peerId, threadId: threadId, { currentState in
+                                                return currentState.withUpdatedComposeInputState(textInputState)
+                                            })
+                                            |> deliverOnMainQueue).startStandalone(completed: { [weak self] in
+                                                guard let strongSelf = self else {
+                                                    return
+                                                }
+                                                strongSelf.updateChatPresentationInterfaceState(animated: false, interactive: true, { $0.updatedInterfaceState({ $0.withoutSelectionState() }) })
+                                                                                                        
+                                                if let navigationController = strongSelf.effectiveNavigationController {
+                                                    let chatController: Signal<ChatController, NoError>
+                                                    if let threadId {
+                                                        chatController = chatControllerForForumThreadImpl(context: strongSelf.context, peerId: peerId, threadId: threadId)
+                                                    } else {
+                                                        chatController = .single(ChatControllerImpl(context: strongSelf.context, chatLocation: .peer(id: peerId)))
+                                                    }
+                                                    
+                                                    let _ = (chatController
+                                                    |> deliverOnMainQueue).start(next: { [weak self, weak navigationController] chatController in
+                                                        guard let strongSelf = self, let navigationController  else {
+                                                            return
+                                                        }
+                                                        var viewControllers = navigationController.viewControllers
+                                                        let lastController = viewControllers.last as! ViewController
+                                                        if threadId != nil {
+                                                            viewControllers.remove(at: viewControllers.count - 2)
+                                                            lastController.navigationPresentation = .modal
+                                                        }
+                                                        viewControllers.insert(chatController, at: viewControllers.count - 1)
+                                                        navigationController.setViewControllers(viewControllers, animated: false)
+                                                        
+                                                        strongSelf.controllerNavigationDisposable.set((chatController.ready.get()
+                                                        |> filter { $0 }
+                                                        |> take(1)
+                                                        |> deliverOnMainQueue).startStrict(next: { [weak lastController] _ in
+                                                            lastController?.dismiss()
+                                                        }))
+                                                    })
+                                                }
+                                            })
+                                        }
+                                    }
+                                }
+                                self.chatDisplayNode.dismissInput()
+                                self.effectiveNavigationController?.pushViewController(controller)
+                            }
+                        default:
+                            break
+                    }
+                }
+            }
+        })
+    }
+    
+    func openBotForumMoreMenu(sourceView: UIView, gesture: ContextGesture?) {
+        guard let peerId = self.chatLocation.peerId else {
+            return
+        }
+        
+        let strings = self.presentationData.strings
+        
+        var items: [ContextMenuItem] = []
+        
+        if let _ = self.chatLocation.threadId {
+        } else {
+            items.append(.action(ContextMenuActionItem(text: strings.Conversation_ContextMenuOpenProfile, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Info"), color: theme.contextMenu.primaryColor)
+            }, action: { [weak self] _, f in
+                f(.default)
+                
+                guard let self, let peer = self.presentationInterfaceState.renderedPeer?.chatMainPeer else {
+                    return
+                }
+                
+                guard let controller = self.context.sharedContext.makePeerInfoController(context: self.context, updatedPresentationData: nil, peer: peer, mode: .generic, avatarInitiallyExpanded: false, fromChat: false, requestsContext: nil) else {
+                    return
+                }
+                (self.navigationController as? NavigationController)?.pushViewController(controller)
+            })))
+        }
+        
+        items.append(.separator)
+        items.append(.action(ContextMenuActionItem(text: strings.Conversation_Search, icon: { theme in
+            return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Search"), color: theme.contextMenu.primaryColor)
+        }, action: { [weak self] action in
+            action.dismissWithResult(.default)
+            
+            self?.beginMessageSearch("")
+        })))
+        
+        if let threadId = self.chatLocation.threadId, let peer = self.presentationInterfaceState.renderedPeer?.chatMainPeer, (peer is TelegramChannel || peer is TelegramGroup) {
+            items.append(.action(ContextMenuActionItem(text: strings.CreateTopic_EditTitle, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Edit"), color: theme.contextMenu.primaryColor)
+            }, action: { [weak self] action in
+                guard let self else {
+                    return
+                }
+                
+                Task { @MainActor [weak self] in
+                    guard let self else {
+                        return
+                    }
+                    
+                    guard let threadData = await self.context.engine.data.get(
+                        TelegramEngine.EngineData.Item.Peer.ThreadData(id: peerId, threadId: threadId)
+                    ).get() else {
+                        return
+                    }
+                    
+                    action.dismissWithResult(.default)
+                    
+                    let controller = ForumCreateTopicScreen(context: self.context, peerId: peerId, mode: .edit(threadId: threadId, threadInfo: threadData.info, isHidden: threadData.isHidden))
+                    controller.navigationPresentation = .modal
+                    controller.completion = { [weak self, weak controller] title, fileId, _, isHidden in
+                        guard let self else {
+                            return
+                        }
+                        let _ = (self.context.engine.peers.editForumChannelTopic(id: peerId, threadId: threadId, title: title, iconFileId: fileId)
+                        |> deliverOnMainQueue).startStandalone(completed: {
+                            controller?.dismiss()
+                        })
+                        
+                        if let isHidden {
+                            let _ = (self.context.engine.peers.setForumChannelTopicHidden(id: peerId, threadId: threadId, isHidden: isHidden)
+                            |> deliverOnMainQueue).startStandalone(completed: {
+                                controller?.dismiss()
+                            })
+                        }
+                    }
+                    self.push(controller)
+                }
+            })))
+        } else {
+            items.append(.action(ContextMenuActionItem(text: strings.Chat_CreateTopic, icon: { theme in
+                return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Edit"), color: theme.contextMenu.primaryColor)
+            }, action: { [weak self] action in
+                guard let self else {
+                    return
+                }
+                
+                action.dismissWithResult(.default)
+                
+                let controller = ForumCreateTopicScreen(context: self.context, peerId: peerId, mode: .create)
+                controller.navigationPresentation = .modal
+                
+                controller.completion = { [weak self, weak controller] title, fileId, iconColor, _ in
+                    controller?.isInProgress = true
+                    controller?.view.endEditing(true)
+                    
+                    guard let self else {
+                        return
+                    }
+                    
+                    let _ = (self.context.engine.peers.createForumChannelTopic(id: peerId, title: title, iconColor: iconColor, iconFileId: fileId)
+                             |> deliverOnMainQueue).startStandalone(next: { [weak self, weak controller] topicId in
+                        guard let self else {
+                            return
+                        }
+                        self.updateChatLocationThread(threadId: topicId)
+                        controller?.dismiss()
+                    }, error: { _ in
+                        controller?.isInProgress = false
+                    })
+                }
+                self.push(controller)
+            })))
+        }
+
+        let presentationData = self.presentationData
+        
+        let contextController = ContextController(presentationData: presentationData, source: .reference(HeaderContextReferenceContentSource(controller: self, sourceView: sourceView)), items: .single(ContextController.Items(content: .list(items))), gesture: gesture)
+        self.presentInGlobalOverlay(contextController)
+    }
+}
+
+private final class HeaderContextReferenceContentSource: ContextReferenceContentSource {
+    private let controller: ViewController
+    private let sourceView: UIView
+
+    init(controller: ViewController, sourceView: UIView) {
+        self.controller = controller
+        self.sourceView = sourceView
+    }
+
+    func transitionInfo() -> ContextControllerReferenceViewInfo? {
+        return ContextControllerReferenceViewInfo(referenceView: self.sourceView, contentAreaInScreenSpace: UIScreen.main.bounds)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenPhoneContextMenu.swift

@@ -0,0 +1,265 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import TelegramNotices
+import ContextUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import AvatarNode
+import UndoUI
+import MessageUI
+import PeerInfoUI
+import ChatControllerInteraction
+
+extension ChatControllerImpl: MFMessageComposeViewControllerDelegate {
+    func openPhoneContextMenu(number: String, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let message = params.message, let contentNode = params.contentNode else {
+            return
+        }
+        
+        guard let messages = self.chatDisplayNode.historyNode.messageGroupInCurrentHistoryView(message.id) else {
+            return
+        }
+        
+        var updatedMessages = messages
+        for i in 0 ..< updatedMessages.count {
+            if updatedMessages[i].id == message.id {
+                let message = updatedMessages.remove(at: i)
+                updatedMessages.insert(message, at: 0)
+                break
+            }
+        }
+        
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+        
+        let source: ContextContentSource
+//                if let location = location {
+//                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: messageNode.view.convert(messageNode.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+//                } else {
+            source = .extracted(ChatMessageLinkContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode))
+//                }
+        
+        params.progress?.set(.single(true))
+        
+        let _ = (self.context.engine.peers.resolvePeerByPhone(phone: number)
+        |> deliverOnMainQueue).start(next: { [weak self] peer in
+            guard let self else {
+                return
+            }
+            params.progress?.set(.single(false))
+            
+            var firstName = ""
+            var lastName = ""
+            let phoneNumber: String
+            if let peer, case let .user(user) = peer, let phone = user.phone {
+                phoneNumber = "+\(phone)"
+            } else {
+                phoneNumber = number
+            }
+            
+            if case let .user(user) = peer {
+                firstName = user.firstName ?? ""
+                lastName = user.lastName ?? ""
+            }
+            
+            var items: [ContextMenuItem] = []
+            items.append(
+                .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_AddToContacts, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/AddUser"), color: theme.contextMenu.primaryColor) }, action: { [weak self] c, _ in
+                    guard let self, let c else {
+                        return
+                    }
+                    let basicData = DeviceContactBasicData(firstName: firstName, lastName: lastName, phoneNumbers: [
+                        DeviceContactPhoneNumberData(label: "", value: phoneNumber)
+                    ])
+                    let contactData = DeviceContactExtendedData(basicData: basicData, middleName: "", prefix: "", suffix: "", organization: "", jobTitle: "", department: "", emailAddresses: [], urls: [], addresses: [], birthdayDate: nil, socialProfiles: [], instantMessagingProfiles: [], note: "")
+                    
+                    pushContactContextOptionsController(context: self.context, contextController: c, presentationData: self.presentationData, peer: nil, contactData: contactData, parentController: self, push: { [weak self] c in
+                        self?.push(c)
+                    })
+                }))
+            )
+            items.append(.separator)
+            if let peer {
+                if peer.id == self.context.account.peerId {
+                    
+                } else {
+                    items.append(
+                        .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_SendMessage, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/MessageBubble"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                            f(.default)
+                            guard let self else {
+                                return
+                            }
+                            self.openPeer(peer: peer, navigation: .chat(textInputState: nil, subject: nil, peekData: nil), fromMessage: nil)
+                        }))
+                    )
+                    items.append(
+                        .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_TelegramVoiceCall, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Call"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                            f(.default)
+                            
+                            guard let self else {
+                                return
+                            }
+                            self.controllerInteraction?.callPeer(peer.id, false)
+                        }))
+                    )
+                    items.append(
+                        .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_TelegramVideoCall, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/VideoCall"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                            f(.default)
+                            
+                            guard let self else {
+                                return
+                            }
+                            self.controllerInteraction?.callPeer(peer.id, true)
+                        }))
+                    )
+                }
+            } else {
+                items.append(
+                    .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_InviteToTelegram, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Telegram"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                        f(.default)
+                        
+                        guard let self else {
+                            return
+                        }
+                        self.inviteToTelegram(numbers: [number])
+                    }))
+                )
+            }
+            if number.hasPrefix("+888") {
+                
+            } else {
+                items.append(
+                    .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_CallViaCarrier, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/PhoneCall"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                        f(.default)
+                        
+                        guard let self else {
+                            return
+                        }
+                        self.openUrl("tel:\(phoneNumber)", concealed: false)
+                    }))
+                )
+            }
+            
+            items.append(
+                .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_CopyNumber, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                    f(.default)
+
+                    guard let self else {
+                        return
+                    }
+                    
+                    UIPasteboard.general.string = number
+
+                    self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: presentationData.strings.Conversation_PhoneCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+                }))
+            )
+            
+            items.append(.separator)
+            if let peer {
+                let avatarSize = CGSize(width: 28.0, height: 28.0)
+                let avatarSignal = peerAvatarCompleteImage(account: self.context.account, peer: peer, size: avatarSize)
+                
+                let subtitle = NSMutableAttributedString(string: self.presentationData.strings.Chat_Context_Phone_ViewProfile + " >")
+                if let range = subtitle.string.range(of: ">"), let arrowImage = UIImage(bundleImageName: "Item List/InlineTextRightArrow") {
+                    subtitle.addAttribute(.attachment, value: arrowImage, range: NSRange(range, in: subtitle.string))
+                    subtitle.addAttribute(.baselineOffset, value: 1.0, range: NSRange(range, in: subtitle.string))
+                }
+                
+                items.append(
+                    .action(ContextMenuActionItem(text: peer.displayTitle(strings: self.presentationData.strings, displayOrder: self.presentationData.nameDisplayOrder), textLayout: .secondLineWithAttributedValue(subtitle), icon: { theme in return nil }, iconSource: ContextMenuActionItemIconSource(size: avatarSize, signal: avatarSignal), iconPosition: .left, action: { [weak self]  _, f in
+                        f(.default)
+                        
+                        guard let self else {
+                            return
+                        }
+                        self.openPeer(peer: peer, navigation: .info(ChatControllerInteractionNavigateToPeer.InfoParams(ignoreInSavedMessages: true)), fromMessage: nil)
+                    }))
+                )
+            } else {
+                let emptyAction: ((ContextMenuActionItem.Action) -> Void)? = nil
+                items.append(
+                    .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Phone_NotOnTelegram, textLayout: .multiline, textFont: .small, icon: { _ in return nil }, action: emptyAction))
+                )
+            }
+            
+            self.canReadHistory.set(false)
+            
+            let controller = ContextController(presentationData: self.presentationData, source: source, items: .single(ContextController.Items(content: .list(items))), recognizer: recognizer, gesture: gesture, disableScreenshots: false)
+            controller.dismissed = { [weak self] in
+                self?.canReadHistory.set(true)
+            }
+            
+            self.window?.presentInGlobalOverlay(controller)
+        })
+    }
+    
+    private func inviteToTelegram(numbers: [String]) {
+        if MFMessageComposeViewController.canSendText() {
+            let composer = MFMessageComposeViewController()
+            composer.messageComposeDelegate = self
+            composer.recipients = Array(Set(numbers))
+            let url = self.presentationData.strings.InviteText_URL
+            let body = self.presentationData.strings.InviteText_SingleContact(url).string
+            composer.body = body
+            self.messageComposeController = composer
+            if let window = self.view.window {
+                window.rootViewController?.present(composer, animated: true)
+            }
+        }
+    }
+    
+    @objc public func messageComposeViewController(_ controller: MFMessageComposeViewController, didFinishWith result: MessageComposeResult) {
+        self.messageComposeController = nil
+        
+        controller.dismiss(animated: true, completion: nil)
+    }
+}
+
+final class ChatMessageLinkContextExtractedContentSource: ContextExtractedContentSource {
+    let keepInPlace: Bool = false
+    let ignoreContentTouches: Bool = true
+    let blurBackground: Bool = true
+    let adjustContentHorizontally = true
+    
+    private weak var chatNode: ChatControllerNode?
+    private let contentNode: ContextExtractedContentContainingNode
+    
+    var shouldBeDismissed: Signal<Bool, NoError> {
+        return .single(false)
+    }
+    
+    init(chatNode: ChatControllerNode, contentNode: ContextExtractedContentContainingNode) {
+        self.chatNode = chatNode
+        self.contentNode = contentNode
+    }
+    
+    func takeView() -> ContextControllerTakeViewInfo? {
+        guard let chatNode = self.chatNode else {
+            return nil
+        }
+        
+        let transition = ContainedViewLayoutTransition.animated(duration: 0.2, curve: .easeInOut)
+        transition.updateAlpha(node: self.contentNode.contentNode, alpha: 1.0)
+        
+        return ContextControllerTakeViewInfo(containingItem: .node(self.contentNode), contentAreaInScreenSpace: chatNode.convert(chatNode.frameForVisibleArea(), to: nil))
+    }
+    
+    func putBack() -> ContextControllerPutBackViewInfo? {
+        guard let chatNode = self.chatNode else {
+            return nil
+        }
+        
+        let transition = ContainedViewLayoutTransition.animated(duration: 0.2, curve: .easeInOut)
+        transition.updateAlpha(node: self.contentNode.contentNode, alpha: 0.0, completion: { _ in
+            self.contentNode.removeFromSupernode()
+        })
+        
+        return ContextControllerPutBackViewInfo(contentAreaInScreenSpace: chatNode.convert(chatNode.frameForVisibleArea(), to: nil))
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenTimecodeContextMenu.swift

@@ -0,0 +1,122 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatControllerInteraction
+
+extension ChatControllerImpl {
+    func openTimecodeContextMenu(timecode: String, value: Double, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let message = params.message, let contentNode = params.contentNode else {
+            return
+        }
+        
+        guard let messages = self.chatDisplayNode.historyNode.messageGroupInCurrentHistoryView(message.id) else {
+            return
+        }
+            
+        var updatedMessages = messages
+        for i in 0 ..< updatedMessages.count {
+            if updatedMessages[i].id == message.id {
+                let message = updatedMessages.remove(at: i)
+                updatedMessages.insert(message, at: 0)
+                break
+            }
+        }
+               
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+        
+        let source: ContextContentSource
+//                if let location = location {
+//                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: messageNode.view.convert(messageNode.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+//                } else {
+            source = .extracted(ChatMessageLinkContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode))
+//                }
+        
+        var items: [ContextMenuItem] = []
+        
+        items.append(
+            .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Timecode_Copy, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                f(.default)
+
+                guard let self else {
+                    return
+                }
+                
+                if message.id.namespace == Namespaces.Message.Cloud, let channel = message.peers[message.id.peerId] as? TelegramChannel, let addressName = channel.addressName {
+                    var timestampSuffix = ""
+                    let startAtTimestamp = parseTimeString(timecode)
+                    
+                    var startAtTimestampString = ""
+                    let hours = startAtTimestamp / 3600
+                    let minutes = startAtTimestamp / 60 % 60
+                    let seconds = startAtTimestamp % 60
+                    if hours == 0 && minutes == 0 {
+                        startAtTimestampString = "\(startAtTimestamp)"
+                    } else {
+                        if hours != 0 {
+                            startAtTimestampString += "\(hours)h"
+                        }
+                        if minutes != 0 {
+                            startAtTimestampString += "\(minutes)m"
+                        }
+                        if seconds != 0 {
+                            startAtTimestampString += "\(seconds)s"
+                        }
+                    }
+                    timestampSuffix = "?t=\(startAtTimestampString)"
+                    let inputCopyText = "https://t.me/\(addressName)/\(message.id.id)\(timestampSuffix)"
+                    UIPasteboard.general.string = inputCopyText
+                } else {
+                    UIPasteboard.general.string = timecode
+                }
+
+                self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: presentationData.strings.Conversation_TextCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+            }))
+        )
+         
+        self.canReadHistory.set(false)
+        
+        let controller = ContextController(presentationData: self.presentationData, source: source, items: .single(ContextController.Items(content: .list(items))), recognizer: recognizer, gesture: gesture, disableScreenshots: false)
+        controller.dismissed = { [weak self] in
+            self?.canReadHistory.set(true)
+        }
+        
+        self.window?.presentInGlobalOverlay(controller)
+    }
+}
+
+private func parseTimeString(_ timeString: String) -> Int {
+    let parts = timeString.split(separator: ":").map(String.init)
+    
+    switch parts.count {
+    case 1:
+        // Single component (e.g. "1", "10") => seconds
+        return Int(parts[0]) ?? 0
+        
+    case 2:
+        // Two components (e.g. "1:01", "10:30") => minutes:seconds
+        let minutes = Int(parts[0]) ?? 0
+        let seconds = Int(parts[1]) ?? 0
+        return minutes * 60 + seconds
+        
+    case 3:
+        // Three components (e.g. "1:01:01", "10:00:00") => hours:minutes:seconds
+        let hours = Int(parts[0]) ?? 0
+        let minutes = Int(parts[1]) ?? 0
+        let seconds = Int(parts[2]) ?? 0
+        return hours * 3600 + minutes * 60 + seconds
+        
+    default:
+        // Fallback to 0 or handle invalid format
+        return 0
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenTodoContextMenu.swift

@@ -0,0 +1,308 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import AvatarNode
+import ChatControllerInteraction
+import Pasteboard
+import TelegramStringFormatting
+import TelegramPresentationData
+
+private enum OptionsId: Hashable {
+    case item
+    case message
+}
+
+extension ChatControllerImpl {
+    func openTodoItemContextMenu(todoItemId: Int32, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let message = params.message, let todo = message.media.first(where: { $0 is TelegramMediaTodo }) as? TelegramMediaTodo, let todoItem = todo.items.first(where: { $0.id == todoItemId }), let contentNode = params.contentNode else {
+            return
+        }
+        
+        let completion = todo.completions.first(where: { $0.id == todoItemId })
+                
+//        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+//        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+        
+        var canMark = false
+        if (todo.flags.contains(.othersCanComplete) || message.author?.id == context.account.peerId) {
+            canMark = true
+        }
+        let canEdit = canEditMessage(context: self.context, limitsConfiguration: self.context.currentLimitsConfiguration.with { EngineConfiguration.Limits($0) }, message: message)
+        
+        let _ = (contextMenuForChatPresentationInterfaceState(chatPresentationInterfaceState: self.presentationInterfaceState, context: self.context, messages: [message], controllerInteraction: self.controllerInteraction, selectAll: false, interfaceInteraction: self.interfaceInteraction, messageNode: params.messageNode as? ChatMessageItemView)
+        |> deliverOnMainQueue).start(next: { [weak self] actions in
+            guard let self else {
+                return
+            }
+          
+            var items: [ContextMenuItem] = []
+            if let completion {
+                let dateText = humanReadableStringForTimestamp(strings: self.presentationData.strings, dateTimeFormat: self.presentationData.dateTimeFormat, timestamp: completion.date, alwaysShowTime: true, allowYesterday: true, format: HumanReadableStringFormat(
+                    dateFormatString: { value in
+                        return PresentationStrings.FormattedString(string: self.presentationData.strings.Chat_TodoItemCompletionTimestamp_Date(value).string, ranges: [])
+                    },
+                    tomorrowFormatString: { value in
+                        return PresentationStrings.FormattedString(string: self.presentationData.strings.Chat_TodoItemCompletionTimestamp_TodayAt(value).string, ranges: [])
+                    },
+                    todayFormatString: { value in
+                        return PresentationStrings.FormattedString(string: self.presentationData.strings.Chat_TodoItemCompletionTimestamp_TodayAt(value).string, ranges: [])
+                    },
+                    yesterdayFormatString: { value in
+                        return PresentationStrings.FormattedString(string: self.presentationData.strings.Chat_TodoItemCompletionTimestamp_YesterdayAt(value).string, ranges: [])
+                    }
+                )).string
+                
+                let nop: ((ContextMenuActionItem.Action) -> Void)? = nil
+                items.append(.action(ContextMenuActionItem(text: dateText, textFont: .small, icon: { _ in return nil }, action: nop)))
+                items.append(.separator)
+                
+                if canMark {
+                    items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Todo_ContextMenu_UncheckTask, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Clear"), color: theme.contextMenu.primaryColor) }, action: { [weak self] c, f in
+                        guard let self else {
+                            return
+                        }
+                        
+                        if !self.context.isPremium {
+                            f(.default)
+                            let controller = UndoOverlayController(
+                                presentationData: self.presentationData,
+                                content: .premiumPaywall(title: nil, text: self.presentationData.strings.Chat_Todo_PremiumRequired, customUndoText: nil, timeout: nil, linkAction: nil),
+                                action: { [weak self] action in
+                                    guard let self else {
+                                        return false
+                                    }
+                                    if case .info = action {
+                                        let controller = self.context.sharedContext.makePremiumIntroController(context: context, source: .presence, forceDark: false, dismissed: nil)
+                                        self.push(controller)
+                                    }
+                                    return false
+                                }
+                            )
+                            self.present(controller, in: .current)
+                        } else {
+                            c?.dismiss(completion: {
+                                let _ = self.context.engine.messages.requestUpdateTodoMessageItems(messageId: message.id, completedIds: [], incompletedIds: [todoItemId]).start()
+                            })
+                        }
+                    })))
+                }
+            } else {
+                if canMark {
+                    items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Todo_ContextMenu_CheckTask, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Select"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  c, f in
+                        guard let self else {
+                            return
+                        }
+                        
+                        if !self.context.isPremium {
+                            f(.default)
+                            let controller = UndoOverlayController(
+                                presentationData: self.presentationData,
+                                content: .premiumPaywall(title: nil, text: self.presentationData.strings.Chat_Todo_PremiumRequired, customUndoText: nil, timeout: nil, linkAction: nil),
+                                action: { [weak self] action in
+                                    guard let self else {
+                                        return false
+                                    }
+                                    if case .info = action {
+                                        let controller = self.context.sharedContext.makePremiumIntroController(context: context, source: .presence, forceDark: false, dismissed: nil)
+                                        self.push(controller)
+                                    }
+                                    return false
+                                }
+                            )
+                            self.present(controller, in: .current)
+                        } else {
+                            c?.dismiss(completion: {
+                                let _ = self.context.engine.messages.requestUpdateTodoMessageItems(messageId: message.id, completedIds: [todoItemId], incompletedIds: []).start()
+                            })
+                        }
+                    })))
+                }
+            }
+            
+            if canReplyInChat(self.presentationInterfaceState, accountPeerId: self.context.account.peerId) {
+                items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Todo_ReplyToItem, icon: { theme in
+                    return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Reply"), color: theme.actionSheet.primaryTextColor)
+                }, action: { [weak self] c, _ in
+                    guard let self else {
+                        return
+                    }
+                    self.interfaceInteraction?.setupReplyMessage(message.id, todoItem.id, { transition, completed in
+                        c?.dismiss(result: .custom(transition), completion: {
+                            completed()
+                        })
+                    })
+                })))
+            }
+            
+            items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Conversation_ContextMenuCopy, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                f(.default)
+
+                guard let self else {
+                    return
+                }
+                storeMessageTextInPasteboard(todoItem.text, entities: todoItem.entities)
+               
+                self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: presentationData.strings.Conversation_TextCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+            })))
+            
+            var isReplyThreadHead = false
+            if case let .replyThread(replyThreadMessage) = self.presentationInterfaceState.chatLocation {
+                isReplyThreadHead = message.id == replyThreadMessage.effectiveTopId
+            }
+            
+            if message.id.namespace == Namespaces.Message.Cloud, let channel = message.peers[message.id.peerId] as? TelegramChannel, !channel.isMonoForum, !isReplyThreadHead {
+                items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Conversation_ContextMenuCopyLink, icon: { theme in
+                    return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Link"), color: theme.contextMenu.primaryColor)
+                }, action: { [weak self] _, f in
+                    guard let self else {
+                        return
+                    }
+                    var threadMessageId: MessageId?
+                    if case let .replyThread(replyThreadMessage) = self.presentationInterfaceState.chatLocation {
+                        threadMessageId = replyThreadMessage.effectiveMessageId
+                    }
+                    let _ = (self.context.engine.messages.exportMessageLink(peerId: message.id.peerId, messageId: message.id, isThread: threadMessageId != nil)
+                    |> map { result -> String? in
+                        return result
+                    }
+                    |> deliverOnMainQueue).startStandalone(next: { [weak self] link in
+                        guard let self, let link else {
+                            return
+                        }
+                        UIPasteboard.general.string = link + "?task=\(todoItemId)"
+                        
+                        let presentationData = self.context.sharedContext.currentPresentationData.with { $0 }
+                        
+                        var warnAboutPrivate = false
+                        if case .peer = self.presentationInterfaceState.chatLocation {
+                            if channel.addressName == nil {
+                                warnAboutPrivate = true
+                            }
+                        }
+                        Queue.mainQueue().after(0.2, {
+                            if warnAboutPrivate {
+                                self.controllerInteraction?.displayUndo(.linkCopied(title: nil, text: presentationData.strings.Conversation_PrivateMessageLinkCopiedLong))
+                            } else {
+                                self.controllerInteraction?.displayUndo(.linkCopied(title: nil, text: presentationData.strings.Conversation_LinkCopied))
+                            }
+                        })
+                    })
+                    f(.default)
+                })))
+            }
+            
+            if canEdit {
+                items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Todo_ContextMenu_EditTask, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Edit"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                    f(.default)
+                    
+                    guard let self else {
+                        return
+                    }
+                    
+                    self.interfaceInteraction?.editTodoMessage(message.id, todoItemId, false)
+                })))
+                
+                if todo.items.count > 1 {
+                    items.append(.separator)
+                    
+                    items.append(.action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Todo_ContextMenu_DeleteTask, textColor: .destructive, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Delete"), color: theme.contextMenu.destructiveColor) }, action: { [weak self]  _, f in
+                        f(.default)
+                        
+                        guard let self else {
+                            return
+                        }
+                        
+                        let updatedItems = todo.items.filter { $0.id != todoItemId }
+                        let updatedTodo = todo.withUpdated(items: updatedItems)
+                        
+                        let _ = self.context.engine.messages.requestEditMessage(
+                            messageId: message.id,
+                            text: "",
+                            media: .update(.standalone(media: updatedTodo)),
+                            entities: nil,
+                            inlineStickers: [:]
+                        ).start()
+                    })))
+                }
+            }
+            
+            self.canReadHistory.set(false)
+            
+            var sources: [ContextController.Source] = []
+            sources.append(
+                ContextController.Source(
+                    id: AnyHashable(OptionsId.item),
+                    title: self.presentationData.strings.Chat_Todo_ContextMenu_SectionTask,
+                    footer: self.presentationData.strings.Chat_Todo_ContextMenu_SectionsInfo,
+                    source: .extracted(ChatTodoItemContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode)),
+                    items: .single(ContextController.Items(content: .list(items)))
+                )
+            )
+            
+            let messageContentSource = ChatMessageContextExtractedContentSource(chatController: self, chatNode: self.chatDisplayNode, engine: self.context.engine, message: message, selectAll: false, snapshot: true)
+            
+            sources.append(
+                ContextController.Source(
+                    id: AnyHashable(OptionsId.message),
+                    title: self.presentationData.strings.Chat_Todo_ContextMenu_SectionList,
+                    source: .extracted(messageContentSource),
+                    items: .single(actions)
+                )
+            )
+            
+            contentNode.onDismiss = { [weak messageContentSource] in
+                messageContentSource?.snapshotView?.removeFromSuperview()
+            }
+            
+            let contextController = ContextController(
+                presentationData: self.presentationData,
+                configuration: ContextController.Configuration(
+                    sources: sources,
+                    initialId: AnyHashable(OptionsId.item)
+                )
+            )
+            contextController.dismissed = { [weak self] in
+                self?.canReadHistory.set(true)
+            }
+            
+            self.window?.presentInGlobalOverlay(contextController)
+        })
+    }
+}
+
+final class ChatTodoItemContextExtractedContentSource: ContextExtractedContentSource {
+    let keepInPlace: Bool = false
+    let ignoreContentTouches: Bool = false
+    let blurBackground: Bool = true
+    
+    private weak var chatNode: ChatControllerNode?
+    private let contentNode: ContextExtractedContentContainingNode
+    
+    init(chatNode: ChatControllerNode, contentNode: ContextExtractedContentContainingNode) {
+        self.chatNode = chatNode
+        self.contentNode = contentNode
+    }
+    
+    func takeView() -> ContextControllerTakeViewInfo? {
+        guard let chatNode = self.chatNode else {
+            return nil
+        }
+        return ContextControllerTakeViewInfo(containingItem: .node(self.contentNode), contentAreaInScreenSpace: chatNode.convert(chatNode.frameForVisibleArea(), to: nil))
+    }
+    
+    func putBack() -> ContextControllerPutBackViewInfo? {
+        guard let chatNode = self.chatNode else {
+            return nil
+        }
+        return ContextControllerPutBackViewInfo(contentAreaInScreenSpace: chatNode.convert(chatNode.frameForVisibleArea(), to: nil))
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenUsernameContextMenu.swift

@@ -0,0 +1,148 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatMessageItemView
+import ChatMessageItemCommon
+import AvatarNode
+import ChatControllerInteraction
+
+extension ChatControllerImpl {
+    func openMentionContextMenu(username: String, peerId: EnginePeer.Id?, params: ChatControllerInteraction.LongTapParams) -> Void {
+        guard let _ = params.message, let contentNode = params.contentNode else {
+            return
+        }
+    
+        let recognizer: TapLongTapOrDoubleTapGestureRecognizer? = nil// anyRecognizer as? TapLongTapOrDoubleTapGestureRecognizer
+        let gesture: ContextGesture? = nil // anyRecognizer as? ContextGesture
+        
+        let source: ContextContentSource
+//                if let location = location {
+//                    source = .location(ChatMessageContextLocationContentSource(controller: self, location: messageNode.view.convert(messageNode.bounds, to: nil).origin.offsetBy(dx: location.x, dy: location.y)))
+//                } else {
+            source = .extracted(ChatMessageLinkContextExtractedContentSource(chatNode: self.chatDisplayNode, contentNode: contentNode))
+//                }
+        
+        params.progress?.set(.single(true))
+                
+        let peer: Signal<EnginePeer?, NoError>
+        if let peerId {
+            peer = self.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId))
+        } else {
+            peer = self.context.engine.peers.resolvePeerByName(name: username, referrer: nil)
+            |> mapToSignal { value in
+                switch value {
+                case .progress:
+                    return .complete()
+                case let .result(result):
+                    return .single(result)
+                }
+            }
+        }
+        
+        let _ = (peer
+        |> deliverOnMainQueue).start(next: { [weak self] peer in
+            guard let self else {
+                return
+            }
+            params.progress?.set(.single(false))
+                         
+            var items: [ContextMenuItem] = []
+            if let peer {
+                if case .user = peer {
+                    items.append(
+                        .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Username_SendMessage, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/MessageBubble"), color: theme.contextMenu.primaryColor) }, action: { [weak self] _, f in
+                            f(.default)
+                            guard let self else {
+                                return
+                            }
+                            self.openPeer(peer: peer, navigation: .chat(textInputState: nil, subject: nil, peekData: nil), fromMessage: nil)
+                        }))
+                    )
+                } else {
+                    var isGroup = true
+                    if case let .channel(channel) = peer, case .broadcast = channel.info {
+                        isGroup = false
+                    }
+                    
+                    let openTitle: String
+                    let openIcon: UIImage?
+                    
+                    if isGroup {
+                        openTitle = self.presentationData.strings.Chat_Context_Username_OpenGroup
+                        openIcon = UIImage(bundleImageName: "Chat/Context Menu/Groups")
+                    } else {
+                        openTitle = self.presentationData.strings.Chat_Context_Username_OpenChannel
+                        openIcon = UIImage(bundleImageName: "Chat/Context Menu/Channels")
+                    }
+                    items.append(
+                        .action(ContextMenuActionItem(text: openTitle, icon: { theme in return generateTintedImage(image: openIcon, color: theme.contextMenu.primaryColor) }, action: { [weak self] _, f in
+                            f(.default)
+                            guard let self else {
+                                return
+                            }
+                            self.openPeer(peer: peer, navigation: .chat(textInputState: nil, subject: nil, peekData: nil), fromMessage: nil)
+                        }))
+                    )
+                }
+            }
+            
+            items.append(
+                .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Username_Copy, icon: { theme in return generateTintedImage(image: UIImage(bundleImageName: "Chat/Context Menu/Copy"), color: theme.contextMenu.primaryColor) }, action: { [weak self]  _, f in
+                    f(.default)
+
+                    guard let self else {
+                        return
+                    }
+                    
+                    UIPasteboard.general.string = username
+
+                    self.present(UndoOverlayController(presentationData: self.presentationData, content: .copy(text: presentationData.strings.Conversation_UsernameCopied), elevatedLayout: false, animateInAsReplacement: false, action: { _ in return false }), in: .current)
+                }))
+            )
+            
+            items.append(.separator)
+            if let peer {
+                let avatarSize = CGSize(width: 28.0, height: 28.0)
+                let avatarSignal = peerAvatarCompleteImage(account: self.context.account, peer: peer, size: avatarSize)
+                
+                let subtitle = NSMutableAttributedString(string: self.presentationData.strings.Chat_Context_Phone_ViewProfile + " >")
+                if let range = subtitle.string.range(of: ">"), let arrowImage = UIImage(bundleImageName: "Item List/InlineTextRightArrow") {
+                    subtitle.addAttribute(.attachment, value: arrowImage, range: NSRange(range, in: subtitle.string))
+                    subtitle.addAttribute(.baselineOffset, value: 1.0, range: NSRange(range, in: subtitle.string))
+                }
+                
+                items.append(
+                    .action(ContextMenuActionItem(text: peer.displayTitle(strings: self.presentationData.strings, displayOrder: self.presentationData.nameDisplayOrder), textLayout: .secondLineWithAttributedValue(subtitle), icon: { theme in return nil }, iconSource: ContextMenuActionItemIconSource(size: avatarSize, signal: avatarSignal), iconPosition: .left, action: { [weak self]  _, f in
+                        f(.default)
+                        
+                        guard let self else {
+                            return
+                        }
+                        self.openPeer(peer: peer, navigation: .info(ChatControllerInteractionNavigateToPeer.InfoParams(ignoreInSavedMessages: true)), fromMessage: nil)
+                    }))
+                )
+            } else {
+                let emptyAction: ((ContextMenuActionItem.Action) -> Void)? = nil
+                items.append(
+                    .action(ContextMenuActionItem(text: self.presentationData.strings.Chat_Context_Username_NotOnTelegram, textLayout: .multiline, textFont: .small, icon: { _ in return nil }, action: emptyAction))
+                )
+            }
+            
+            self.canReadHistory.set(false)
+            
+            let controller = ContextController(presentationData: self.presentationData, source: source, items: .single(ContextController.Items(content: .list(items))), recognizer: recognizer, gesture: gesture, disableScreenshots: false)
+            controller.dismissed = { [weak self] in
+                self?.canReadHistory.set(true)
+            }
+            
+            self.window?.presentInGlobalOverlay(controller)
+        })
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenViewOnceMediaMessage.swift

@@ -0,0 +1,182 @@
+import Foundation
+import UIKit
+import Postbox
+import SwiftSignalKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SafariServices
+import MobileCoreServices
+import Intents
+import LegacyComponents
+import TelegramPresentationData
+import TelegramUIPreferences
+import DeviceAccess
+import TextFormat
+import TelegramBaseController
+import AccountContext
+import TelegramStringFormatting
+import OverlayStatusController
+import DeviceLocationManager
+import ShareController
+import UrlEscaping
+import ContextUI
+import ComposePollUI
+import AlertUI
+import PresentationDataUtils
+import UndoUI
+import TelegramCallsUI
+import TelegramNotices
+import GameUI
+import ScreenCaptureDetection
+import GalleryUI
+import OpenInExternalAppUI
+import LegacyUI
+import InstantPageUI
+import LocationUI
+import BotPaymentsUI
+import DeleteChatPeerActionSheetItem
+import HashtagSearchUI
+import LegacyMediaPickerUI
+import Emoji
+import PeerAvatarGalleryUI
+import PeerInfoUI
+import RaiseToListen
+import UrlHandling
+import AvatarNode
+import AppBundle
+import LocalizedPeerData
+import PhoneNumberFormat
+import SettingsUI
+import UrlWhitelist
+import TelegramIntents
+import TooltipUI
+import StatisticsUI
+import MediaResources
+import GalleryData
+import ChatInterfaceState
+import InviteLinksUI
+import Markdown
+import TelegramPermissionsUI
+import Speak
+import TranslateUI
+import UniversalMediaPlayer
+import WallpaperBackgroundNode
+import ChatListUI
+import CalendarMessageScreen
+import ReactionSelectionNode
+import ReactionListContextMenuContent
+import AttachmentUI
+import AttachmentTextInputPanelNode
+import MediaPickerUI
+import ChatPresentationInterfaceState
+import Pasteboard
+import ChatSendMessageActionUI
+import ChatTextLinkEditUI
+import WebUI
+import PremiumUI
+import ImageTransparency
+import StickerPackPreviewUI
+import TextNodeWithEntities
+import EntityKeyboard
+import ChatTitleView
+import EmojiStatusComponent
+import ChatTimerScreen
+import MediaPasteboardUI
+import ChatListHeaderComponent
+import ChatControllerInteraction
+import FeaturedStickersScreen
+import ChatEntityKeyboardInputNode
+import StorageUsageScreen
+import AvatarEditorScreen
+import ChatScheduleTimeController
+import ICloudResources
+import StoryContainerScreen
+import MoreHeaderButton
+import VolumeButtons
+import ChatAvatarNavigationNode
+import ChatContextQuery
+import PeerReportScreen
+import PeerSelectionController
+import SaveToCameraRoll
+import ChatMessageDateAndStatusNode
+import ReplyAccessoryPanelNode
+import TextSelectionNode
+import ChatMessagePollBubbleContentNode
+import ChatMessageItem
+import ChatMessageItemImpl
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatMessageAnimatedStickerItemNode
+import ChatMessageBubbleItemNode
+import ChatNavigationButton
+import WebsiteType
+import PeerInfoScreen
+import MediaEditorScreen
+import WallpaperGalleryScreen
+import WallpaperGridScreen
+import VideoMessageCameraScreen
+import TopMessageReactions
+import AudioWaveform
+import PeerNameColorScreen
+import ChatEmptyNode
+import ChatMediaInputStickerGridItem
+import AdsInfoScreen
+
+extension ChatControllerImpl {
+    func openViewOnceMediaMessage(_ message: Message) {
+        if self.screenCaptureManager?.isRecordingActive == true {
+            let controller = textAlertController(context: self.context, updatedPresentationData: self.updatedPresentationData, title: nil, text: self.presentationData.strings.Chat_PlayOnceMesasge_DisableScreenCapture, actions: [TextAlertAction(type: .defaultAction, title: self.presentationData.strings.Common_OK, action: {
+            })])
+            self.present(controller, in: .window(.root))
+            return
+        }
+        
+        let isIncoming = message.effectivelyIncoming(self.context.account.peerId)
+        
+        var presentImpl: ((ViewController) -> Void)?
+        let configuration = ContextController.Configuration(
+            sources: [
+                ContextController.Source(
+                    id: 0,
+                    title: "",
+                    source: .extracted(ChatViewOnceMessageContextExtractedContentSource(
+                        context: self.context,
+                        presentationData: self.presentationData,
+                        chatNode: self.chatDisplayNode,
+                        backgroundNode: self.chatBackgroundNode,
+                        engine: self.context.engine,
+                        message: message,
+                        present: { c in
+                            presentImpl?(c)
+                        }
+                    )),
+                    items: .single(ContextController.Items(content: .list([]))),
+                    closeActionTitle: isIncoming ? self.presentationData.strings.Chat_PlayOnceMesasgeCloseAndDelete : self.presentationData.strings.Chat_PlayOnceMesasgeClose,
+                    closeAction: { [weak self] in
+                        if let self {
+                            self.context.sharedContext.mediaManager.setPlaylist(nil, type: .voice, control: .playback(.pause))
+                        }
+                    }
+                )
+            ], initialId: 0
+        )
+        
+        let contextController = ContextController(presentationData: self.presentationData, configuration: configuration)
+        contextController.getOverlayViews = { [weak self] in
+            guard let self else {
+                return []
+            }
+            return [self.chatDisplayNode.navigateButtons.view]
+        }
+        self.currentContextController = contextController
+        self.presentInGlobalOverlay(contextController)
+        
+        presentImpl = { [weak contextController] c in
+            contextController?.present(c, in: .current)
+        }
+        
+        let _ = self.context.sharedContext.openChatMessage(OpenChatMessageParams(context: self.context, chatLocation: nil, chatFilterTag: nil, chatLocationContextHolder: nil, message: message, standalone: false, reverseMessageGalleryOrder: false, navigationController: nil, dismissInput: { }, present: { _, _, _ in }, transitionNode: { _, _, _ in return nil }, addToTransitionSurface: { _ in }, openUrl: { _ in }, openPeer: { _, _ in }, callPeer: { _, _ in }, openConferenceCall: { _ in
+        }, enqueueMessage: { _ in }, sendSticker: nil, sendEmoji: nil, setupTemporaryHiddenMedia: { _, _, _ in }, chatAvatarHiddenMedia: { _, _ in }, playlistLocation: .singleMessage(message.id)))
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerOpenWebApp.swift

@@ -0,0 +1,718 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import ChatPresentationInterfaceState
+import ChatControllerInteraction
+import WebUI
+import AttachmentUI
+import AccountContext
+import TelegramNotices
+import PresentationDataUtils
+import UndoUI
+import UrlHandling
+import TelegramPresentationData
+import ChatInterfaceState
+
+func openWebAppImpl(
+    context: AccountContext,
+    parentController: ViewController,
+    updatedPresentationData: (initial: PresentationData, signal: Signal<PresentationData, NoError>)?,
+    botPeer: EnginePeer,
+    chatPeer: EnginePeer?,
+    threadId: Int64?,
+    buttonText: String,
+    url: String,
+    simple: Bool,
+    source: ChatOpenWebViewSource,
+    skipTermsOfService: Bool,
+    payload: String?,
+    verifyAgeCompletion: ((Int) -> Void)?
+) {
+    if context.isFrozen {
+        parentController.push(context.sharedContext.makeAccountFreezeInfoScreen(context: context))
+        return
+    }
+    
+    let presentationData: PresentationData
+    if let parentController = parentController as? ChatControllerImpl {
+        presentationData = parentController.presentationData
+    } else {
+        presentationData = context.sharedContext.currentPresentationData.with({ $0 })
+    }
+    
+    var skipTermsOfService = skipTermsOfService
+    if let whiteListedBots = context.currentAppConfiguration.with({ $0 }).data?["whitelisted_bots"] as? [Double] {
+        let botId = botPeer.id.id._internalGetInt64Value()
+        for bot in whiteListedBots {
+            if Int64(bot) == botId {
+                skipTermsOfService = true
+            }
+        }
+    }
+    
+    let botName: String
+    let botAddress: String
+    let botVerified: Bool
+    if case let .inline(bot) = source {
+        botName = bot.compactDisplayTitle
+        botAddress = bot.addressName ?? ""
+        botVerified = bot.isVerified
+    } else {
+        botName = botPeer.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
+        botAddress = botPeer.addressName ?? ""
+        botVerified = botPeer.isVerified
+    }
+    
+    if source == .generic {
+        if let parentController = parentController as? ChatControllerImpl {
+            parentController.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                return $0.updatedTitlePanelContext {
+                    if !$0.contains(where: {
+                        switch $0 {
+                        case .requestInProgress:
+                            return true
+                        default:
+                            return false
+                        }
+                    }) {
+                        var updatedContexts = $0
+                        updatedContexts.append(.requestInProgress)
+                        return updatedContexts.sorted()
+                    }
+                    return $0
+                }
+            })
+        }
+    }
+    
+    let updateProgress = { [weak parentController] in
+        Queue.mainQueue().async {
+            if let parentController = parentController as? ChatControllerImpl {
+                parentController.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                    return $0.updatedTitlePanelContext {
+                        if let index = $0.firstIndex(where: {
+                            switch $0 {
+                                case .requestInProgress:
+                                    return true
+                                default:
+                                    return false
+                            }
+                        }) {
+                            var updatedContexts = $0
+                            updatedContexts.remove(at: index)
+                            return updatedContexts
+                        }
+                        return $0
+                    }
+                })
+            }
+        }
+    }
+    
+    var botPeer = botPeer
+    if case let .inline(bot) = source {
+        botPeer = bot
+    }
+            
+    let _ = combineLatest(queue: Queue.mainQueue(),
+        context.engine.data.get(TelegramEngine.EngineData.Item.Peer.BotAppSettings(id: botPeer.id)),
+        ApplicationSpecificNotice.getBotGameNotice(accountManager: context.sharedContext.accountManager, peerId: botPeer.id),
+        context.engine.messages.attachMenuBots(),
+        context.engine.messages.getAttachMenuBot(botId: botPeer.id, cached: true)
+        |> map(Optional.init)
+        |> `catch` { _ -> Signal<AttachMenuBot?, NoError> in
+          return .single(nil)
+        }
+    ).start(next: { appSettings, noticed, attachMenuBots, attachMenuBot in
+        let openWebView: (Bool) -> Void = { [weak parentController] justInstalled in
+            guard let parentController else {
+                return
+            }
+            if source == .menu {
+                if let parentController = parentController as? ChatControllerImpl {
+                    parentController.updateChatPresentationInterfaceState(interactive: false) { state in
+                        return state.updatedForceInputCommandsHidden(true)
+                    }
+                }
+                
+                if let navigationController = parentController.navigationController as? NavigationController, let minimizedContainer = navigationController.minimizedContainer {
+                    for controller in minimizedContainer.controllers {
+                        if let controller = controller as? AttachmentController, let mainController = controller.mainController as? WebAppController, mainController.botId == botPeer.id && mainController.source == .menu {
+                            navigationController.maximizeViewController(controller, animated: true)
+                            return
+                        }
+                    }
+                }
+                
+                var fullSize = false
+                var isFullscreen = false
+                if isTelegramMeLink(url), let internalUrl = parseFullInternalUrl(sharedContext: context.sharedContext, context: context, url: url), case .peer(_, .appStart) = internalUrl {
+                    if url.contains("mode=fullscreen") {
+                        isFullscreen = true
+                        fullSize = true
+                    } else {
+                        fullSize = !url.contains("mode=compact")
+                    }
+                }
+                
+                var hasWebApp = false
+                if case let .user(user) = botPeer, let botInfo = user.botInfo, botInfo.flags.contains(.hasWebApp) {
+                    hasWebApp = true
+                }
+                
+                var presentImpl: ((ViewController, Any?) -> Void)?
+                let params = WebAppParameters(source: .menu, peerId: chatPeer?.id ?? botPeer.id, botId: botPeer.id, botName: botName, botVerified: botVerified, botAddress: botPeer.addressName ?? "", appName: hasWebApp ? "" : nil, url: url, queryId: nil, payload: nil, buttonText: buttonText, keepAliveSignal: nil, forceHasSettings: false, fullSize: fullSize, isFullscreen: isFullscreen, appSettings: appSettings)
+                
+                let controller = standaloneWebAppController(context: context, updatedPresentationData: updatedPresentationData, params: params, threadId: threadId, openUrl: { [weak parentController] url, concealed, forceUpdate, commit in
+                    ChatControllerImpl.botOpenUrl(context: context, peerId: chatPeer?.id ?? botPeer.id, controller: parentController as? ChatControllerImpl, url: url, concealed: concealed, forceUpdate: forceUpdate, present: { c, a in
+                        presentImpl?(c, a)
+                    }, commit: commit)
+                }, requestSwitchInline: { [weak parentController] query, chatTypes, completion in
+                    ChatControllerImpl.botRequestSwitchInline(context: context, controller: parentController as? ChatControllerImpl, peerId: chatPeer?.id ?? botPeer.id, botAddress: botAddress, query: query, chatTypes: chatTypes, completion: completion)
+                }, getInputContainerNode: { [weak parentController] in
+                    if let parentController = parentController as? ChatControllerImpl, let layout = parentController.validLayout, case .compact = layout.metrics.widthClass {
+                        return (parentController.chatDisplayNode.getWindowInputAccessoryHeight(), parentController.chatDisplayNode.inputPanelContainerNode, {
+                            guard let menuTransition = parentController.chatDisplayNode.textInputPanelNode?.makeAttachmentMenuTransition(accessoryPanelNode: nil) else {
+                                return nil
+                            }
+                            return AttachmentController.InputPanelTransition(
+                                inputNode: menuTransition.inputNode,
+                                accessoryPanelNode: menuTransition.accessoryPanelNode,
+                                menuButtonNode: menuTransition.menuButtonNode,
+                                menuButtonBackgroundView: menuTransition.menuButtonBackgroundView,
+                                menuIconNode: menuTransition.menuIconNode,
+                                menuTextNode: menuTransition.menuTextNode,
+                                prepareForDismiss: menuTransition.prepareForDismiss
+                            )
+                        })
+                    } else {
+                        return nil
+                    }
+                }, completion: { [weak parentController] in
+                    if let parentController = parentController as? ChatControllerImpl {
+                        parentController.chatDisplayNode.historyNode.scrollToEndOfHistory()
+                    }
+                }, willDismiss: { [weak parentController] in
+                    if let parentController = parentController as? ChatControllerImpl {
+                        parentController.interfaceInteraction?.updateShowWebView { _ in
+                            return false
+                        }
+                    }
+                }, didDismiss: { [weak parentController] in
+                    if let parentController = parentController as? ChatControllerImpl {
+                        parentController.updateChatPresentationInterfaceState(interactive: false) { state in
+                            return state.updatedForceInputCommandsHidden(false)
+                        }
+                    }
+                }, getNavigationController: { [weak parentController] in
+                    var navigationController: NavigationController?
+                    if let parentController = parentController as? ChatControllerImpl {
+                        navigationController = parentController.effectiveNavigationController
+                    }
+                    return navigationController ?? (context.sharedContext.mainWindow?.viewController as? NavigationController)
+                })
+                controller.navigationPresentation = .flatModal
+                parentController.push(controller)
+                
+                presentImpl = { [weak controller] c, a in
+                    controller?.present(c, in: .window(.root), with: a)
+                }
+            } else if simple {
+                var isInline = false
+                var botId = botPeer.id
+                var botName = botName
+                var botAddress = botPeer.addressName ?? ""
+                var botVerified = botPeer.isVerified
+                if case let .inline(bot) = source {
+                    isInline = true
+                    botId = bot.id
+                    botName = bot.displayTitle(strings: presentationData.strings, displayOrder: presentationData.nameDisplayOrder)
+                    botAddress = bot.addressName ?? ""
+                    botVerified = bot.isVerified
+                }
+                
+                let messageActionCallbackDisposable: MetaDisposable
+                if let parentController = parentController as? ChatControllerImpl {
+                    messageActionCallbackDisposable = parentController.messageActionCallbackDisposable
+                } else {
+                    messageActionCallbackDisposable = MetaDisposable()
+                }
+                
+                let webViewSignal: Signal<RequestWebViewResult, RequestWebViewError>
+                let webViewSource: RequestSimpleWebViewSource
+                if let payload {
+                    webViewSource = .inline(startParam: payload)
+                } else {
+                    webViewSource = .generic
+                }
+                if url.isEmpty {
+                    webViewSignal = context.engine.messages.requestMainWebView(peerId: chatPeer?.id ?? botId, botId: botId, source: webViewSource, themeParams: generateWebAppThemeParams(presentationData.theme))
+                } else {
+                    webViewSignal = context.engine.messages.requestSimpleWebView(botId: botId, url: url, source: webViewSource, themeParams: generateWebAppThemeParams(presentationData.theme))
+                }
+                
+                messageActionCallbackDisposable.set(((webViewSignal
+                |> afterDisposed {
+                    updateProgress()
+                })
+                |> deliverOnMainQueue).start(next: { [weak parentController] result in
+                    guard let parentController else {
+                        return
+                    }
+                    var presentImpl: ((ViewController, Any?) -> Void)?
+                    let source: WebAppParameters.Source
+                    if isInline {
+                        source = .inline
+                    } else {
+                        source = url.isEmpty ? .generic : .simple
+                    }
+                    let params = WebAppParameters(source: source, peerId: chatPeer?.id ?? botId, botId: botId, botName: botName, botVerified: botVerified, botAddress: botPeer.addressName ?? "", appName: "", url: result.url, queryId: nil, payload: payload, buttonText: buttonText, keepAliveSignal: nil, forceHasSettings: false, fullSize: result.flags.contains(.fullSize), isFullscreen: result.flags.contains(.fullScreen), appSettings: appSettings)
+                    let controller = standaloneWebAppController(context: context, updatedPresentationData: updatedPresentationData, params: params, threadId: threadId, openUrl: { [weak parentController] url, concealed, forceUpdate, commit in
+                        ChatControllerImpl.botOpenUrl(context: context, peerId: chatPeer?.id ?? botId, controller: parentController as? ChatControllerImpl, url: url, concealed: concealed, forceUpdate: forceUpdate, present: { c, a in
+                            presentImpl?(c, a)
+                        }, commit: commit)
+                    }, requestSwitchInline: { [weak parentController] query, chatTypes, completion in
+                        ChatControllerImpl.botRequestSwitchInline(context: context, controller: parentController as? ChatControllerImpl, peerId: chatPeer?.id ?? botId, botAddress: botAddress, query: query, chatTypes: chatTypes, completion: completion)
+                    }, getNavigationController: { [weak parentController] in
+                        var navigationController: NavigationController?
+                        if let parentController = parentController as? ChatControllerImpl {
+                            navigationController = parentController.effectiveNavigationController
+                        }
+                        return navigationController ?? (context.sharedContext.mainWindow?.viewController as? NavigationController)
+                    }, verifyAgeCompletion: verifyAgeCompletion)
+                    controller.navigationPresentation = .flatModal
+                    parentController.push(controller)
+                    
+                    presentImpl = { [weak controller] c, a in
+                        controller?.present(c, in: .window(.root), with: a)
+                    }
+                }, error: { [weak parentController] error in
+                    if let parentController {
+                        parentController.present(textAlertController(context: context, updatedPresentationData: updatedPresentationData, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {
+                        })]), in: .window(.root))
+                    }
+                }))
+            } else {
+                let messageActionCallbackDisposable: MetaDisposable
+                if let parentController = parentController as? ChatControllerImpl {
+                    messageActionCallbackDisposable = parentController.messageActionCallbackDisposable
+                } else {
+                    messageActionCallbackDisposable = MetaDisposable()
+                }
+                
+                messageActionCallbackDisposable.set(((context.engine.messages.requestWebView(peerId: chatPeer?.id ?? botPeer.id, botId: botPeer.id, url: !url.isEmpty ? url : nil, payload: nil, themeParams: generateWebAppThemeParams(presentationData.theme), fromMenu: false, replyToMessageId: nil, threadId: threadId)
+                |> afterDisposed {
+                    updateProgress()
+                })
+                |> deliverOnMainQueue).startStandalone(next: { [weak parentController] result in
+                    guard let parentController else {
+                        return
+                    }
+                    
+                    var hasWebApp = false
+                    if case let .user(user) = botPeer, let botInfo = user.botInfo, botInfo.flags.contains(.hasWebApp) {
+                        hasWebApp = true
+                    }
+                    
+                    var presentImpl: ((ViewController, Any?) -> Void)?
+                    let params = WebAppParameters(source: .button, peerId: chatPeer?.id ?? botPeer.id, botId: botPeer.id, botName: botName, botVerified: botVerified, botAddress: botPeer.addressName ?? "", appName: hasWebApp ? "" : nil, url: result.url, queryId: result.queryId, payload: nil, buttonText: buttonText, keepAliveSignal: result.keepAliveSignal, forceHasSettings: false, fullSize: result.flags.contains(.fullSize), isFullscreen: result.flags.contains(.fullScreen), appSettings: appSettings)
+                    let controller = standaloneWebAppController(context: context, updatedPresentationData: updatedPresentationData, params: params, threadId: threadId, openUrl: { [weak parentController] url, concealed, forceUpdate, commit in
+                        ChatControllerImpl.botOpenUrl(context: context, peerId: chatPeer?.id ?? botPeer.id, controller: parentController as? ChatControllerImpl, url: url, concealed: concealed, forceUpdate: forceUpdate, present: { c, a in
+                            presentImpl?(c, a)
+                        }, commit: commit)
+                    }, completion: { [weak parentController] in
+                        if let parentController = parentController as? ChatControllerImpl {
+                            parentController.chatDisplayNode.historyNode.scrollToEndOfHistory()
+                        }
+                    }, getNavigationController: { [weak parentController] in
+                        var navigationController: NavigationController?
+                        if let parentController = parentController as? ChatControllerImpl {
+                            navigationController = parentController.effectiveNavigationController
+                        }
+                        return navigationController ?? (context.sharedContext.mainWindow?.viewController as? NavigationController)
+                    })
+                    controller.navigationPresentation = .flatModal
+                    parentController.push(controller)
+                    
+                    presentImpl = { [weak controller] c, a in
+                        controller?.present(c, in: .window(.root), with: a)
+                    }
+                    
+                    if justInstalled {
+                        let content: UndoOverlayContent = .succeed(text: presentationData.strings.WebApp_ShortcutsSettingsAdded(botPeer.compactDisplayTitle).string, timeout: 5.0, customUndoText: nil)
+                        controller.present(UndoOverlayController(presentationData: presentationData, content: content, elevatedLayout: false, position: .top, action: { _ in return false }), in: .current)
+                    }
+                }, error: { [weak parentController] error in
+                    if let parentController {
+                        parentController.present(textAlertController(context: context, updatedPresentationData: updatedPresentationData, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {
+                        })]), in: .window(.root))
+                    }
+                }))
+            }
+        }
+        
+        var isAttachMenuBotInstalled: Bool?
+        if let _ = attachMenuBot {
+            if let _ = attachMenuBots.first(where: { $0.peer.id == botPeer.id && !$0.flags.contains(.notActivated) }) {
+                isAttachMenuBotInstalled = true
+            } else {
+                isAttachMenuBotInstalled = false
+            }
+        }
+        
+        if !noticed || attachMenuBot?.flags.contains(.notActivated) == true || isAttachMenuBotInstalled == false {
+            if let isAttachMenuBotInstalled, let attachMenuBot {
+                if !isAttachMenuBotInstalled {
+                    let controller = webAppTermsAlertController(context: context, updatedPresentationData: updatedPresentationData, bot: attachMenuBot, completion: { allowWrite in
+                        let _ = ApplicationSpecificNotice.setBotGameNotice(accountManager: context.sharedContext.accountManager, peerId: botPeer.id).startStandalone()
+                        let _ = (context.engine.messages.addBotToAttachMenu(botId: botPeer.id, allowWrite: allowWrite)
+                        |> deliverOnMainQueue).startStandalone(error: { _ in
+                        }, completed: {
+                            openWebView(true)
+                        })
+                    })
+                    parentController.present(controller, in: .window(.root))
+                } else {
+                    openWebView(false)
+                }
+            } else {
+                if skipTermsOfService {
+                    openWebView(false)
+                } else {
+                    let controller = webAppLaunchConfirmationController(context: context, updatedPresentationData: updatedPresentationData, peer: botPeer, completion: { _ in
+                        let _ = ApplicationSpecificNotice.setBotGameNotice(accountManager: context.sharedContext.accountManager, peerId: botPeer.id).startStandalone()
+                        openWebView(false)
+                    }, showMore: nil, openTerms: {
+                        if let navigationController = parentController.navigationController as? NavigationController {
+                            context.sharedContext.openExternalUrl(context: context, urlContext: .generic, url: presentationData.strings.WebApp_LaunchTermsConfirmation_URL, forceExternal: false, presentationData: presentationData, navigationController: navigationController, dismissInput: {})
+                        }
+                    })
+                    parentController.present(controller, in: .window(.root))
+                }
+            }
+        } else {
+            openWebView(false)
+        }
+    })
+}
+
+public extension ChatControllerImpl {
+    func openWebApp(buttonText: String, url: String, simple: Bool, source: ChatOpenWebViewSource) {
+        guard let peer = self.presentationInterfaceState.renderedPeer?.peer else {
+            return
+        }
+        self.chatDisplayNode.dismissInput()
+        
+        self.context.sharedContext.openWebApp(
+            context: self.context,
+            parentController: self,
+            updatedPresentationData: self.updatedPresentationData,
+            botPeer: EnginePeer(peer),
+            chatPeer: EnginePeer(peer),
+            threadId: self.chatLocation.threadId,
+            buttonText: buttonText,
+            url: url,
+            simple: simple,
+            source: source,
+            skipTermsOfService: false,
+            payload: nil,
+            verifyAgeCompletion: nil
+        )
+    }
+    
+    fileprivate static func botRequestSwitchInline(context: AccountContext, controller: ChatControllerImpl?, peerId: EnginePeer.Id, botAddress: String, query: String, chatTypes: [ReplyMarkupButtonRequestPeerType]?, completion:  @escaping () -> Void) -> Void {
+        let activateSwitchInline: (EnginePeer?) -> Void = { selectedPeer in
+            var chatController: ChatControllerImpl?
+            if let current = controller {
+                chatController = current
+            } else if let navigationController = context.sharedContext.mainWindow?.viewController as? NavigationController {
+                for controller in navigationController.viewControllers.reversed() {
+                    if let controller = controller as? ChatControllerImpl {
+                        chatController = controller
+                        break
+                    }
+                }
+            }
+            let inputString = "@\(botAddress) \(query)"
+            if let chatController {
+                chatController.controllerInteraction?.activateSwitchInline(selectedPeer?.id ?? peerId, inputString, nil)
+            } else if let selectedPeer, let navigationController = context.sharedContext.mainWindow?.viewController as? NavigationController {
+                let textInputState = ChatTextInputState(inputText: NSAttributedString(string: inputString))
+                let _ = (ChatInterfaceState.update(engine: context.engine, peerId: selectedPeer.id, threadId: nil, { currentState in
+                    return currentState.withUpdatedComposeInputState(textInputState)
+                })
+                |> deliverOnMainQueue).startStandalone(completed: { [weak navigationController] in
+                    guard let navigationController else {
+                        return
+                    }
+                    context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(selectedPeer), subject: nil, updateTextInputState: textInputState, peekData: nil))
+                })
+            }
+        }
+    
+        if let chatTypes {
+            let peerController = context.sharedContext.makePeerSelectionController(PeerSelectionControllerParams(context: context, filter: [.excludeRecent, .doNotSearchMessages], requestPeerType: chatTypes, hasContactSelector: false, hasCreation: false))
+            peerController.peerSelected = { [weak peerController] peer, _ in
+                completion()
+                peerController?.dismiss()
+                activateSwitchInline(peer)
+            }
+            if let controller {
+                controller.push(peerController)
+            } else {
+                ((context.sharedContext.mainWindow?.viewController as? TelegramRootControllerInterface)?.viewControllers.last as? ViewController)?.push(peerController)
+            }
+        } else {
+            activateSwitchInline(nil)
+        }
+    }
+    
+    private static func botOpenPeer(context: AccountContext, peerId: EnginePeer.Id, navigation: ChatControllerInteractionNavigateToPeer, navigationController: NavigationController) {
+        let _ = (context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: peerId))
+        |> deliverOnMainQueue).startStandalone(next: { peer in
+            guard let peer else {
+                return
+            }
+            switch navigation {
+            case .default:
+                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), keepStack: .always))
+            case let .chat(_, subject, peekData):
+                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), subject: subject, keepStack: .always, peekData: peekData))
+            case .info:
+                if peer.restrictionText(platform: "ios", contentSettings: context.currentContentSettings.with { $0 }) == nil {
+                    if let infoController = context.sharedContext.makePeerInfoController(context: context, updatedPresentationData: nil, peer: peer._asPeer(), mode: .generic, avatarInitiallyExpanded: false, fromChat: false, requestsContext: nil) {
+                        navigationController.pushViewController(infoController)
+                    }
+                }
+            case let .withBotStartPayload(startPayload):
+                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), botStart: startPayload))
+            case let .withAttachBot(attachBotStart):
+                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), attachBotStart: attachBotStart))
+            case let .withBotApp(botAppStart):
+                context.sharedContext.navigateToChatController(NavigateToChatControllerParams(navigationController: navigationController, context: context, chatLocation: .peer(peer), botAppStart: botAppStart, keepStack: .always))
+            }
+        })
+    }
+    
+    fileprivate static func botOpenUrl(context: AccountContext, peerId: EnginePeer.Id, controller: ChatControllerImpl?, url: String, concealed: Bool, forceUpdate: Bool, present: @escaping (ViewController, Any?) -> Void, commit: @escaping () -> Void = {}) {
+        if let controller {
+            controller.openUrl(url, concealed: concealed, forceExternal: true, commit: commit)
+        } else {
+            let _ = openUserGeneratedUrl(context: context, peerId: peerId, url: url, concealed: concealed, present: { c in
+                present(c, nil)
+            }, openResolved: { result in
+                var navigationController: NavigationController?
+                if let main = context.sharedContext.mainWindow?.viewController as? NavigationController {
+                    navigationController = main
+                }
+                if case let .peer(peer, navigation) = result, case let .withBotApp(botApp) = navigation, let botPeer = peer.flatMap(EnginePeer.init), let parentController = navigationController?.viewControllers.last as? ViewController {
+                    self.presentBotApp(context: context, parentController: parentController, botApp: botApp.botApp, botPeer: botPeer, payload: botApp.payload, mode: botApp.mode)
+                } else {
+                    context.sharedContext.openResolvedUrl(result, context: context, urlContext: .generic, navigationController: navigationController, forceExternal: false, forceUpdate: forceUpdate, openPeer: { peer, navigation in
+                        if let navigationController {
+                            ChatControllerImpl.botOpenPeer(context: context, peerId: peer.id, navigation: navigation, navigationController: navigationController)
+                        }
+                        commit()
+                    }, sendFile: nil, sendSticker: nil, sendEmoji: nil, requestMessageActionUrlAuth: nil, joinVoiceChat: { peerId, invite, call in
+                    }, present: { c, a in
+                        present(c, a)
+                    }, dismissInput: {
+                        context.sharedContext.mainWindow?.viewController?.view.endEditing(false)
+                    }, contentContext: nil, progress: nil, completion: nil)
+                }
+            })
+        }
+    }
+    
+    func presentBotApp(botApp: BotApp?, botPeer: EnginePeer, payload: String?, mode: ResolvedStartAppMode, concealed: Bool = false, commit: @escaping () -> Void = {}) {
+        ChatControllerImpl.presentBotApp(context: self.context, parentController: self, botApp: botApp, botPeer: botPeer, payload: payload, mode: mode, concealed: concealed, commit: commit)
+    }
+    
+    fileprivate static func presentBotApp(context: AccountContext, parentController: ViewController, botApp: BotApp?, botPeer: EnginePeer, payload: String?, mode: ResolvedStartAppMode, concealed: Bool = false, commit: @escaping () -> Void = {}) {
+        let chatController = parentController as? ChatControllerImpl
+        let peerId: EnginePeer.Id
+        let threadId = chatController?.chatLocation.threadId
+        if let chatPeerId = chatController?.chatLocation.peerId {
+            peerId = chatPeerId
+        } else {
+            peerId = botPeer.id
+        }
+        
+        var skipTermsOfService = false
+        if let whiteListedBots = context.currentAppConfiguration.with({ $0 }).data?["whitelisted_bots"] as? [Double] {
+            let botId = botPeer.id.id._internalGetInt64Value()
+            for bot in whiteListedBots {
+                if Int64(bot) == botId {
+                    skipTermsOfService = true
+                }
+            }
+        }
+
+        chatController?.attachmentController?.dismiss(animated: true, completion: nil)
+        
+        let updatedPresentationData = chatController?.updatedPresentationData
+        let presentationData = updatedPresentationData?.0 ?? context.sharedContext.currentPresentationData.with { $0 }
+        
+        if let botApp {
+            let openBotApp: (Bool, Bool, BotAppSettings?) -> Void = { [weak parentController, weak chatController] allowWrite, justInstalled, appSettings in
+                commit()
+                
+                chatController?.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                    return $0.updatedTitlePanelContext {
+                        if !$0.contains(where: {
+                            switch $0 {
+                            case .requestInProgress:
+                                return true
+                            default:
+                                return false
+                            }
+                        }) {
+                            var updatedContexts = $0
+                            updatedContexts.append(.requestInProgress)
+                            return updatedContexts.sorted()
+                        }
+                        return $0
+                    }
+                })
+                
+                let updateProgress = { [weak chatController] in
+                    Queue.mainQueue().async {
+                        if let chatController {
+                            chatController.updateChatPresentationInterfaceState(animated: true, interactive: true, {
+                                return $0.updatedTitlePanelContext {
+                                    if let index = $0.firstIndex(where: {
+                                        switch $0 {
+                                        case .requestInProgress:
+                                            return true
+                                        default:
+                                            return false
+                                        }
+                                    }) {
+                                        var updatedContexts = $0
+                                        updatedContexts.remove(at: index)
+                                        return updatedContexts
+                                    }
+                                    return $0
+                                }
+                            })
+                        }
+                    }
+                }
+                
+                let botAddress = botPeer.addressName ?? ""
+                let _ = ((context.engine.messages.requestAppWebView(peerId: peerId, appReference: .id(id: botApp.id, accessHash: botApp.accessHash), payload: payload, themeParams: generateWebAppThemeParams(presentationData.theme), compact: mode == .compact, fullscreen: mode == .fullscreen, allowWrite: allowWrite)
+                |> afterDisposed {
+                    updateProgress()
+                })
+                |> deliverOnMainQueue).startStandalone(next: { [weak parentController, weak chatController] result in
+                    let params = WebAppParameters(source: .generic, peerId: peerId, botId: botPeer.id, botName: botApp.title, botVerified: botPeer.isVerified, botAddress: botPeer.addressName ?? "", appName: botApp.shortName, url: result.url, queryId: 0, payload: payload, buttonText: "", keepAliveSignal: nil, forceHasSettings: botApp.flags.contains(.hasSettings), fullSize: result.flags.contains(.fullSize), isFullscreen: result.flags.contains(.fullScreen), appSettings: appSettings)
+                    var presentImpl: ((ViewController, Any?) -> Void)?
+                    let controller = standaloneWebAppController(context: context, updatedPresentationData: updatedPresentationData, params: params, threadId: threadId, openUrl: { url, concealed, forceUpdate, commit in
+                        ChatControllerImpl.botOpenUrl(context: context, peerId: peerId, controller: chatController, url: url, concealed: concealed, forceUpdate: forceUpdate, present: { c, a in
+                            presentImpl?(c, a)
+                        }, commit: commit)
+                    }, requestSwitchInline: { query, chatTypes, completion in
+                        ChatControllerImpl.botRequestSwitchInline(context: context, controller: chatController, peerId: peerId, botAddress: botAddress, query: query, chatTypes: chatTypes, completion: completion)
+                    }, completion: {
+                        chatController?.chatDisplayNode.historyNode.scrollToEndOfHistory()
+                    }, getNavigationController: {
+                        if let navigationController = parentController?.navigationController as? NavigationController {
+                            return navigationController
+                        } else {
+                            return context.sharedContext.mainWindow?.viewController as? NavigationController
+                        }
+                    })
+                    controller.navigationPresentation = .flatModal
+                    parentController?.push(controller)
+                        
+                    presentImpl = { [weak controller] c, a in
+                        controller?.present(c, in: .window(.root), with: a)
+                    }
+                    
+                    if justInstalled {
+                        let content: UndoOverlayContent = .succeed(text: presentationData.strings.WebApp_ShortcutsSettingsAdded(botPeer.compactDisplayTitle).string, timeout: 5.0, customUndoText: nil)
+                        controller.present(UndoOverlayController(presentationData: presentationData, content: content, elevatedLayout: false, position: .top, action: { _ in return false }), in: .current)
+                    }
+                }, error: { [weak parentController] error in
+                    parentController?.present(textAlertController(context: context, updatedPresentationData: updatedPresentationData, title: nil, text: presentationData.strings.Login_UnknownError, actions: [TextAlertAction(type: .defaultAction, title: presentationData.strings.Common_OK, action: {
+                        })]), in: .window(.root))
+                })
+            }
+            
+            let _ = combineLatest(
+                queue: Queue.mainQueue(),
+                ApplicationSpecificNotice.getBotGameNotice(accountManager: context.sharedContext.accountManager, peerId: botPeer.id),
+                context.engine.messages.attachMenuBots(),
+                context.engine.messages.getAttachMenuBot(botId: botPeer.id, cached: true)
+                |> map(Optional.init)
+                |> `catch` { _ -> Signal<AttachMenuBot?, NoError> in
+                    return .single(nil)
+                },
+                context.engine.data.get(TelegramEngine.EngineData.Item.Peer.BotAppSettings(id: botPeer.id))
+            ).startStandalone(next: { [weak parentController, weak chatController] noticed, attachMenuBots, attachMenuBot, appSettings in
+                var isAttachMenuBotInstalled: Bool?
+                if let _ = attachMenuBot {
+                    if let _ = attachMenuBots.first(where: { $0.peer.id == botPeer.id && !$0.flags.contains(.notActivated) }) {
+                        isAttachMenuBotInstalled = true
+                    } else {
+                        isAttachMenuBotInstalled = false
+                    }
+                }
+                
+                if !noticed || botApp.flags.contains(.notActivated) || isAttachMenuBotInstalled == false {
+                    if let isAttachMenuBotInstalled, let attachMenuBot {
+                        if !isAttachMenuBotInstalled {
+                            let controller = webAppTermsAlertController(context: context, updatedPresentationData: updatedPresentationData, bot: attachMenuBot, completion: { allowWrite in
+                                let _ = ApplicationSpecificNotice.setBotGameNotice(accountManager: context.sharedContext.accountManager, peerId: botPeer.id).startStandalone()
+                                let _ = (context.engine.messages.addBotToAttachMenu(botId: botPeer.id, allowWrite: allowWrite)
+                                |> deliverOnMainQueue).startStandalone(error: { _ in
+                                }, completed: {
+                                    openBotApp(allowWrite, true, appSettings)
+                                })
+                            })
+                            parentController?.present(controller, in: .window(.root))
+                        } else {
+                            openBotApp(false, false, appSettings)
+                        }
+                    } else {
+                        if skipTermsOfService {
+                            openBotApp(true, false, appSettings)
+                        } else {
+                            let controller = webAppLaunchConfirmationController(context: context, updatedPresentationData: updatedPresentationData, peer: botPeer, requestWriteAccess: botApp.flags.contains(.notActivated) && botApp.flags.contains(.requiresWriteAccess), completion: { allowWrite in
+                                let _ = ApplicationSpecificNotice.setBotGameNotice(accountManager: context.sharedContext.accountManager, peerId: botPeer.id).startStandalone()
+                                openBotApp(allowWrite, false, appSettings)
+                            }, showMore: chatController == nil ? nil : { [weak chatController] in
+                                if let chatController {
+                                    chatController.openResolved(result: .peer(botPeer._asPeer(), .info(nil)), sourceMessageId: nil)
+                                }
+                            }, openTerms: {
+                                context.sharedContext.openExternalUrl(context: context, urlContext: .generic, url: presentationData.strings.WebApp_LaunchTermsConfirmation_URL, forceExternal: false, presentationData: presentationData, navigationController: parentController?.navigationController as? NavigationController, dismissInput: {})
+                            })
+                            parentController?.present(controller, in: .window(.root))
+                        }
+                    }
+                } else {
+                    openBotApp(false, false, appSettings)
+                }
+            })
+        } else {
+            context.sharedContext.openWebApp(
+                context: context,
+                parentController: parentController,
+                updatedPresentationData: updatedPresentationData,
+                botPeer: botPeer,
+                chatPeer: nil,
+                threadId: nil,
+                buttonText: "",
+                url: "",
+                simple: true,
+                source: .generic,
+                skipTermsOfService: false,
+                payload: payload,
+                verifyAgeCompletion: nil
+            )
+        }
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerPaidMessage.swift

@@ -0,0 +1,140 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import ContextUI
+import UndoUI
+import AccountContext
+import ChatControllerInteraction
+import AnimatedTextComponent
+import ChatMessagePaymentAlertController
+import TelegramPresentationData
+import TelegramNotices
+
+extension ChatControllerImpl {
+    func presentPaidMessageAlertIfNeeded(count: Int32 = 1, forceDark: Bool = false, alwaysAsk: Bool = false, completion: @escaping (Bool) -> Void) {
+        guard let peer = self.presentationInterfaceState.renderedPeer?.peer.flatMap(EnginePeer.init) else {
+            completion(false)
+            return
+        }
+        guard let renderedPeer = self.presentationInterfaceState.renderedPeer.flatMap(EngineRenderedPeer.init) else {
+            return
+        }
+        if let sendPaidMessageStars = self.presentationInterfaceState.sendPaidMessageStars, self.presentationInterfaceState.interfaceState.editMessage == nil {
+            let totalAmount = sendPaidMessageStars.value * Int64(count)
+            
+            let _ = (ApplicationSpecificNotice.dismissedPaidMessageWarningNamespace(accountManager: self.context.sharedContext.accountManager, peerId: peer.id)
+            |> take(1)
+            |> deliverOnMainQueue).start(next: { [weak self] dismissedAmount in
+                guard let self, let starsContext = self.context.starsContext else {
+                    return
+                }
+                if !alwaysAsk, let dismissedAmount, dismissedAmount == sendPaidMessageStars.value, let currentState = starsContext.currentState, currentState.balance.value > totalAmount {
+                    if count < 3 && totalAmount < 100 {
+                        completion(false)
+                    } else {
+                        completion(true)
+                        self.displayPaidMessageUndo(count: count, amount: sendPaidMessageStars)
+                    }
+                } else {
+                    var presentationData = self.presentationData
+                    if forceDark {
+                        presentationData = presentationData.withUpdated(theme: defaultDarkColorPresentationTheme)
+                    }
+                    var peer = peer
+                    var renderedPeer = renderedPeer
+                    if let peerDiscussionId = self.presentationInterfaceState.peerDiscussionId, let channel = self.contentData?.state.peerView?.peers[peerDiscussionId] {
+                        peer = EnginePeer(channel)
+                        renderedPeer = EngineRenderedPeer(peer: peer)
+                    }
+                    let controller = chatMessagePaymentAlertController(
+                        context: self.context,
+                        presentationData: presentationData,
+                        updatedPresentationData: nil,
+                        peers: [renderedPeer],
+                        count: count,
+                        amount: sendPaidMessageStars,
+                        totalAmount: nil,
+                        hasCheck: !alwaysAsk,
+                        navigationController: self.navigationController as? NavigationController,
+                        completion: { [weak self] dontAskAgain in
+                            guard let self else {
+                                return
+                            }
+                            
+                            if dontAskAgain {
+                                let _ = ApplicationSpecificNotice.setDismissedPaidMessageWarningNamespace(accountManager: self.context.sharedContext.accountManager, peerId: peer.id, amount: sendPaidMessageStars.value).start()
+                            }
+                            
+                            if let currentState = starsContext.currentState, currentState.balance.value < totalAmount {
+                                let _ = (self.context.engine.payments.starsTopUpOptions()
+                                |> take(1)
+                                |> deliverOnMainQueue).startStandalone(next: { [weak self] options in
+                                    guard let self else {
+                                        return
+                                    }
+                                    let controller = self.context.sharedContext.makeStarsPurchaseScreen(context: self.context, starsContext: starsContext, options: options, purpose: .sendMessage(peerId: peer.id, requiredStars: totalAmount), targetPeerId: nil, customTheme: nil, completion: { stars in
+                                        starsContext.add(balance: StarsAmount(value: stars, nanos: 0))
+                                        let _ = (starsContext.onUpdate
+                                        |> deliverOnMainQueue).start(next: {
+                                            completion(false)
+                                        })
+                                    })
+                                    self.push(controller)
+                                })
+                            } else {
+                                completion(false)
+                            }
+                        }
+                    )
+                    self.present(controller, in: .window(.root))
+                }
+            })
+        } else {
+            completion(false)
+        }
+    }
+    
+    func displayPaidMessageUndo(count: Int32, amount: StarsAmount) {
+        guard let peerId = self.chatLocation.peerId else {
+            return
+        }
+        
+        if let current = self.currentPaidMessageUndoController {
+            self.currentPaidMessageUndoController = nil
+            current.dismiss()
+            
+            self.context.engine.messages.forceSendPostponedPaidMessage(peerId: peerId)
+        }
+        
+        let title = self.presentationData.strings.Chat_PaidMessage_Sent_Title(count)
+        let text = self.presentationData.strings.Chat_PaidMessage_Sent_Text(self.presentationData.strings.Chat_PaidMessage_Sent_Text_Stars(Int32(clamping: amount.value * Int64(count)))).string
+        let textItems: [AnimatedTextComponent.Item] = [
+            AnimatedTextComponent.Item(id: 0, content: .text(text))
+        ]
+        let controller = UndoOverlayController(presentationData: self.presentationData, content: .starsSent(context: self.context, title: title, text: textItems, hasUndo: true), elevatedLayout: false, position: .top, action: { [weak self] action in
+            guard let self else {
+                return false
+            }
+            if case .undo = action {
+                var messageIds: [MessageId] = []
+                self.chatDisplayNode.historyNode.forEachItemNode { itemNode in
+                    if let itemNode = itemNode as? ChatMessageItemNodeProtocol {
+                        for message in itemNode.messages() {
+                            if message.id.namespace == Namespaces.Message.Local {
+                                messageIds.append(message.id)
+                            }
+                        }
+                    }
+                }
+                let _ = self.context.engine.messages.deleteMessagesInteractively(messageIds: messageIds, type: .forLocalPeer).startStandalone()
+            }
+            return false
+        })
+        self.currentPaidMessageUndoController = controller
+        self.present(controller, in: .current)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerPaste.swift

@@ -0,0 +1,262 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramUIPreferences
+import AccountContext
+import MediaPickerUI
+import MediaPasteboardUI
+import LegacyMediaPickerUI
+import MediaEditor
+import ChatEntityKeyboardInputNode
+
+extension ChatControllerImpl {
+    func displayPasteMenu(_ subjects: [MediaPickerScreenImpl.Subject.Media]) {
+        let _ = (self.context.sharedContext.accountManager.transaction { transaction -> GeneratedMediaStoreSettings in
+            let entry = transaction.getSharedData(ApplicationSpecificSharedDataKeys.generatedMediaStoreSettings)?.get(GeneratedMediaStoreSettings.self)
+            return entry ?? GeneratedMediaStoreSettings.defaultSettings
+        }
+        |> deliverOnMainQueue).startStandalone(next: { [weak self] settings in
+            if let strongSelf = self, let peer = strongSelf.presentationInterfaceState.renderedPeer?.peer {
+                var enableMultiselection = true
+                if strongSelf.presentationInterfaceState.interfaceState.postSuggestionState != nil {
+                    enableMultiselection = false
+                }
+                
+                strongSelf.chatDisplayNode.dismissInput()
+                let controller = mediaPasteboardScreen(
+                    context: strongSelf.context,
+                    updatedPresentationData: strongSelf.updatedPresentationData,
+                    peer: EnginePeer(peer),
+                    subjects: subjects,
+                    presentMediaPicker: { [weak self] subject, saveEditedPhotos, bannedSendPhotos, bannedSendVideos, present in
+                        if let strongSelf = self {
+                            strongSelf.presentMediaPicker(subject: subject, saveEditedPhotos: saveEditedPhotos, bannedSendPhotos: bannedSendPhotos, bannedSendVideos: bannedSendVideos, enableMultiselection: enableMultiselection, present: present, updateMediaPickerContext: { _ in }, completion: { [weak self] fromGallery, signals, silentPosting, scheduleTime, parameters, getAnimatedTransitionSource, completion in
+                                self?.enqueueMediaMessages(fromGallery: fromGallery, signals: signals, silentPosting: silentPosting, scheduleTime: scheduleTime, parameters: parameters, getAnimatedTransitionSource: getAnimatedTransitionSource, completion: completion)
+                            })
+                        }
+                    },
+                    getSourceRect: nil,
+                    makeEntityInputView: { [weak self] in
+                        guard let self else {
+                            return nil
+                        }
+                        return EntityInputView(context: self.context, isDark: false, areCustomEmojiEnabled: self.presentationInterfaceState.customEmojiAvailable)
+                    }
+                )
+                controller.navigationPresentation = .flatModal
+                strongSelf.push(controller)
+            }
+        })
+    }
+    
+    func enqueueGifData(_ data: Data) {
+        self.enqueueMediaMessageDisposable.set((legacyEnqueueGifMessage(account: self.context.account, data: data) |> deliverOnMainQueue).startStrict(next: { [weak self] message in
+            if let strongSelf = self {
+                strongSelf.presentPaidMessageAlertIfNeeded(completion: { [weak self] postpone in
+                    guard let strongSelf = self else {
+                        return
+                    }
+                    let replyMessageSubject = strongSelf.presentationInterfaceState.interfaceState.replyMessageSubject
+                    strongSelf.chatDisplayNode.setupSendActionOnViewUpdate({
+                        if let strongSelf = self {
+                            strongSelf.chatDisplayNode.collapseInput()
+                            
+                            strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                                $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedSendMessageEffect(nil).withUpdatedPostSuggestionState(nil) }
+                            })
+                        }
+                    }, nil)
+                    strongSelf.sendMessages([message].map { $0.withUpdatedReplyToMessageId(replyMessageSubject?.subjectModel) })
+                })
+            }
+        }))
+    }
+    
+    func enqueueVideoData(_ data: Data) {
+        self.enqueueMediaMessageDisposable.set((legacyEnqueueGifMessage(account: self.context.account, data: data) |> deliverOnMainQueue).startStrict(next: { [weak self] message in
+            if let strongSelf = self {
+                strongSelf.presentPaidMessageAlertIfNeeded(completion: { [weak self] postpone in
+                    guard let strongSelf = self else {
+                        return
+                    }
+                    let replyMessageSubject = strongSelf.presentationInterfaceState.interfaceState.replyMessageSubject
+                    strongSelf.chatDisplayNode.setupSendActionOnViewUpdate({
+                        if let strongSelf = self {
+                            strongSelf.chatDisplayNode.collapseInput()
+                            
+                            strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                                $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedSendMessageEffect(nil).withUpdatedPostSuggestionState(nil) }
+                            })
+                        }
+                    }, nil)
+                    strongSelf.sendMessages([message].map { $0.withUpdatedReplyToMessageId(replyMessageSubject?.subjectModel) })
+                })
+            }
+        }))
+    }
+    
+    func enqueueStickerImage(_ image: UIImage, isMemoji: Bool) {
+        let size = image.size.aspectFitted(CGSize(width: 512.0, height: 512.0))
+        self.enqueueMediaMessageDisposable.set((convertToWebP(image: image, targetSize: size, targetBoundingSize: size, quality: 0.9) |> deliverOnMainQueue).startStrict(next: { [weak self] data in
+            if let strongSelf = self, !data.isEmpty {
+                let resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
+                strongSelf.context.account.postbox.mediaBox.storeResourceData(resource.id, data: data)
+                
+                var fileAttributes: [TelegramMediaFileAttribute] = []
+                fileAttributes.append(.FileName(fileName: "sticker.webp"))
+                fileAttributes.append(.Sticker(displayText: "", packReference: nil, maskData: nil))
+                fileAttributes.append(.ImageSize(size: PixelDimensions(size)))
+                
+                let media = TelegramMediaFile(fileId: MediaId(namespace: Namespaces.Media.LocalFile, id: Int64.random(in: Int64.min ... Int64.max)), partialReference: nil, resource: resource, previewRepresentations: [], videoThumbnails: [], immediateThumbnailData: nil, mimeType: "image/webp", size: Int64(data.count), attributes: fileAttributes, alternativeRepresentations: [])
+                let message = EnqueueMessage.message(text: "", attributes: [], inlineStickers: [:], mediaReference: .standalone(media: media), threadId: strongSelf.chatLocation.threadId, replyToMessageId: nil, replyToStoryId: nil, localGroupingKey: nil, correlationId: nil, bubbleUpEmojiOrStickersets: [])
+                
+                strongSelf.presentPaidMessageAlertIfNeeded(completion: { [weak self] postpone in
+                    guard let strongSelf = self else {
+                        return
+                    }
+                    let replyMessageSubject = strongSelf.presentationInterfaceState.interfaceState.replyMessageSubject
+                    strongSelf.chatDisplayNode.setupSendActionOnViewUpdate({
+                        if let strongSelf = self {
+                            strongSelf.chatDisplayNode.collapseInput()
+                            
+                            strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                                $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedSendMessageEffect(nil).withUpdatedPostSuggestionState(nil) }
+                            })
+                        }
+                    }, nil)
+                    strongSelf.sendMessages([message].map { $0.withUpdatedReplyToMessageId(replyMessageSubject?.subjectModel) }, postpone: postpone)
+                })
+            }
+        }))
+    }
+    
+    func enqueueStickerFile(_ file: TelegramMediaFile) {
+        let message = EnqueueMessage.message(text: "", attributes: [], inlineStickers: [:], mediaReference: .standalone(media: file), threadId: self.chatLocation.threadId, replyToMessageId: nil, replyToStoryId: nil, localGroupingKey: nil, correlationId: nil, bubbleUpEmojiOrStickersets: [])
+        
+        self.presentPaidMessageAlertIfNeeded(completion: { [weak self] postpone in
+            guard let self else {
+                return
+            }
+            let replyMessageSubject = self.presentationInterfaceState.interfaceState.replyMessageSubject
+            self.chatDisplayNode.setupSendActionOnViewUpdate({ [weak self] in
+                if let strongSelf = self {
+                    strongSelf.chatDisplayNode.collapseInput()
+                    
+                    strongSelf.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                        $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedSendMessageEffect(nil).withUpdatedPostSuggestionState(nil) }
+                    })
+                }
+            }, nil)
+            self.sendMessages([message].map { $0.withUpdatedReplyToMessageId(replyMessageSubject?.subjectModel) })
+            
+            Queue.mainQueue().after(3.0) {
+                if let message = self.chatDisplayNode.historyNode.lastVisbleMesssage(), let file = message.media.first(where: { $0 is TelegramMediaFile }) as? TelegramMediaFile, file.isSticker {
+                    self.context.engine.stickers.addRecentlyUsedSticker(fileReference: .message(message: MessageReference(message), media: file))
+                }
+            }
+        })
+    }
+    
+    func enqueueAnimatedStickerData(_ data: Data) {
+        guard let animatedImage = UIImage.animatedImageFromData(data: data), let thumbnailImage = animatedImage.images.first else {
+            return
+        }
+        
+        let dimensions = PixelDimensions(width: 1080, height: 1920)
+        let image = generateImage(dimensions.cgSize, opaque: false, scale: 1.0, rotatedContext: { size, context in
+            context.clear(CGRect(origin: .zero, size: size))
+        })!
+        
+        let blackImage = generateImage(dimensions.cgSize, opaque: true, scale: 1.0, rotatedContext: { size, context in
+            context.setFillColor(UIColor.black.cgColor)
+            context.fill(CGRect(origin: .zero, size: size))
+        })!
+        
+        let stickerEntity = DrawingStickerEntity(content: .animatedImage(data, thumbnailImage))
+        stickerEntity.referenceDrawingSize = dimensions.cgSize
+        stickerEntity.position = CGPoint(x: dimensions.cgSize.width / 2.0, y: dimensions.cgSize.height / 2.0)
+        stickerEntity.scale = 3.5
+        
+        let entities: [CodableDrawingEntity] = [
+            .sticker(stickerEntity)
+        ]
+        
+        let values = MediaEditorValues(
+            peerId: self.context.account.peerId,
+            originalDimensions: dimensions,
+            cropOffset: .zero,
+            cropRect: nil,
+            cropScale: 1.0,
+            cropRotation: 1.0,
+            cropMirroring: false,
+            cropOrientation: .up,
+            gradientColors: [.clear, .clear],
+            videoTrimRange: nil,
+            videoIsMuted: false,
+            videoIsFullHd: false,
+            videoIsMirrored: false,
+            videoVolume: nil,
+            additionalVideoPath: nil,
+            additionalVideoIsDual: false,
+            additionalVideoPosition: nil,
+            additionalVideoScale: nil,
+            additionalVideoRotation: nil,
+            additionalVideoPositionChanges: [],
+            additionalVideoTrimRange: nil,
+            additionalVideoOffset: nil,
+            additionalVideoVolume: nil,
+            collage: [],
+            nightTheme: false,
+            drawing: nil,
+            maskDrawing: blackImage,
+            entities: entities,
+            toolValues: [:],
+            audioTrack: nil,
+            audioTrackTrimRange: nil,
+            audioTrackOffset: nil,
+            audioTrackVolume: nil,
+            audioTrackSamples: nil,
+            collageTrackSamples: nil,
+            coverImageTimestamp: nil,
+            coverDimensions: nil,
+            qualityPreset: nil
+        )
+        
+        let configuration = recommendedVideoExportConfiguration(values: values, duration: animatedImage.duration, frameRate: 30.0, isSticker: true)
+        
+        let path = NSTemporaryDirectory() + "\(Int64.random(in: Int64.min ... Int64.max)).webm"
+        let videoExport = MediaEditorVideoExport(
+            postbox: self.context.account.postbox,
+            subject: .image(image: image),
+            configuration: configuration,
+            outputPath: path
+        )
+        
+        let _ = (videoExport.status
+        |> deliverOnMainQueue).startStandalone(next: { [weak self] status in
+            guard let self else {
+                return
+            }
+            switch status {
+            case .completed:
+                var fileAttributes: [TelegramMediaFileAttribute] = []
+                fileAttributes.append(.FileName(fileName: "sticker.webm"))
+                fileAttributes.append(.Sticker(displayText: "", packReference: nil, maskData: nil))
+                fileAttributes.append(.Video(duration: animatedImage.duration, size: PixelDimensions(width: 512, height: 512), flags: [], preloadSize: nil, coverTime: nil, videoCodec: nil))
+                
+                let previewRepresentations: [TelegramMediaImageRepresentation] = []
+
+                let resource = LocalFileMediaResource(fileId: Int64.random(in: Int64.min ... Int64.max))
+                self.context.account.postbox.mediaBox.copyResourceData(resource.id, fromTempPath: path)
+                
+                let file = TelegramMediaFile(fileId: MediaId(namespace: Namespaces.Media.LocalFile, id: Int64.random(in: Int64.min ... Int64.max)), partialReference: nil, resource: resource, previewRepresentations: previewRepresentations, videoThumbnails: [], immediateThumbnailData: nil, mimeType: "video/webm", size: 0, attributes: fileAttributes, alternativeRepresentations: [])
+                self.enqueueStickerFile(file)
+            default:
+                break
+            }
+        })
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerPlayMessageEffect.swift

@@ -0,0 +1,22 @@
+import Foundation
+import UIKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramUIPreferences
+import AccountContext
+import ChatMessageItemView
+
+extension ChatControllerImpl {
+    func playMessageEffect(message: Message) {
+        var messageItemNode: ChatMessageItemView?
+        self.chatDisplayNode.historyNode.forEachVisibleMessageItemNode { itemNode in
+            if let item = itemNode.item, item.message.id == message.id {
+                messageItemNode = itemNode
+            }
+        }
+        
+        messageItemNode?.playMessageEffect(force: true)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerQuickShare.swift

@@ -0,0 +1,61 @@
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import TelegramCore
+import ContextUI
+import QuickShareScreen
+
+extension ChatControllerImpl {
+    func displayQuickShare(id: EngineMessage.Id, node: ASDisplayNode, gesture: ContextGesture) {
+        let controller = QuickShareScreen(
+            context: self.context,
+            sourceNode: node,
+            gesture: gesture,
+            completion: { [weak self] peer, sourceFrame in
+                guard let self else {
+                    return
+                }
+                self.window?.forEachController({ controller in
+                    if let controller = controller as? QuickShareToastScreen {
+                        controller.dismissWithCommitAction()
+                    }
+                })
+                let toastScreen = QuickShareToastScreen(
+                    context: self.context,
+                    peer: peer,
+                    sourceFrame: sourceFrame,
+                    action: { [weak self] action in
+                        guard let self else {
+                            return
+                        }
+                        switch action {
+                        case .info:
+                            self.openPeer(peer: peer, navigation: .chat(textInputState: nil, subject: nil, peekData: nil), fromMessage: nil)
+                        case .commit:
+                            let enqueueMessage = StandaloneSendEnqueueMessage(
+                                content: .forward(forward: StandaloneSendEnqueueMessage.Forward(
+                                    sourceId: id,
+                                    threadId: nil
+                                )),
+                                replyToMessageId: nil
+                            )
+                            let _ = (standaloneSendEnqueueMessages(
+                                accountPeerId: self.context.account.peerId,
+                                postbox: self.context.account.postbox,
+                                network: self.context.account.network,
+                                stateManager: self.context.account.stateManager,
+                                auxiliaryMethods: self.context.account.auxiliaryMethods,
+                                peerId: peer.id,
+                                threadId: nil,
+                                messages: [enqueueMessage]
+                            )).startStandalone()
+                        }
+                    }
+                )
+                self.present(toastScreen, in: .window(.root))
+            }
+        )
+        self.presentInGlobalOverlay(controller)
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerReport.swift

@@ -0,0 +1,264 @@
+import Foundation
+import UIKit
+import Postbox
+import SwiftSignalKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SafariServices
+import MobileCoreServices
+import Intents
+import LegacyComponents
+import TelegramPresentationData
+import TelegramUIPreferences
+import DeviceAccess
+import TextFormat
+import TelegramBaseController
+import AccountContext
+import TelegramStringFormatting
+import OverlayStatusController
+import DeviceLocationManager
+import ShareController
+import UrlEscaping
+import ContextUI
+import ComposePollUI
+import AlertUI
+import PresentationDataUtils
+import UndoUI
+import TelegramCallsUI
+import TelegramNotices
+import GameUI
+import ScreenCaptureDetection
+import GalleryUI
+import OpenInExternalAppUI
+import LegacyUI
+import InstantPageUI
+import LocationUI
+import BotPaymentsUI
+import DeleteChatPeerActionSheetItem
+import HashtagSearchUI
+import LegacyMediaPickerUI
+import Emoji
+import PeerAvatarGalleryUI
+import PeerInfoUI
+import RaiseToListen
+import UrlHandling
+import AvatarNode
+import AppBundle
+import LocalizedPeerData
+import PhoneNumberFormat
+import SettingsUI
+import UrlWhitelist
+import TelegramIntents
+import TooltipUI
+import StatisticsUI
+import MediaResources
+import GalleryData
+import ChatInterfaceState
+import InviteLinksUI
+import Markdown
+import TelegramPermissionsUI
+import Speak
+import TranslateUI
+import UniversalMediaPlayer
+import WallpaperBackgroundNode
+import ChatListUI
+import CalendarMessageScreen
+import ReactionSelectionNode
+import ReactionListContextMenuContent
+import AttachmentUI
+import AttachmentTextInputPanelNode
+import MediaPickerUI
+import ChatPresentationInterfaceState
+import Pasteboard
+import ChatSendMessageActionUI
+import ChatTextLinkEditUI
+import WebUI
+import PremiumUI
+import ImageTransparency
+import StickerPackPreviewUI
+import TextNodeWithEntities
+import EntityKeyboard
+import ChatTitleView
+import EmojiStatusComponent
+import ChatTimerScreen
+import MediaPasteboardUI
+import ChatListHeaderComponent
+import ChatControllerInteraction
+import FeaturedStickersScreen
+import ChatEntityKeyboardInputNode
+import StorageUsageScreen
+import AvatarEditorScreen
+import ChatScheduleTimeController
+import ICloudResources
+import StoryContainerScreen
+import MoreHeaderButton
+import VolumeButtons
+import ChatAvatarNavigationNode
+import ChatContextQuery
+import PeerReportScreen
+import PeerSelectionController
+import SaveToCameraRoll
+import ChatMessageDateAndStatusNode
+import ReplyAccessoryPanelNode
+import TextSelectionNode
+import ChatMessagePollBubbleContentNode
+import ChatMessageItem
+import ChatMessageItemImpl
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatMessageAnimatedStickerItemNode
+import ChatMessageBubbleItemNode
+import ChatNavigationButton
+import WebsiteType
+import PeerInfoScreen
+import MediaEditorScreen
+import WallpaperGalleryScreen
+import WallpaperGridScreen
+import VideoMessageCameraScreen
+import TopMessageReactions
+import AudioWaveform
+import PeerNameColorScreen
+import ChatEmptyNode
+import ChatMediaInputStickerGridItem
+import AdsInfoScreen
+
+extension ChatControllerImpl {
+    func unblockPeer() {
+        guard case let .peer(peerId) = self.chatLocation else {
+            return
+        }
+        let unblockingPeer = self.unblockingPeer
+        unblockingPeer.set(true)
+        
+        var restartBot = false
+        if let user = self.presentationInterfaceState.renderedPeer?.peer as? TelegramUser, user.botInfo != nil {
+            restartBot = true
+        }
+        self.editMessageDisposable.set((self.context.engine.privacy.requestUpdatePeerIsBlocked(peerId: peerId, isBlocked: false)
+        |> afterDisposed({ [weak self] in
+            Queue.mainQueue().async {
+                unblockingPeer.set(false)
+                if let strongSelf = self, restartBot {
+                    strongSelf.startBot(strongSelf.presentationInterfaceState.botStartPayload)
+                }
+            }
+        })).startStrict())
+    }
+    
+    func reportPeer() {
+        guard let renderedPeer = self.presentationInterfaceState.renderedPeer, let peer = renderedPeer.chatMainPeer, let chatPeer = renderedPeer.peer else {
+            return
+        }
+        self.chatDisplayNode.dismissInput()
+        
+        if let peer = peer as? TelegramChannel, let username = peer.addressName, !username.isEmpty {
+            let actionSheet = ActionSheetController(presentationData: self.presentationData)
+            
+            var items: [ActionSheetItem] = []
+            items.append(ActionSheetButtonItem(title: self.presentationData.strings.Conversation_ReportSpamAndLeave, color: .destructive, action: { [weak self, weak actionSheet] in
+                actionSheet?.dismissAnimated()
+                if let strongSelf = self {
+                    strongSelf.deleteChat(reportChatSpam: true)
+                }
+            }))
+            actionSheet.setItemGroups([ActionSheetItemGroup(items: items), ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: self.presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                })
+            ])])
+            
+            self.present(actionSheet, in: .window(.root))
+        } else if let _ = peer as? TelegramUser {
+            let presentationData = self.presentationData
+            let controller = ActionSheetController(presentationData: presentationData)
+            let dismissAction: () -> Void = { [weak controller] in
+                controller?.dismissAnimated()
+            }
+            var reportSpam = true
+            var deleteChat = true
+            var items: [ActionSheetItem] = []
+            if !peer.isDeleted {
+                items.append(ActionSheetTextItem(title: presentationData.strings.UserInfo_BlockConfirmationTitle(EnginePeer(peer).compactDisplayTitle).string))
+            }
+            items.append(contentsOf: [
+                ActionSheetCheckboxItem(title: presentationData.strings.Conversation_Moderate_Report, label: "", value: reportSpam, action: { [weak controller] checkValue in
+                    reportSpam = checkValue
+                    controller?.updateItem(groupIndex: 0, itemIndex: 1, { item in
+                        if let item = item as? ActionSheetCheckboxItem {
+                            return ActionSheetCheckboxItem(title: item.title, label: item.label, value: !item.value, action: item.action)
+                        }
+                        return item
+                    })
+                }),
+                ActionSheetCheckboxItem(title: presentationData.strings.ReportSpam_DeleteThisChat, label: "", value: deleteChat, action: { [weak controller] checkValue in
+                    deleteChat = checkValue
+                    controller?.updateItem(groupIndex: 0, itemIndex: 2, { item in
+                        if let item = item as? ActionSheetCheckboxItem {
+                            return ActionSheetCheckboxItem(title: item.title, label: item.label, value: !item.value, action: item.action)
+                        }
+                        return item
+                    })
+                }),
+                ActionSheetButtonItem(title: presentationData.strings.UserInfo_BlockActionTitle(EnginePeer(peer).compactDisplayTitle).string, color: .destructive, action: { [weak self] in
+                    dismissAction()
+                    guard let strongSelf = self else {
+                        return
+                    }
+                    let _ = strongSelf.context.engine.privacy.requestUpdatePeerIsBlocked(peerId: peer.id, isBlocked: true).startStandalone()
+                    if let _ = chatPeer as? TelegramSecretChat {
+                        let _ = strongSelf.context.engine.peers.terminateSecretChat(peerId: chatPeer.id, requestRemoteHistoryRemoval: true).startStandalone()
+                    }
+                    if deleteChat {
+                        let _ = strongSelf.context.engine.peers.removePeerChat(peerId: chatPeer.id, reportChatSpam: reportSpam).startStandalone()
+                        strongSelf.effectiveNavigationController?.filterController(strongSelf, animated: true)
+                    } else if reportSpam {
+                        let _ = strongSelf.context.engine.peers.reportPeer(peerId: peer.id, reason: .spam, message: "").startStandalone()
+                    }
+                })
+            ] as [ActionSheetItem])
+            
+            controller.setItemGroups([
+                ActionSheetItemGroup(items: items),
+            ActionSheetItemGroup(items: [ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, action: { dismissAction() })])
+            ])
+            self.present(controller, in: .window(.root), with: ViewControllerPresentationArguments(presentationAnimation: .modalSheet))
+        } else {
+            let title: String
+            var infoString: String?
+            if let _ = peer as? TelegramGroup {
+                title = self.presentationData.strings.Conversation_ReportSpamAndLeave
+                infoString = self.presentationData.strings.Conversation_ReportSpamGroupConfirmation
+            } else if let channel = peer as? TelegramChannel {
+                title = self.presentationData.strings.Conversation_ReportSpamAndLeave
+                if case .group = channel.info {
+                    infoString = self.presentationData.strings.Conversation_ReportSpamGroupConfirmation
+                } else {
+                    infoString = self.presentationData.strings.Conversation_ReportSpamChannelConfirmation
+                }
+            } else {
+                title = self.presentationData.strings.Conversation_ReportSpam
+                infoString = self.presentationData.strings.Conversation_ReportSpamConfirmation
+            }
+            let actionSheet = ActionSheetController(presentationData: self.presentationData)
+            
+            var items: [ActionSheetItem] = []
+            if let infoString = infoString {
+                items.append(ActionSheetTextItem(title: infoString))
+            }
+            items.append(ActionSheetButtonItem(title: title, color: .destructive, action: { [weak self, weak actionSheet] in
+                actionSheet?.dismissAnimated()
+                if let strongSelf = self {
+                    strongSelf.deleteChat(reportChatSpam: true)
+                }
+            }))
+            actionSheet.setItemGroups([ActionSheetItemGroup(items: items), ActionSheetItemGroup(items: [
+                ActionSheetButtonItem(title: self.presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
+                    actionSheet?.dismissAnimated()
+                })
+            ])])
+            
+            self.present(actionSheet, in: .window(.root))
+        }
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerThemeManagement.swift

@@ -0,0 +1,366 @@
+import Foundation
+import UIKit
+import Postbox
+import SwiftSignalKit
+import Display
+import AsyncDisplayKit
+import TelegramCore
+import SafariServices
+import MobileCoreServices
+import Intents
+import LegacyComponents
+import TelegramPresentationData
+import TelegramUIPreferences
+import DeviceAccess
+import TextFormat
+import TelegramBaseController
+import AccountContext
+import TelegramStringFormatting
+import OverlayStatusController
+import DeviceLocationManager
+import ShareController
+import UrlEscaping
+import ContextUI
+import ComposePollUI
+import AlertUI
+import PresentationDataUtils
+import UndoUI
+import TelegramCallsUI
+import TelegramNotices
+import GameUI
+import ScreenCaptureDetection
+import GalleryUI
+import OpenInExternalAppUI
+import LegacyUI
+import InstantPageUI
+import LocationUI
+import BotPaymentsUI
+import DeleteChatPeerActionSheetItem
+import HashtagSearchUI
+import LegacyMediaPickerUI
+import Emoji
+import PeerAvatarGalleryUI
+import PeerInfoUI
+import RaiseToListen
+import UrlHandling
+import AvatarNode
+import AppBundle
+import LocalizedPeerData
+import PhoneNumberFormat
+import SettingsUI
+import UrlWhitelist
+import TelegramIntents
+import TooltipUI
+import StatisticsUI
+import MediaResources
+import GalleryData
+import ChatInterfaceState
+import InviteLinksUI
+import Markdown
+import TelegramPermissionsUI
+import Speak
+import TranslateUI
+import UniversalMediaPlayer
+import WallpaperBackgroundNode
+import ChatListUI
+import CalendarMessageScreen
+import ReactionSelectionNode
+import ReactionListContextMenuContent
+import AttachmentUI
+import AttachmentTextInputPanelNode
+import MediaPickerUI
+import ChatPresentationInterfaceState
+import Pasteboard
+import ChatSendMessageActionUI
+import ChatTextLinkEditUI
+import WebUI
+import PremiumUI
+import ImageTransparency
+import StickerPackPreviewUI
+import TextNodeWithEntities
+import EntityKeyboard
+import ChatTitleView
+import EmojiStatusComponent
+import ChatTimerScreen
+import MediaPasteboardUI
+import ChatListHeaderComponent
+import ChatControllerInteraction
+import FeaturedStickersScreen
+import ChatEntityKeyboardInputNode
+import StorageUsageScreen
+import AvatarEditorScreen
+import ChatScheduleTimeController
+import ICloudResources
+import StoryContainerScreen
+import MoreHeaderButton
+import VolumeButtons
+import ChatAvatarNavigationNode
+import ChatContextQuery
+import PeerReportScreen
+import PeerSelectionController
+import SaveToCameraRoll
+import ChatMessageDateAndStatusNode
+import ReplyAccessoryPanelNode
+import TextSelectionNode
+import ChatMessagePollBubbleContentNode
+import ChatMessageItem
+import ChatMessageItemImpl
+import ChatMessageItemView
+import ChatMessageItemCommon
+import ChatMessageAnimatedStickerItemNode
+import ChatMessageBubbleItemNode
+import ChatNavigationButton
+import WebsiteType
+import PeerInfoScreen
+import MediaEditorScreen
+import WallpaperGalleryScreen
+import WallpaperGridScreen
+import VideoMessageCameraScreen
+import TopMessageReactions
+import AudioWaveform
+import PeerNameColorScreen
+import ChatEmptyNode
+import ChatMediaInputStickerGridItem
+import AdsInfoScreen
+import Photos
+import ChatThemeScreen
+
+extension ChatControllerImpl {
+    public func presentThemeSelection() {
+        guard self.themeScreen == nil else {
+            return
+        }
+        let context = self.context
+        let peerId = self.chatLocation.peerId
+        
+        self.updateChatPresentationInterfaceState(animated: true, interactive: true, { state in
+            var updated = state
+            updated = updated.updatedInputMode({ _ in
+                return .none
+            })
+            updated = updated.updatedShowCommands(false)
+            return updated
+        })
+        
+        let animatedEmojiStickers = context.engine.stickers.loadedStickerPack(reference: .animatedEmoji, forceActualized: false)
+        |> map { animatedEmoji -> [String: [StickerPackItem]] in
+            var animatedEmojiStickers: [String: [StickerPackItem]] = [:]
+            switch animatedEmoji {
+                case let .result(_, items, _):
+                    for item in items {
+                        if let emoji = item.getStringRepresentationsOfIndexKeys().first {
+                            animatedEmojiStickers[emoji.basicEmoji.0] = [item]
+                            let strippedEmoji = emoji.basicEmoji.0.strippedEmoji
+                            if animatedEmojiStickers[strippedEmoji] == nil {
+                                animatedEmojiStickers[strippedEmoji] = [item]
+                            }
+                        }
+                    }
+                default:
+                    break
+            }
+            return animatedEmojiStickers
+        }
+        
+        let _ = (combineLatest(queue: Queue.mainQueue(), self.chatThemePromise.get(), animatedEmojiStickers)
+        |> take(1)).startStandalone(next: { [weak self] chatTheme, animatedEmojiStickers in
+            guard let strongSelf = self, let peer = strongSelf.presentationInterfaceState.renderedPeer?.peer else {
+                return
+            }
+            
+            var canResetWallpaper = false
+            if let cachedUserData = strongSelf.contentData?.state.peerView?.cachedData as? CachedUserData {
+                canResetWallpaper = cachedUserData.wallpaper != nil
+            }
+            
+            let controller = ChatThemeScreen(
+                context: context,
+                updatedPresentationData: strongSelf.updatedPresentationData,
+                animatedEmojiStickers: animatedEmojiStickers,
+                initiallySelectedTheme: chatTheme,
+                peerName: strongSelf.presentationInterfaceState.renderedPeer?.chatMainPeer.flatMap(EnginePeer.init)?.compactDisplayTitle ?? "",
+                canResetWallpaper: canResetWallpaper,
+                previewTheme: { [weak self] chatTheme, dark in
+                    if let strongSelf = self {
+                        strongSelf.presentCrossfadeSnapshot()
+                        strongSelf.chatThemeAndDarkAppearancePreviewPromise.set(.single((chatTheme, dark)))
+                    }
+                },
+                changeWallpaper: { [weak self] in
+                    guard let self, let peerId else {
+                        return
+                    }
+                    if let themeController = self.themeScreen {
+                        self.themeScreen = nil
+                        themeController.dimTapped()
+                    }                    
+                    let dismissControllers = { [weak self] in
+                        if let self, let navigationController = self.navigationController as? NavigationController {
+                            let controllers = navigationController.viewControllers.filter({ controller in
+                                if controller is WallpaperGalleryController || controller is AttachmentController {
+                                    return false
+                                }
+                                return true
+                            })
+                            navigationController.setViewControllers(controllers, animated: true)
+                        }
+                    }
+                    var openWallpaperPickerImpl: ((Bool) -> Void)?
+                    let openWallpaperPicker = { [weak self] animateAppearance in
+                        guard let self else {
+                            return
+                        }
+                        let controller = wallpaperMediaPickerController(
+                            context: context,
+                            updatedPresentationData: self.updatedPresentationData,
+                            peer: EnginePeer(peer),
+                            animateAppearance: animateAppearance,
+                            completion: { [weak self] _, result in
+                                guard let self, let asset = result as? PHAsset else {
+                                    return
+                                }
+                                let controller = WallpaperGalleryController(context: context, source: .asset(asset), mode: .peer(EnginePeer(peer), false))
+                                controller.navigationPresentation = .modal
+                                controller.apply = { wallpaper, options, editedImage, cropRect, brightness, forBoth in
+                                    uploadCustomPeerWallpaper(context: context, wallpaper: wallpaper, mode: options, editedImage: editedImage, cropRect: cropRect, brightness: brightness, peerId: peerId, forBoth: forBoth, completion: {
+                                        Queue.mainQueue().after(0.3, {
+                                            dismissControllers()
+                                        })
+                                    })
+                                }
+                                self.push(controller)
+                            },
+                            openColors: { [weak self] in
+                                guard let self else {
+                                    return
+                                }
+                                let controller = standaloneColorPickerController(context: context, peer: EnginePeer(peer), push: { [weak self] controller in
+                                    if let self {
+                                        self.push(controller)
+                                    }
+                                }, openGallery: {
+                                    openWallpaperPickerImpl?(false)
+                                })
+                                controller.navigationPresentation = .flatModal
+                                self.push(controller)
+                            }
+                        )
+                        controller.navigationPresentation = .flatModal
+                        self.push(controller)
+                    }
+                    openWallpaperPickerImpl = openWallpaperPicker
+                    openWallpaperPicker(true)
+                },
+                resetWallpaper: { [weak self] in
+                    guard let self, let peerId else {
+                        return
+                    }
+                    let _ = self.context.engine.themes.setChatWallpaper(peerId: peerId, wallpaper: nil, forBoth: false).startStandalone()
+                },
+                completion: { [weak self] chatTheme in
+                    guard let self, let peerId else {
+                        return
+                    }
+                    if canResetWallpaper && chatTheme != nil {
+                        let _ = context.engine.themes.setChatWallpaper(peerId: peerId, wallpaper: nil, forBoth: true).startStandalone()
+                    }
+                    strongSelf.chatThemeAndDarkAppearancePreviewPromise.set(.single((chatTheme ?? .emoticon(""), nil)))
+                    let _ = context.engine.themes.setChatTheme(peerId: peerId, chatTheme: chatTheme ?? .emoticon("")).startStandalone(completed: { [weak self] in
+                        if let self {
+                            self.chatThemeAndDarkAppearancePreviewPromise.set(.single((nil, nil)))
+                        }
+                    })
+                }
+            )
+            controller.navigationPresentation = .flatModal
+            controller.passthroughHitTestImpl = { [weak self] _ in
+                if let strongSelf = self {
+                    return strongSelf.chatDisplayNode.historyNode.view
+                } else {
+                    return nil
+                }
+            }
+            controller.dismissed = { [weak self] in
+                if let strongSelf = self {
+                    strongSelf.chatDisplayNode.historyNode.tapped = nil
+                }
+            }
+            strongSelf.chatDisplayNode.historyNode.tapped = { [weak controller] in
+                controller?.dimTapped()
+            }
+            strongSelf.push(controller)
+            strongSelf.themeScreen = controller
+        })
+    }
+    
+    func presentEmojiList(references: [StickerPackReference], previewIconFile: TelegramMediaFile? = nil) {
+        guard let packReference = references.first else {
+            return
+        }
+        self.chatDisplayNode.dismissTextInput()
+        
+        var previewIconFile: TelegramMediaFile? = previewIconFile
+        if let file = previewIconFile, let peerId = self.chatLocation.peerId, !file.isValidForDisplay(chatPeerId: peerId) {
+            previewIconFile = nil
+        }
+        
+        let presentationData = self.presentationData
+        let controller = StickerPackScreen(context: self.context, updatedPresentationData: self.updatedPresentationData, mainStickerPack: packReference, stickerPacks: Array(references), previewIconFile: previewIconFile, parentNavigationController: self.effectiveNavigationController, sendEmoji: canSendMessagesToChat(self.presentationInterfaceState) ? { [weak self] text, attribute in
+            if let strongSelf = self {
+                strongSelf.controllerInteraction?.sendEmoji(text, attribute, false)
+            }
+        } : nil, actionPerformed: { [weak self] actions in
+            guard let strongSelf = self else {
+                return
+            }
+            let context = strongSelf.context
+            if actions.count > 1, let first = actions.first {
+                if case .add = first.2 {
+                    strongSelf.presentInGlobalOverlay(UndoOverlayController(presentationData: presentationData, content: .stickersModified(title: presentationData.strings.EmojiPackActionInfo_AddedTitle, text: presentationData.strings.EmojiPackActionInfo_MultipleAddedText(Int32(actions.count)), undo: false, info: first.0, topItem: first.1.first, context: context), elevatedLayout: true, animateInAsReplacement: false, action: { _ in
+                        return true
+                    }))
+                } else if actions.allSatisfy({
+                    if case .remove = $0.2 {
+                        return true
+                    } else {
+                        return false
+                    }
+                }) {
+                    let isEmoji = actions[0].0.id.namespace == Namespaces.ItemCollection.CloudEmojiPacks
+                    strongSelf.presentInGlobalOverlay(UndoOverlayController(presentationData: presentationData, content: .stickersModified(title: isEmoji ? presentationData.strings.EmojiPackActionInfo_RemovedTitle : presentationData.strings.StickerPackActionInfo_RemovedTitle, text: isEmoji ? presentationData.strings.EmojiPackActionInfo_MultipleRemovedText(Int32(actions.count)) : presentationData.strings.StickerPackActionInfo_MultipleRemovedText(Int32(actions.count)), undo: true, info: actions[0].0, topItem: actions[0].1.first, context: context), elevatedLayout: true, animateInAsReplacement: false, action: { action in
+                        if case .undo = action {
+                            var itemsAndIndices: [(StickerPackCollectionInfo, [StickerPackItem], Int)] = actions.compactMap { action -> (StickerPackCollectionInfo, [StickerPackItem], Int)? in
+                                if case let .remove(index) = action.2 {
+                                    return (action.0, action.1, index)
+                                } else {
+                                    return nil
+                                }
+                            }
+                            itemsAndIndices.sort(by: { $0.2 < $1.2 })
+                            for (info, items, index) in itemsAndIndices.reversed() {
+                                let _ = context.engine.stickers.addStickerPackInteractively(info: info, items: items, positionInList: index).startStandalone()
+                            }
+                        }
+                        return true
+                    }))
+                }
+            } else if let (info, items, action) = actions.first {
+                let isEmoji = info.id.namespace == Namespaces.ItemCollection.CloudEmojiPacks
+                switch action {
+                case .add:
+                    strongSelf.presentInGlobalOverlay(UndoOverlayController(presentationData: presentationData, content: .stickersModified(title: isEmoji ? presentationData.strings.EmojiPackActionInfo_AddedTitle : presentationData.strings.StickerPackActionInfo_AddedTitle, text: isEmoji ? presentationData.strings.EmojiPackActionInfo_AddedText(info.title).string : presentationData.strings.StickerPackActionInfo_AddedText(info.title).string, undo: false, info: info, topItem: items.first, context: context), elevatedLayout: true, animateInAsReplacement: false, action: { _ in
+                        return true
+                    }))
+                case let .remove(positionInList):
+                    strongSelf.presentInGlobalOverlay(UndoOverlayController(presentationData: presentationData, content: .stickersModified(title: isEmoji ? presentationData.strings.EmojiPackActionInfo_RemovedTitle : presentationData.strings.StickerPackActionInfo_RemovedTitle, text: isEmoji ? presentationData.strings.EmojiPackActionInfo_RemovedText(info.title).string : presentationData.strings.StickerPackActionInfo_RemovedText(info.title).string, undo: true, info: info, topItem: items.first, context: context), elevatedLayout: true, animateInAsReplacement: false, action: { action in
+                        if case .undo = action {
+                            let _ = context.engine.stickers.addStickerPackInteractively(info: info, items: items, positionInList: positionInList).startStandalone()
+                        }
+                        return true
+                    }))
+                }
+            }
+        })
+        self.present(controller, in: .window(.root))
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatControllerToasts.swift

@@ -0,0 +1,100 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AsyncDisplayKit
+import Display
+import UndoUI
+import AccountContext
+import ChatControllerInteraction
+
+extension ChatControllerImpl {
+    func displayPostedScheduledMessagesToast(ids: [EngineMessage.Id]) {
+        let timestamp = CFAbsoluteTimeGetCurrent()
+        if self.lastPostedScheduledMessagesToastTimestamp + 0.4 >= timestamp {
+            return
+        }
+        self.lastPostedScheduledMessagesToastTimestamp = timestamp
+        
+        guard case .scheduledMessages = self.presentationInterfaceState.subject else {
+            return
+        }
+        
+        let _ = (self.context.engine.data.get(
+            EngineDataList(ids.map(TelegramEngine.EngineData.Item.Messages.Message.init(id:)))
+        )
+        |> deliverOnMainQueue).startStandalone(next: { [weak self] messages in
+            guard let self else {
+                return
+            }
+            let messages = messages.compactMap { $0 }
+            
+            var found: (message: EngineMessage, file: TelegramMediaFile)?
+            outer: for message in messages {
+                for media in message.media {
+                    if let file = media as? TelegramMediaFile, file.isVideo {
+                        found = (message, file)
+                        break outer
+                    }
+                }
+            }
+            
+            guard let (message, file) = found else {
+                return
+            }
+            
+            guard case let .loaded(isEmpty, _) = self.chatDisplayNode.historyNode.currentHistoryState else {
+                return
+            }
+            
+            if isEmpty {
+                if let navigationController = self.navigationController as? NavigationController, let topController = navigationController.viewControllers.first(where: { c in
+                    if let c = c as? ChatController, c.chatLocation == self.chatLocation {
+                        return true
+                    }
+                    return false
+                }) as? ChatControllerImpl {
+                    topController.controllerInteraction?.presentControllerInCurrent(UndoOverlayController(
+                        presentationData: self.presentationData,
+                        content: .media(
+                            context: self.context,
+                            file: .message(message: MessageReference(message._asMessage()), media: file),
+                            title: nil,
+                            text: self.presentationData.strings.Chat_ToastVideoPublished_Title,
+                            undoText: nil,
+                            customAction: nil
+                        ),
+                        elevatedLayout: false,
+                        position: .top,
+                        animateInAsReplacement: false,
+                        action: { _ in false }
+                    ), nil)
+                    
+                    self.dismiss()
+                }
+            } else {
+                self.controllerInteraction?.presentControllerInCurrent(UndoOverlayController(
+                    presentationData: self.presentationData,
+                    content: .media(
+                        context: self.context,
+                        file: .message(message: MessageReference(message._asMessage()), media: file),
+                        title: nil,
+                        text: self.presentationData.strings.Chat_ToastVideoPublished_Title,
+                        undoText: self.presentationData.strings.Chat_ToastVideoPublished_Action,
+                        customAction: { [weak self] in
+                            guard let self else {
+                                return
+                            }
+                            self.dismiss()
+                        }
+                    ),
+                    elevatedLayout: false,
+                    position: .top,
+                    animateInAsReplacement: false,
+                    action: { _ in false }
+                ), nil)
+            }
+        })
+    }
+}

submodules/TelegramUI/Sources/Chat/ChatMessageDisplaySendMessageOptions.swift

@@ -0,0 +1,300 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import ContextUI
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramNotices
+import ChatSendMessageActionUI
+import AccountContext
+import TopMessageReactions
+import ReactionSelectionNode
+import ChatControllerInteraction
+import ChatSendAudioMessageContextPreview
+
+extension ChatSendMessageEffect {
+    convenience init(_ effect: ChatSendMessageActionSheetController.SendParameters.Effect) {
+        self.init(id: effect.id)
+    }
+}
+
+func chatMessageDisplaySendMessageOptions(selfController: ChatControllerImpl, node: ASDisplayNode, gesture: ContextGesture) {
+    guard let peerId = selfController.chatLocation.peerId, let textInputView = selfController.chatDisplayNode.textInputView(), let layout = selfController.validLayout else {
+        return
+    }
+    let previousSupportedOrientations = selfController.supportedOrientations
+    if layout.size.width > layout.size.height {
+        selfController.supportedOrientations = ViewControllerSupportedOrientations(regularSize: .all, compactSize: .landscape)
+    } else {
+        selfController.supportedOrientations = ViewControllerSupportedOrientations(regularSize: .all, compactSize: .portrait)
+    }
+    
+    let _ = ApplicationSpecificNotice.incrementChatMessageOptionsTip(accountManager: selfController.context.sharedContext.accountManager, count: 4).startStandalone()
+    
+    var hasEntityKeyboard = false
+    if case .media = selfController.presentationInterfaceState.inputMode {
+        hasEntityKeyboard = true
+    }
+    
+    let effectItems: Signal<[ReactionItem]?, NoError>
+    if peerId != selfController.context.account.peerId && peerId.namespace == Namespaces.Peer.CloudUser {
+        effectItems = effectMessageReactions(context: selfController.context)
+        |> map(Optional.init)
+    } else {
+        effectItems = .single(nil)
+    }
+    
+    let availableMessageEffects = selfController.context.availableMessageEffects |> take(1)
+    let hasPremium = selfController.context.engine.data.get(TelegramEngine.EngineData.Item.Peer.Peer(id: selfController.context.account.peerId))
+    |> map { peer -> Bool in
+        guard case let .user(user) = peer else {
+            return false
+        }
+        return user.isPremium
+    }
+    
+    let editMessages: Signal<[EngineMessage], NoError>
+    if let editMessage = selfController.presentationInterfaceState.interfaceState.editMessage {
+        editMessages = selfController.context.engine.data.get(
+            TelegramEngine.EngineData.Item.Messages.MessageGroup(id: editMessage.messageId)
+        )
+    } else {
+        editMessages = .single([])
+    }
+    
+    var currentMessageEffect: ChatSendMessageActionSheetControllerSendParameters.Effect?
+    if selfController.presentationInterfaceState.interfaceState.editMessage == nil {
+        if let sendMessageEffect = selfController.presentationInterfaceState.interfaceState.sendMessageEffect {
+            currentMessageEffect = ChatSendMessageActionSheetControllerSendParameters.Effect(id: sendMessageEffect)
+        }
+    }
+    
+    let _ = (combineLatest(
+        selfController.context.account.viewTracker.peerView(peerId) |> take(1),
+        effectItems,
+        availableMessageEffects,
+        hasPremium,
+        editMessages,
+        ChatSendMessageContextScreen.initialData(context: selfController.context, currentMessageEffectId: currentMessageEffect?.id)
+    )
+    |> deliverOnMainQueue).startStandalone(next: { [weak selfController] peerView, effectItems, availableMessageEffects, hasPremium, editMessages, initialData in
+        guard let selfController, let peer = peerViewMainPeer(peerView) else {
+            return
+        }
+        
+        if let editMessage = selfController.presentationInterfaceState.interfaceState.editMessage {
+            if editMessages.isEmpty {
+                return
+            }
+            
+            var mediaPreview: ChatSendMessageContextScreenMediaPreview?
+            if editMessages.contains(where: { message in
+                return message.media.contains(where: { media in
+                    if media is TelegramMediaImage {
+                        return true
+                    } else if let file = media as? TelegramMediaFile, file.isVideo {
+                        return true
+                    } else if media is TelegramMediaPaidContent {
+                        return true
+                    }
+                    return false
+                })
+            }) {
+                mediaPreview = ChatSendGroupMediaMessageContextPreview(
+                    context: selfController.context,
+                    presentationData: selfController.presentationData,
+                    wallpaperBackgroundNode: selfController.chatDisplayNode.backgroundNode,
+                    messages: editMessages
+                )
+            }
+            
+            let mediaCaptionIsAbove: Bool
+            if let value = editMessage.mediaCaptionIsAbove {
+                mediaCaptionIsAbove = value
+            } else {
+                mediaCaptionIsAbove = editMessages.contains(where: {
+                    $0.attributes.contains(where: {
+                        $0 is InvertMediaMessageAttribute
+                    })
+                })
+            }
+            
+            let controller = makeChatSendMessageActionSheetController(
+                initialData: initialData,
+                context: selfController.context,
+                updatedPresentationData: selfController.updatedPresentationData,
+                peerId: selfController.presentationInterfaceState.chatLocation.peerId,
+                params: .editMessage(SendMessageActionSheetControllerParams.EditMessage(
+                    messages: editMessages,
+                    mediaPreview: mediaPreview,
+                    mediaCaptionIsAbove: (mediaCaptionIsAbove, { [weak selfController] updatedMediaCaptionIsAbove in
+                        guard let selfController else {
+                            return
+                        }
+                        selfController.updateChatPresentationInterfaceState(animated: false, interactive: false, { state in
+                            return state.updatedInterfaceState { interfaceState in
+                                guard var editMessage = interfaceState.editMessage else {
+                                    return interfaceState
+                                }
+                                editMessage.mediaCaptionIsAbove = updatedMediaCaptionIsAbove
+                                return interfaceState.withUpdatedEditMessage(editMessage)
+                            }
+                        })
+                    })
+                )),
+                hasEntityKeyboard: hasEntityKeyboard,
+                gesture: gesture,
+                sourceSendButton: node,
+                textInputView: textInputView,
+                emojiViewProvider: selfController.chatDisplayNode.textInputPanelNode?.emojiViewProvider,
+                wallpaperBackgroundNode: selfController.chatDisplayNode.backgroundNode,
+                completion: { [weak selfController] in
+                    guard let selfController else {
+                        return
+                    }
+                    selfController.supportedOrientations = previousSupportedOrientations
+                },
+                sendMessage: { [weak selfController] mode, parameters in
+                    guard let selfController else {
+                        return
+                    }
+                    selfController.interfaceInteraction?.editMessage()
+                },
+                schedule: { _ in
+                },
+                editPrice: { _ in
+                }, openPremiumPaywall: { [weak selfController] c in
+                    guard let selfController else {
+                        return
+                    }
+                    selfController.push(c)
+                },
+                reactionItems: nil,
+                availableMessageEffects: nil,
+                isPremium: hasPremium
+            )
+            selfController.sendMessageActionsController = controller
+            if layout.isNonExclusive {
+                selfController.present(controller, in: .window(.root))
+            } else {
+                selfController.presentInGlobalOverlay(controller, with: nil)
+            }
+        } else {
+            var sendWhenOnlineAvailable = false
+            if let presence = peerView.peerPresences[peer.id] as? TelegramUserPresence, case let .present(until) = presence.status {
+                let currentTime = Int32(CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970)
+                if currentTime > until {
+                    sendWhenOnlineAvailable = true
+                }
+            }
+            if peer.id.namespace == Namespaces.Peer.CloudUser && peer.id.id._internalGetInt64Value() == 777000 {
+                sendWhenOnlineAvailable = false
+            }
+            
+            if sendWhenOnlineAvailable {
+                let _ = ApplicationSpecificNotice.incrementSendWhenOnlineTip(accountManager: selfController.context.sharedContext.accountManager, count: 4).startStandalone()
+            }
+            
+            var mediaPreview: ChatSendMessageContextScreenMediaPreview?
+            if let videoRecorderValue = selfController.videoRecorderValue {
+                mediaPreview = videoRecorderValue.makeSendMessageContextPreview()
+            }
+            if let mediaDraftState = selfController.presentationInterfaceState.interfaceState.mediaDraftState {
+                if case let .audio(audio) = mediaDraftState {
+                    mediaPreview = ChatSendAudioMessageContextPreview(
+                        context: selfController.context,
+                        presentationData: selfController.presentationData,
+                        wallpaperBackgroundNode: selfController.chatDisplayNode.backgroundNode,
+                        waveform: audio.waveform
+                    )
+                }
+            }
+            
+            let controller = makeChatSendMessageActionSheetController(
+                initialData: initialData,
+                context: selfController.context,
+                updatedPresentationData: selfController.updatedPresentationData,
+                peerId: selfController.presentationInterfaceState.chatLocation.peerId,
+                params: .sendMessage(SendMessageActionSheetControllerParams.SendMessage(
+                    isScheduledMessages: false,
+                    mediaPreview: mediaPreview,
+                    mediaCaptionIsAbove: nil,
+                    messageEffect: (currentMessageEffect, { [weak selfController] updatedEffect in
+                        guard let selfController else {
+                            return
+                        }
+                        selfController.updateChatPresentationInterfaceState(transition: .immediate, interactive: true, { presentationInterfaceState in
+                            return presentationInterfaceState.updatedInterfaceState { interfaceState in
+                                return interfaceState.withUpdatedSendMessageEffect(updatedEffect?.id)
+                            }
+                        })
+                    }),
+                    attachment: false,
+                    canSendWhenOnline: sendWhenOnlineAvailable,
+                    forwardMessageIds: selfController.presentationInterfaceState.interfaceState.forwardMessageIds ?? [],
+                    canMakePaidContent: false,
+                    currentPrice: nil,
+                    hasTimers: false,
+                    sendPaidMessageStars: selfController.presentationInterfaceState.sendPaidMessageStars,
+                    isMonoforum: selfController.presentationInterfaceState.renderedPeer?.peer?.isMonoForum ?? false
+                )),
+                hasEntityKeyboard: hasEntityKeyboard,
+                gesture: gesture,
+                sourceSendButton: node,
+                textInputView: textInputView,
+                emojiViewProvider: selfController.chatDisplayNode.textInputPanelNode?.emojiViewProvider,
+                wallpaperBackgroundNode: selfController.chatDisplayNode.backgroundNode,
+                completion: { [weak selfController] in
+                    guard let selfController else {
+                        return
+                    }
+                    selfController.supportedOrientations = previousSupportedOrientations
+                },
+                sendMessage: { [weak selfController] mode, parameters in
+                    guard let selfController else {
+                        return
+                    }
+                    switch mode {
+                    case .generic:
+                        selfController.controllerInteraction?.sendCurrentMessage(false, parameters?.effect.flatMap(ChatSendMessageEffect.init))
+                    case .silently:
+                        selfController.controllerInteraction?.sendCurrentMessage(true, parameters?.effect.flatMap(ChatSendMessageEffect.init))
+                    case .whenOnline:
+                        selfController.chatDisplayNode.sendCurrentMessage(scheduleTime: scheduleWhenOnlineTimestamp, messageEffect: parameters?.effect.flatMap(ChatSendMessageEffect.init)) { [weak selfController] in
+                            guard let selfController else {
+                                return
+                            }
+                            selfController.updateChatPresentationInterfaceState(animated: true, interactive: false, saveInterfaceState: selfController.presentationInterfaceState.subject != .scheduledMessages, {
+                                $0.updatedInterfaceState { $0.withUpdatedReplyMessageSubject(nil).withUpdatedSendMessageEffect(nil).withUpdatedPostSuggestionState(nil).withUpdatedForwardMessageIds(nil).withUpdatedForwardOptionsState(nil).withUpdatedComposeInputState(ChatTextInputState(inputText: NSAttributedString(string: ""))) }
+                            })
+                            selfController.openScheduledMessages()
+                        }
+                    }
+                },
+                schedule: { [weak selfController] params in
+                    guard let selfController else {
+                        return
+                    }
+                    selfController.controllerInteraction?.scheduleCurrentMessage(params)
+                }, editPrice: { _ in
+                }, openPremiumPaywall: { [weak selfController] c in
+                    guard let selfController else {
+                        return
+                    }
+                    selfController.push(c)
+                },
+                reactionItems: (!textInputView.text.isEmpty || mediaPreview != nil) ? effectItems : nil,
+                availableMessageEffects: availableMessageEffects,
+                isPremium: hasPremium
+            )
+            selfController.sendMessageActionsController = controller
+            if layout.isNonExclusive {
+                selfController.present(controller, in: .window(.root))
+            } else {
+                selfController.presentInGlobalOverlay(controller, with: nil)
+            }
+        }
+    })
+}

submodules/TelegramUI/Sources/Chat/PeerMessageSelectedReactions.swift

@@ -0,0 +1,37 @@
+import Foundation
+import UIKit
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import AccountContext
+
+func peerMessageSelectedReactions(context: AccountContext, message: Message) -> Signal<(reactions: Set<MessageReaction.Reaction>, files: Set<MediaId>), NoError> {
+    return context.engine.stickers.availableReactions()
+    |> take(1)
+    |> map { availableReactions -> (reactions: Set<MessageReaction.Reaction>, files: Set<MediaId>) in
+        var result = Set<MediaId>()
+        var reactions = Set<MessageReaction.Reaction>()
+        
+        if let effectiveReactions = message.effectiveReactions(isTags: message.areReactionsTags(accountPeerId: context.account.peerId)) {
+            for reaction in effectiveReactions {
+                if !reaction.isSelected {
+                    continue
+                }
+                if case .stars = reaction.value {
+                    continue
+                }
+                reactions.insert(reaction.value)
+                switch reaction.value {
+                case .builtin, .stars:
+                    if let availableReaction = availableReactions?.reactions.first(where: { $0.value == reaction.value }) {
+                        result.insert(availableReaction.selectAnimation.fileId)
+                    }
+                case let .custom(fileId):
+                    result.insert(MediaId(namespace: Namespaces.Media.CloudFile, id: fileId))
+                }
+            }
+        }
+        
+        return (reactions, result)
+    }
+}

submodules/TelegramUI/Sources/Chat/UpdateChatPresentationInterfaceState.swift

@@ -0,0 +1,609 @@
+import Foundation
+import UIKit
+import AsyncDisplayKit
+import Display
+import SwiftSignalKit
+import Postbox
+import TelegramCore
+import TelegramPresentationData
+import AccountContext
+import ChatPresentationInterfaceState
+import ChatInterfaceState
+import TelegramNotices
+import PresentationDataUtils
+import TelegramCallsUI
+import AttachmentUI
+import WebUI
+
+func updateChatPresentationInterfaceStateImpl(
+    selfController: ChatControllerImpl,
+    transition: ContainedViewLayoutTransition,
+    interactive: Bool,
+    saveInterfaceState: Bool,
+    _ f: (ChatPresentationInterfaceState) -> ChatPresentationInterfaceState,
+    completion externalCompletion: @escaping (ContainedViewLayoutTransition) -> Void
+) {
+    var transition = transition
+    if !selfController.didAppear {
+        transition = .immediate
+    }
+    
+    var completion = externalCompletion
+    var temporaryChatPresentationInterfaceState = f(selfController.presentationInterfaceState)
+    
+    if selfController.presentationInterfaceState.keyboardButtonsMessage?.visibleButtonKeyboardMarkup != temporaryChatPresentationInterfaceState.keyboardButtonsMessage?.visibleButtonKeyboardMarkup || selfController.presentationInterfaceState.keyboardButtonsMessage?.id != temporaryChatPresentationInterfaceState.keyboardButtonsMessage?.id {
+        if let keyboardButtonsMessage = temporaryChatPresentationInterfaceState.keyboardButtonsMessage, let keyboardMarkup = keyboardButtonsMessage.visibleButtonKeyboardMarkup {
+            if selfController.presentationInterfaceState.interfaceState.editMessage == nil && selfController.presentationInterfaceState.interfaceState.composeInputState.inputText.length == 0 && keyboardButtonsMessage.id != temporaryChatPresentationInterfaceState.interfaceState.messageActionsState.closedButtonKeyboardMessageId && keyboardButtonsMessage.id != temporaryChatPresentationInterfaceState.interfaceState.messageActionsState.dismissedButtonKeyboardMessageId && temporaryChatPresentationInterfaceState.botStartPayload == nil {
+                temporaryChatPresentationInterfaceState = temporaryChatPresentationInterfaceState.updatedInputMode({ _ in
+                    return .inputButtons(persistent: keyboardMarkup.flags.contains(.persistent))
+                })
+            }
+            
+            if case let .peer(peerId) = selfController.chatLocation, peerId.namespace == Namespaces.Peer.CloudChannel || peerId.namespace == Namespaces.Peer.CloudGroup {
+                if temporaryChatPresentationInterfaceState.interfaceState.replyMessageSubject == nil && temporaryChatPresentationInterfaceState.interfaceState.messageActionsState.processedSetupReplyMessageId != keyboardButtonsMessage.id  {
+                    temporaryChatPresentationInterfaceState = temporaryChatPresentationInterfaceState.updatedInterfaceState({
+                        $0.withUpdatedReplyMessageSubject(ChatInterfaceState.ReplyMessageSubject(
+                            messageId: keyboardButtonsMessage.id,
+                            quote: nil,
+                            todoItemId: nil
+                        )).withUpdatedMessageActionsState({ value in
+                        var value = value
+                        value.processedSetupReplyMessageId = keyboardButtonsMessage.id
+                        return value
+                    }) })
+                }
+            }
+        } else {
+            temporaryChatPresentationInterfaceState = temporaryChatPresentationInterfaceState.updatedInputMode({ mode in
+                if case .inputButtons = mode {
+                    return .text
+                } else {
+                    return mode
+                }
+            })
+        }
+    }
+    
+    if let keyboardButtonsMessage = temporaryChatPresentationInterfaceState.keyboardButtonsMessage, keyboardButtonsMessage.requestsSetupReply {
+        if temporaryChatPresentationInterfaceState.interfaceState.replyMessageSubject == nil && temporaryChatPresentationInterfaceState.interfaceState.messageActionsState.processedSetupReplyMessageId != keyboardButtonsMessage.id  {
+            temporaryChatPresentationInterfaceState = temporaryChatPresentationInterfaceState.updatedInterfaceState({ $0.withUpdatedReplyMessageSubject(ChatInterfaceState.ReplyMessageSubject(
+                messageId: keyboardButtonsMessage.id,
+                quote: nil,
+                todoItemId: nil
+            )).withUpdatedMessageActionsState({ value in
+                var value = value
+                value.processedSetupReplyMessageId = keyboardButtonsMessage.id
+                return value
+            }) })
+        }
+    }
+    
+    let inputTextPanelState = inputTextPanelStateForChatPresentationInterfaceState(temporaryChatPresentationInterfaceState, context: selfController.context)
+    var updatedChatPresentationInterfaceState = temporaryChatPresentationInterfaceState.updatedInputTextPanelState({ _ in return inputTextPanelState })
+    
+    let contextQueryUpdates = contextQueryResultStateForChatInterfacePresentationState(updatedChatPresentationInterfaceState, context: selfController.context, currentQueryStates: &selfController.contextQueryStates, requestBotLocationStatus: { [weak selfController] peerId in
+        guard let selfController else {
+            return
+        }
+        let _ = (ApplicationSpecificNotice.updateInlineBotLocationRequestState(accountManager: selfController.context.sharedContext.accountManager, peerId: peerId, timestamp: Int32(Date().timeIntervalSince1970 + 10 * 60))
+        |> deliverOnMainQueue).startStandalone(next: { [weak selfController] value in
+            guard let selfController, value else {
+                return
+            }
+            selfController.present(textAlertController(context: selfController.context, updatedPresentationData: selfController.updatedPresentationData, title: nil, text: selfController.presentationData.strings.Conversation_ShareInlineBotLocationConfirmation, actions: [TextAlertAction(type: .defaultAction, title: selfController.presentationData.strings.Common_Cancel, action: {
+            }), TextAlertAction(type: .defaultAction, title: selfController.presentationData.strings.Common_OK, action: { [weak selfController] in
+                guard let selfController else {
+                    return
+                }
+                let _ = ApplicationSpecificNotice.setInlineBotLocationRequest(accountManager: selfController.context.sharedContext.accountManager, peerId: peerId, value: 0).startStandalone()
+            })]), in: .window(.root))
+        })
+    })
+    
+    for (kind, update) in contextQueryUpdates {
+        switch update {
+        case .remove:
+            if let (_, disposable) = selfController.contextQueryStates[kind] {
+                disposable.dispose()
+                selfController.contextQueryStates.removeValue(forKey: kind)
+                
+                updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedInputQueryResult(queryKind: kind, { _ in
+                    return nil
+                })
+            }
+            if case .contextRequest = kind {
+                selfController.performingInlineSearch.set(false)
+            }
+        case let .update(query, signal):
+            let currentQueryAndDisposable = selfController.contextQueryStates[kind]
+            currentQueryAndDisposable?.1.dispose()
+            
+            var inScope = true
+            var inScopeResult: ((ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult?)?
+            selfController.contextQueryStates[kind] = (query, (signal
+            |> deliverOnMainQueue).startStrict(next: { [weak selfController] result in
+                guard let selfController else {
+                    return
+                }
+                if Thread.isMainThread && inScope {
+                    inScope = false
+                    inScopeResult = result
+                } else {
+                    selfController.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                        $0.updatedInputQueryResult(queryKind: kind, { previousResult in
+                            return result(previousResult)
+                        })
+                    })
+                }
+            }, error: { [weak selfController] error in
+                guard let selfController else {
+                    return
+                }
+                if case .contextRequest = kind {
+                    selfController.performingInlineSearch.set(false)
+                }
+                
+                switch error {
+                case .generic:
+                    break
+                case let .inlineBotLocationRequest(peerId):
+                    selfController.present(textAlertController(context: selfController.context, updatedPresentationData: selfController.updatedPresentationData, title: nil, text: selfController.presentationData.strings.Conversation_ShareInlineBotLocationConfirmation, actions: [TextAlertAction(type: .defaultAction, title: selfController.presentationData.strings.Common_Cancel, action: { [weak selfController] in
+                        guard let selfController else {
+                            return
+                        }
+                        let _ = ApplicationSpecificNotice.setInlineBotLocationRequest(accountManager: selfController.context.sharedContext.accountManager, peerId: peerId, value: Int32(Date().timeIntervalSince1970 + 10 * 60)).startStandalone()
+                    }), TextAlertAction(type: .defaultAction, title: selfController.presentationData.strings.Common_OK, action: { [weak selfController] in
+                        guard let selfController else {
+                            return
+                        }
+                        let _ = ApplicationSpecificNotice.setInlineBotLocationRequest(accountManager: selfController.context.sharedContext.accountManager, peerId: peerId, value: 0).startStandalone()
+                    })]), in: .window(.root))
+                }
+            }, completed: { [weak selfController] in
+                guard let selfController else {
+                    return
+                }
+                if case .contextRequest = kind {
+                    selfController.performingInlineSearch.set(false)
+                }
+            }))
+            inScope = false
+            if let inScopeResult = inScopeResult {
+                updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedInputQueryResult(queryKind: kind, { previousResult in
+                    return inScopeResult(previousResult)
+                })
+            } else {
+                if case .contextRequest = kind {
+                    selfController.performingInlineSearch.set(true)
+                }
+            }
+        
+            if case let .peer(peerId) = selfController.chatLocation, peerId.namespace == Namespaces.Peer.SecretChat {
+                if case .contextRequest = query {
+                    let _ = (ApplicationSpecificNotice.getSecretChatInlineBotUsage(accountManager: selfController.context.sharedContext.accountManager)
+                    |> deliverOnMainQueue).startStandalone(next: { [weak selfController] value in
+                        guard let selfController, !value else {
+                            return
+                        }
+                        let _ = ApplicationSpecificNotice.setSecretChatInlineBotUsage(accountManager: selfController.context.sharedContext.accountManager).startStandalone()
+                        selfController.present(textAlertController(context: selfController.context, updatedPresentationData: selfController.updatedPresentationData, title: nil, text: selfController.presentationData.strings.Conversation_SecretChatContextBotAlert, actions: [TextAlertAction(type: .defaultAction, title: selfController.presentationData.strings.Common_OK, action: {})]), in: .window(.root))
+                    })
+                }
+            }
+        }
+    }
+    
+    var isBot = false
+    if let peer = updatedChatPresentationInterfaceState.renderedPeer?.peer as? TelegramUser, peer.botInfo != nil {
+        isBot = true
+    } else {
+        isBot = false
+    }
+    selfController.chatDisplayNode.historyNode.chatHasBots = updatedChatPresentationInterfaceState.hasBots || isBot
+    
+    if let (updatedSearchQuerySuggestionState, updatedSearchQuerySuggestionSignal) = searchQuerySuggestionResultStateForChatInterfacePresentationState(updatedChatPresentationInterfaceState, context: selfController.context, currentQuery: selfController.searchQuerySuggestionState?.0) {
+        selfController.searchQuerySuggestionState?.1.dispose()
+        var inScope = true
+        var inScopeResult: ((ChatPresentationInputQueryResult?) -> ChatPresentationInputQueryResult?)?
+        selfController.searchQuerySuggestionState = (updatedSearchQuerySuggestionState, (updatedSearchQuerySuggestionSignal |> deliverOnMainQueue).startStrict(next: { [weak selfController] result in
+            guard let selfController else {
+                return
+            }
+            if Thread.isMainThread && inScope {
+                inScope = false
+                inScopeResult = result
+            } else {
+                selfController.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                    $0.updatedSearchQuerySuggestionResult { previousResult in
+                        return result(previousResult)
+                    }
+                })
+            }
+        }))
+        inScope = false
+        if let inScopeResult = inScopeResult {
+            updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedSearchQuerySuggestionResult { previousResult in
+                return inScopeResult(previousResult)
+            }
+        }
+    }
+    
+    var canHaveUrlPreview = true
+    if case let .customChatContents(customChatContents) = updatedChatPresentationInterfaceState.subject {
+        switch customChatContents.kind {
+        case .hashTagSearch:
+            break
+        case .quickReplyMessageInput:
+            break
+        case .businessLinkSetup:
+            canHaveUrlPreview = false
+        }
+    }
+    
+    if canHaveUrlPreview, let (updatedUrlPreviewState, updatedUrlPreviewSignal) = urlPreviewStateForInputText(updatedChatPresentationInterfaceState.interfaceState.composeInputState.inputText, context: selfController.context, currentQuery: selfController.urlPreviewQueryState?.0, forPeerId: selfController.chatLocation.peerId) {
+        selfController.urlPreviewQueryState?.1.dispose()
+        var inScope = true
+        var inScopeResult: ((TelegramMediaWebpage?) -> (TelegramMediaWebpage, String)?)?
+        let linkPreviews: Signal<Bool, NoError>
+        if case let .peer(peerId) = selfController.chatLocation, peerId.namespace == Namespaces.Peer.SecretChat {
+            linkPreviews = interactiveChatLinkPreviewsEnabled(accountManager: selfController.context.sharedContext.accountManager, displayAlert: { [weak selfController] f in
+                guard let selfController else {
+                    return
+                }
+                selfController.present(textAlertController(context: selfController.context, updatedPresentationData: selfController.updatedPresentationData, title: nil, text: selfController.presentationData.strings.Conversation_SecretLinkPreviewAlert, actions: [
+                    TextAlertAction(type: .defaultAction, title: selfController.presentationData.strings.Common_Yes, action: {
+                    f.f(true)
+                }), TextAlertAction(type: .genericAction, title: selfController.presentationData.strings.Common_No, action: {
+                    f.f(false)
+                })]), in: .window(.root))
+            })
+        } else {
+            var bannedEmbedLinks = false
+            if let channel = selfController.presentationInterfaceState.renderedPeer?.peer as? TelegramChannel, channel.hasBannedPermission(.banEmbedLinks) != nil {
+                bannedEmbedLinks = true
+            } else if let group = selfController.presentationInterfaceState.renderedPeer?.peer as? TelegramGroup, group.hasBannedPermission(.banEmbedLinks) {
+                bannedEmbedLinks = true
+            }
+            if bannedEmbedLinks {
+                linkPreviews = .single(false)
+            } else {
+                linkPreviews = .single(true)
+            }
+        }
+        let filteredPreviewSignal = linkPreviews
+        |> take(1)
+        |> mapToSignal { value -> Signal<(TelegramMediaWebpage?) -> (TelegramMediaWebpage, String)?, NoError> in
+            if value {
+                return updatedUrlPreviewSignal
+            } else {
+                return .single({ _ in return nil })
+            }
+        }
+        
+        selfController.urlPreviewQueryState = (updatedUrlPreviewState, (filteredPreviewSignal |> deliverOnMainQueue).startStrict(next: { [weak selfController] result in
+            guard let selfController else {
+                return
+            }
+            if Thread.isMainThread && inScope {
+                inScope = false
+                inScopeResult = result
+            } else {
+                selfController.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                    if let (webpage, webpageUrl) = result($0.urlPreview?.webPage) {
+                        let updatedPreview = ChatPresentationInterfaceState.UrlPreview(
+                            url: webpageUrl,
+                            webPage: webpage,
+                            positionBelowText: $0.urlPreview?.positionBelowText ?? true,
+                            largeMedia: $0.urlPreview?.largeMedia
+                        )
+                        return $0.updatedUrlPreview(updatedPreview)
+                    } else {
+                        return $0.updatedUrlPreview(nil)
+                    }
+                })
+            }
+        }))
+        inScope = false
+        if let inScopeResult = inScopeResult {
+            if let (webpage, webpageUrl) = inScopeResult(updatedChatPresentationInterfaceState.urlPreview?.webPage) {
+                let updatedPreview = ChatPresentationInterfaceState.UrlPreview(
+                    url: webpageUrl,
+                    webPage: webpage,
+                    positionBelowText: updatedChatPresentationInterfaceState.urlPreview?.positionBelowText ?? true,
+                    largeMedia: updatedChatPresentationInterfaceState.urlPreview?.largeMedia
+                )
+                updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedUrlPreview(updatedPreview)
+            } else {
+                updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedUrlPreview(nil)
+            }
+        }
+    }
+    
+    let isEditingMedia: Bool = updatedChatPresentationInterfaceState.editMessageState?.content != .plaintext
+    let editingUrlPreviewText: NSAttributedString? = isEditingMedia ? nil : updatedChatPresentationInterfaceState.interfaceState.editMessage?.inputState.inputText
+    if let (updatedEditingUrlPreviewState, updatedEditingUrlPreviewSignal) = urlPreviewStateForInputText(editingUrlPreviewText, context: selfController.context, currentQuery: selfController.editingUrlPreviewQueryState?.0, forPeerId: selfController.chatLocation.peerId) {
+        selfController.editingUrlPreviewQueryState?.1.dispose()
+        var inScope = true
+        var inScopeResult: ((TelegramMediaWebpage?) -> (TelegramMediaWebpage, String)?)?
+        selfController.editingUrlPreviewQueryState = (updatedEditingUrlPreviewState, (updatedEditingUrlPreviewSignal |> deliverOnMainQueue).startStrict(next: { [weak selfController] result in
+            guard let selfController else {
+                return
+            }
+            if Thread.isMainThread && inScope {
+                inScope = false
+                inScopeResult = result
+            } else {
+                selfController.updateChatPresentationInterfaceState(animated: true, interactive: false, {
+                    if let (webpage, webpageUrl) = result($0.editingUrlPreview?.webPage) {
+                        let updatedPreview = ChatPresentationInterfaceState.UrlPreview(
+                            url: webpageUrl,
+                            webPage: webpage,
+                            positionBelowText: $0.editingUrlPreview?.positionBelowText ?? true,
+                            largeMedia: $0.editingUrlPreview?.largeMedia
+                        )
+                        return $0.updatedEditingUrlPreview(updatedPreview)
+                    } else {
+                        return $0.updatedEditingUrlPreview(nil)
+                    }
+                })
+            }
+        }))
+        inScope = false
+        if let inScopeResult = inScopeResult {
+            if let (webpage, webpageUrl) = inScopeResult(updatedChatPresentationInterfaceState.editingUrlPreview?.webPage) {
+                let updatedPreview = ChatPresentationInterfaceState.UrlPreview(
+                    url: webpageUrl,
+                    webPage: webpage,
+                    positionBelowText: updatedChatPresentationInterfaceState.editingUrlPreview?.positionBelowText ?? true,
+                    largeMedia: updatedChatPresentationInterfaceState.editingUrlPreview?.largeMedia
+                )
+                updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedEditingUrlPreview(updatedPreview)
+            } else {
+                updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedEditingUrlPreview(nil)
+            }
+        }
+    }
+    
+    if let replyMessageId = updatedChatPresentationInterfaceState.interfaceState.replyMessageSubject?.messageId {
+        if selfController.replyMessageState?.0 != replyMessageId {
+            selfController.replyMessageState?.1.dispose()
+            updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedReplyMessage(nil)
+            let disposable = MetaDisposable()
+            selfController.replyMessageState = (replyMessageId, disposable)
+            disposable.set((selfController.context.engine.data.subscribe(TelegramEngine.EngineData.Item.Messages.Message(id: replyMessageId))
+            |> deliverOnMainQueue).start(next: { [weak selfController] message in
+                guard let selfController else {
+                    return
+                }
+                if message != selfController.presentationInterfaceState.replyMessage.flatMap(EngineMessage.init) {
+                    selfController.updateChatPresentationInterfaceState(interactive: false, { presentationInterfaceState in
+                        return presentationInterfaceState.updatedReplyMessage(message?._asMessage())
+                    })
+                }
+            }))
+        }
+    } else {
+        if let replyMessageState = selfController.replyMessageState {
+            selfController.replyMessageState = nil
+            replyMessageState.1.dispose()
+            updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedReplyMessage(nil)
+        }
+    }
+    
+    if let updated = selfController.updateSearch(updatedChatPresentationInterfaceState) {
+        updatedChatPresentationInterfaceState = updated
+    }
+    
+    let recordingActivityValue: ChatRecordingActivity
+    if let mediaRecordingState = updatedChatPresentationInterfaceState.inputTextPanelState.mediaRecordingState {
+        switch mediaRecordingState {
+            case .audio:
+                recordingActivityValue = .voice
+            case .video(ChatVideoRecordingStatus.recording, _):
+                recordingActivityValue = .instantVideo
+            default:
+                recordingActivityValue = .none
+        }
+    } else {
+        recordingActivityValue = .none
+    }
+    if recordingActivityValue != selfController.recordingActivityValue {
+        selfController.recordingActivityValue = recordingActivityValue
+        selfController.recordingActivityPromise.set(recordingActivityValue)
+    }
+    
+    if (selfController.presentationInterfaceState.interfaceState.selectionState == nil) != (updatedChatPresentationInterfaceState.interfaceState.selectionState == nil) {
+        selfController.isSelectingMessagesUpdated?(updatedChatPresentationInterfaceState.interfaceState.selectionState != nil)
+        selfController.updateNextChannelToReadVisibility()
+    }
+    
+    if updatedChatPresentationInterfaceState.displayHistoryFilterAsList {
+        var canDisplayAsList = false
+        if updatedChatPresentationInterfaceState.search != nil {
+            if updatedChatPresentationInterfaceState.search?.resultsState != nil {
+                canDisplayAsList = true
+            }
+            if updatedChatPresentationInterfaceState.historyFilter != nil {
+                canDisplayAsList = true
+            }
+            if case .peer(selfController.context.account.peerId) = updatedChatPresentationInterfaceState.chatLocation {
+                canDisplayAsList = true
+            }
+        }
+        if selfController.alwaysShowSearchResultsAsList {
+            canDisplayAsList = true
+        }
+        
+        if !canDisplayAsList {
+            updatedChatPresentationInterfaceState = updatedChatPresentationInterfaceState.updatedDisplayHistoryFilterAsList(false)
+        }
+    }
+    
+    selfController.presentationInterfaceState = updatedChatPresentationInterfaceState
+    
+    selfController.updateSlowmodeStatus()
+    
+    switch updatedChatPresentationInterfaceState.inputMode {
+    case .media:
+        break
+    default:
+        selfController.chatDisplayNode.collapseInput()
+    }
+    
+    selfController.tempHideAccessoryPanels = selfController.presentationInterfaceState.search != nil
+    
+    if selfController.isNodeLoaded {
+        selfController.chatDisplayNode.updateChatPresentationInterfaceState(updatedChatPresentationInterfaceState, transition: transition, interactive: interactive, completion: completion)
+    } else {
+        completion(.immediate)
+    }
+    
+    let updatedServiceTasks = serviceTasksForChatPresentationIntefaceState(context: selfController.context, chatPresentationInterfaceState: updatedChatPresentationInterfaceState, updateState: { [weak selfController] f in
+        guard let selfController else {
+            return
+        }
+        selfController.updateChatPresentationInterfaceState(animated: false, interactive: false, f)
+        
+        //selfController.chatDisplayNode.updateChatPresentationInterfaceState(f(selfController.chatDisplayNode.chatPresentationInterfaceState), transition: transition, interactive: false, completion: { _ in })
+    })
+    for (id, begin) in updatedServiceTasks {
+        if selfController.stateServiceTasks[id] == nil {
+            selfController.stateServiceTasks[id] = begin()
+        }
+    }
+    var removedServiceTaskIds: [AnyHashable] = []
+    for (id, _) in selfController.stateServiceTasks {
+        if updatedServiceTasks[id] == nil {
+            removedServiceTaskIds.append(id)
+        }
+    }
+    for id in removedServiceTaskIds {
+        selfController.stateServiceTasks.removeValue(forKey: id)?.dispose()
+    }
+    
+    if let button = leftNavigationButtonForChatInterfaceState(updatedChatPresentationInterfaceState, subject: selfController.subject, strings: updatedChatPresentationInterfaceState.strings, currentButton: selfController.leftNavigationButton, target: selfController, selector: #selector(selfController.leftNavigationButtonAction)) {
+        if selfController.leftNavigationButton != button {
+            var animated = transition.isAnimated
+            if let currentButton = selfController.leftNavigationButton?.action, currentButton == button.action {
+                animated = false
+            }
+            animated = false
+            selfController.navigationItem.setLeftBarButton(button.buttonItem, animated: animated && selfController.currentChatSwitchDirection == nil)
+            selfController.leftNavigationButton = button
+        }
+    } else if let _ = selfController.leftNavigationButton {
+        selfController.navigationItem.setLeftBarButton(nil, animated: transition.isAnimated && selfController.currentChatSwitchDirection == nil)
+        selfController.leftNavigationButton = nil
+    }
+    
+    var buttonsAnimated = transition.isAnimated
+    if let button = rightNavigationButtonForChatInterfaceState(context: selfController.context, presentationInterfaceState: updatedChatPresentationInterfaceState, strings: updatedChatPresentationInterfaceState.strings, currentButton: selfController.rightNavigationButton, target: selfController, selector: #selector(selfController.rightNavigationButtonAction), chatInfoNavigationButton: selfController.chatInfoNavigationButton, moreInfoNavigationButton: selfController.moreInfoNavigationButton) {
+        if selfController.rightNavigationButton != button {
+            if let currentButton = selfController.rightNavigationButton?.action, currentButton == button.action {
+                buttonsAnimated = false
+            }
+            selfController.rightNavigationButton = button
+        }
+    } else if let _ = selfController.rightNavigationButton {
+        selfController.rightNavigationButton = nil
+    }
+    
+    if let button = secondaryRightNavigationButtonForChatInterfaceState(context: selfController.context, presentationInterfaceState: updatedChatPresentationInterfaceState, strings: updatedChatPresentationInterfaceState.strings, currentButton: selfController.secondaryRightNavigationButton, target: selfController, selector: #selector(selfController.secondaryRightNavigationButtonAction), chatInfoNavigationButton: selfController.chatInfoNavigationButton, moreInfoNavigationButton: selfController.moreInfoNavigationButton) {
+        if selfController.secondaryRightNavigationButton != button {
+            if let currentButton = selfController.secondaryRightNavigationButton?.action, currentButton == button.action {
+                buttonsAnimated = false
+            }
+            if case .replyThread = selfController.chatLocation {
+                buttonsAnimated = false
+            }
+            selfController.secondaryRightNavigationButton = button
+        }
+    } else if let _ = selfController.secondaryRightNavigationButton {
+        selfController.secondaryRightNavigationButton = nil
+    }
+    
+    var rightBarButtons: [UIBarButtonItem] = []
+    if let rightNavigationButton = selfController.rightNavigationButton {
+        rightBarButtons.append(rightNavigationButton.buttonItem)
+    }
+    if let secondaryRightNavigationButton = selfController.secondaryRightNavigationButton {
+        rightBarButtons.append(secondaryRightNavigationButton.buttonItem)
+    }
+    var rightBarButtonsUpdated = false
+    let currentRightBarButtons = selfController.navigationItem.rightBarButtonItems ?? []
+    if rightBarButtons.count != currentRightBarButtons.count {
+        rightBarButtonsUpdated = true
+    } else {
+        for i in 0 ..< rightBarButtons.count {
+            if rightBarButtons[i] !== currentRightBarButtons[i] {
+                rightBarButtonsUpdated = true
+                break
+            }
+        }
+    }
+    if rightBarButtonsUpdated {
+        selfController.navigationItem.setRightBarButtonItems(rightBarButtons, animated: buttonsAnimated)
+    }
+    
+    if let controllerInteraction = selfController.controllerInteraction {
+        if updatedChatPresentationInterfaceState.interfaceState.selectionState != controllerInteraction.selectionState {
+            controllerInteraction.selectionState = updatedChatPresentationInterfaceState.interfaceState.selectionState
+            let isBlackout = controllerInteraction.selectionState != nil
+            let previousCompletion = completion
+            completion = { [weak selfController] transition in
+                previousCompletion(transition)
+                
+                guard let selfController else {
+                    return
+                }
+                (selfController.navigationController as? NavigationController)?.updateMasterDetailsBlackout(isBlackout ? .master : nil, transition: transition)
+            }
+            selfController.updateItemNodesSelectionStates(animated: transition.isAnimated)
+        }
+    }
+    
+    if saveInterfaceState {
+        selfController.saveInterfaceState(includeScrollState: false)
+    }
+    
+    if let navigationController = selfController.navigationController as? NavigationController, isTopmostChatController(selfController) {
+        var voiceChatOverlayController: VoiceChatOverlayController?
+        for controller in navigationController.globalOverlayControllers {
+            if let controller = controller as? VoiceChatOverlayController {
+                voiceChatOverlayController = controller
+                break
+            }
+        }
+        
+        if let controller = voiceChatOverlayController {
+            controller.updateVisibility()
+        }
+    }
+     
+    selfController.presentationInterfaceStatePromise.set(selfController.presentationInterfaceState)
+    
+    if case .tag = selfController.chatDisplayNode.historyNode.tag {
+    } else {
+        if let historyFilter = selfController.presentationInterfaceState.historyFilter, historyFilter.isActive {
+            selfController.chatDisplayNode.historyNode.updateTag(tag: .customTag(historyFilter.customTag, nil))
+        } else {
+            selfController.chatDisplayNode.historyNode.updateTag(tag: nil)
+        }
+    }
+    
+    selfController.updateDownButtonVisibility()
+    
+    if selfController.presentationInterfaceState.hasBirthdayToday {
+        selfController.displayBirthdayTooltip()
+    }
+        
+    if case .standard(.embedded) = selfController.presentationInterfaceState.mode, let controllerInteraction = selfController.controllerInteraction, let interfaceInteraction = selfController.interfaceInteraction {
+        if let titleAccessoryPanelNode = titlePanelForChatPresentationInterfaceState(selfController.presentationInterfaceState, context: selfController.context, currentPanel: selfController.customNavigationPanelNode as? ChatTitleAccessoryPanelNode, controllerInteraction: controllerInteraction, interfaceInteraction: interfaceInteraction, force: true) {
+            selfController.customNavigationPanelNode = titleAccessoryPanelNode as? ChatControllerCustomNavigationPanelNode
+        } else {
+            selfController.customNavigationPanelNode = nil
+        }
+    }
+    
+    selfController.stateUpdated?(transition)
+}