UI improvements

submodules/ChatListUI/Sources/ChatListSearchListPaneNode.swift

@@ -275,6 +275,7 @@ public enum ChatListSearchEntry: Comparable, Identifiable {
         case recentlyDownloaded
     }
     
+    case recentlySearchedPeer(EnginePeer, EnginePeer?, (Int32, Bool)?, Int, PresentationTheme, PresentationStrings, PresentationPersonNameOrder, PresentationPersonNameOrder)
     case localPeer(EnginePeer, EnginePeer?, (Int32, Bool)?, Int, PresentationTheme, PresentationStrings, PresentationPersonNameOrder, PresentationPersonNameOrder, ChatListSearchSectionExpandType)
     case globalPeer(FoundPeer, (Int32, Bool)?, Int, PresentationTheme, PresentationStrings, PresentationPersonNameOrder, PresentationPersonNameOrder, ChatListSearchSectionExpandType)
     case message(EngineMessage, EngineRenderedPeer, EnginePeerReadCounters?, ChatListPresentationData, Int32, Bool?, Bool, MessageOrderingKey, (id: String, size: Int, isFirstInList: Bool)?, MessageSection, Bool)
@@ -282,126 +283,219 @@ public enum ChatListSearchEntry: Comparable, Identifiable {
     
     public var stableId: ChatListSearchEntryStableId {
         switch self {
-            case let .localPeer(peer, _, _, _, _, _, _, _, _):
-                return .localPeerId(peer.id)
-            case let .globalPeer(peer, _, _, _, _, _, _, _):
-                return .globalPeerId(peer.peer.id)
-            case let .message(message, _, _, _, _, _, _, _, _, section, _):
-                return .messageId(message.id, section)
-            case .addContact:
-                return .addContact
+        case let .recentlySearchedPeer(peer, _, _, _, _, _, _, _):
+            return .localPeerId(peer.id)
+        case let .localPeer(peer, _, _, _, _, _, _, _, _):
+            return .localPeerId(peer.id)
+        case let .globalPeer(peer, _, _, _, _, _, _, _):
+            return .globalPeerId(peer.peer.id)
+        case let .message(message, _, _, _, _, _, _, _, _, section, _):
+            return .messageId(message.id, section)
+        case .addContact:
+            return .addContact
         }
     }
     
     public static func ==(lhs: ChatListSearchEntry, rhs: ChatListSearchEntry) -> Bool {
         switch lhs {
-            case let .localPeer(lhsPeer, lhsAssociatedPeer, lhsUnreadBadge, lhsIndex, lhsTheme, lhsStrings, lhsSortOrder, lhsDisplayOrder, lhsExpandType):
-                if case let .localPeer(rhsPeer, rhsAssociatedPeer, rhsUnreadBadge, rhsIndex, rhsTheme, rhsStrings, rhsSortOrder, rhsDisplayOrder, rhsExpandType) = rhs, lhsPeer == rhsPeer && lhsAssociatedPeer == rhsAssociatedPeer && lhsIndex == rhsIndex && lhsTheme === rhsTheme && lhsStrings === rhsStrings && lhsSortOrder == rhsSortOrder && lhsDisplayOrder == rhsDisplayOrder && lhsUnreadBadge?.0 == rhsUnreadBadge?.0 && lhsUnreadBadge?.1 == rhsUnreadBadge?.1 && lhsExpandType == rhsExpandType {
-                    return true
-                } else {
+        case let .recentlySearchedPeer(lhsPeer, lhsAssociatedPeer, lhsUnreadBadge, lhsIndex, lhsTheme, lhsStrings, lhsSortOrder, lhsDisplayOrder):
+            if case let .recentlySearchedPeer(rhsPeer, rhsAssociatedPeer, rhsUnreadBadge, rhsIndex, rhsTheme, rhsStrings, rhsSortOrder, rhsDisplayOrder) = rhs, lhsPeer == rhsPeer && lhsAssociatedPeer == rhsAssociatedPeer && lhsIndex == rhsIndex && lhsTheme === rhsTheme && lhsStrings === rhsStrings && lhsSortOrder == rhsSortOrder && lhsDisplayOrder == rhsDisplayOrder && lhsUnreadBadge?.0 == rhsUnreadBadge?.0 && lhsUnreadBadge?.1 == rhsUnreadBadge?.1 {
+                return true
+            } else {
+                return false
+            }
+        case let .localPeer(lhsPeer, lhsAssociatedPeer, lhsUnreadBadge, lhsIndex, lhsTheme, lhsStrings, lhsSortOrder, lhsDisplayOrder, lhsExpandType):
+            if case let .localPeer(rhsPeer, rhsAssociatedPeer, rhsUnreadBadge, rhsIndex, rhsTheme, rhsStrings, rhsSortOrder, rhsDisplayOrder, rhsExpandType) = rhs, lhsPeer == rhsPeer && lhsAssociatedPeer == rhsAssociatedPeer && lhsIndex == rhsIndex && lhsTheme === rhsTheme && lhsStrings === rhsStrings && lhsSortOrder == rhsSortOrder && lhsDisplayOrder == rhsDisplayOrder && lhsUnreadBadge?.0 == rhsUnreadBadge?.0 && lhsUnreadBadge?.1 == rhsUnreadBadge?.1 && lhsExpandType == rhsExpandType {
+                return true
+            } else {
+                return false
+            }
+        case let .globalPeer(lhsPeer, lhsUnreadBadge, lhsIndex, lhsTheme, lhsStrings, lhsSortOrder, lhsDisplayOrder, lhsExpandType):
+            if case let .globalPeer(rhsPeer, rhsUnreadBadge, rhsIndex, rhsTheme, rhsStrings, rhsSortOrder, rhsDisplayOrder, rhsExpandType) = rhs, lhsPeer == rhsPeer && lhsIndex == rhsIndex && lhsTheme === rhsTheme && lhsStrings === rhsStrings && lhsSortOrder == rhsSortOrder && lhsDisplayOrder == rhsDisplayOrder && lhsUnreadBadge?.0 == rhsUnreadBadge?.0 && lhsUnreadBadge?.1 == rhsUnreadBadge?.1 && lhsExpandType == rhsExpandType {
+                return true
+            } else {
+                return false
+            }
+        case let .message(lhsMessage, lhsPeer, lhsCombinedPeerReadState, lhsPresentationData, lhsTotalCount, lhsSelected, lhsDisplayCustomHeader, lhsKey, lhsResourceId, lhsSection, lhsAllPaused):
+            if case let .message(rhsMessage, rhsPeer, rhsCombinedPeerReadState, rhsPresentationData, rhsTotalCount, rhsSelected, rhsDisplayCustomHeader, rhsKey, rhsResourceId, rhsSection, rhsAllPaused) = rhs {
+                if lhsMessage.id != rhsMessage.id {
                     return false
                 }
-            case let .globalPeer(lhsPeer, lhsUnreadBadge, lhsIndex, lhsTheme, lhsStrings, lhsSortOrder, lhsDisplayOrder, lhsExpandType):
-                if case let .globalPeer(rhsPeer, rhsUnreadBadge, rhsIndex, rhsTheme, rhsStrings, rhsSortOrder, rhsDisplayOrder, rhsExpandType) = rhs, lhsPeer == rhsPeer && lhsIndex == rhsIndex && lhsTheme === rhsTheme && lhsStrings === rhsStrings && lhsSortOrder == rhsSortOrder && lhsDisplayOrder == rhsDisplayOrder && lhsUnreadBadge?.0 == rhsUnreadBadge?.0 && lhsUnreadBadge?.1 == rhsUnreadBadge?.1 && lhsExpandType == rhsExpandType {
-                    return true
-                } else {
+                if lhsMessage.stableVersion != rhsMessage.stableVersion {
                     return false
                 }
-            case let .message(lhsMessage, lhsPeer, lhsCombinedPeerReadState, lhsPresentationData, lhsTotalCount, lhsSelected, lhsDisplayCustomHeader, lhsKey, lhsResourceId, lhsSection, lhsAllPaused):
-                if case let .message(rhsMessage, rhsPeer, rhsCombinedPeerReadState, rhsPresentationData, rhsTotalCount, rhsSelected, rhsDisplayCustomHeader, rhsKey, rhsResourceId, rhsSection, rhsAllPaused) = rhs {
-                    if lhsMessage.id != rhsMessage.id {
-                        return false
-                    }
-                    if lhsMessage.stableVersion != rhsMessage.stableVersion {
-                        return false
-                    }
-                    if lhsPeer != rhsPeer {
-                        return false
-                    }
-                    if lhsPresentationData !== rhsPresentationData {
-                        return false
-                    }
-                    if lhsCombinedPeerReadState != rhsCombinedPeerReadState {
-                        return false
-                    }
-                    if lhsTotalCount != rhsTotalCount {
-                        return false
-                    }
-                    if lhsSelected != rhsSelected {
-                        return false
-                    }
-                    if lhsDisplayCustomHeader != rhsDisplayCustomHeader {
-                        return false
-                    }
-                    if lhsKey != rhsKey {
-                        return false
-                    }
-                    if lhsResourceId?.0 != rhsResourceId?.0 {
-                        return false
-                    }
-                    if lhsResourceId?.1 != rhsResourceId?.1 {
-                        return false
-                    }
-                    if lhsSection != rhsSection {
-                        return false
-                    }
-                    if lhsAllPaused != rhsAllPaused {
-                        return false
-                    }
-                    return true
-                } else {
+                if lhsPeer != rhsPeer {
                     return false
                 }
-            case let .addContact(lhsPhoneNumber, lhsTheme, lhsStrings):
-                if case let .addContact(rhsPhoneNumber, rhsTheme, rhsStrings) = rhs {
-                    if lhsPhoneNumber != rhsPhoneNumber {
-                        return false
-                    }
-                    if lhsTheme !== rhsTheme {
-                        return false
-                    }
-                    if lhsStrings !== rhsStrings {
-                        return false
-                    }
-                    return true
-                } else {
+                if lhsPresentationData !== rhsPresentationData {
                     return false
                 }
+                if lhsCombinedPeerReadState != rhsCombinedPeerReadState {
+                    return false
+                }
+                if lhsTotalCount != rhsTotalCount {
+                    return false
+                }
+                if lhsSelected != rhsSelected {
+                    return false
+                }
+                if lhsDisplayCustomHeader != rhsDisplayCustomHeader {
+                    return false
+                }
+                if lhsKey != rhsKey {
+                    return false
+                }
+                if lhsResourceId?.0 != rhsResourceId?.0 {
+                    return false
+                }
+                if lhsResourceId?.1 != rhsResourceId?.1 {
+                    return false
+                }
+                if lhsSection != rhsSection {
+                    return false
+                }
+                if lhsAllPaused != rhsAllPaused {
+                    return false
+                }
+                return true
+            } else {
+                return false
+            }
+        case let .addContact(lhsPhoneNumber, lhsTheme, lhsStrings):
+            if case let .addContact(rhsPhoneNumber, rhsTheme, rhsStrings) = rhs {
+                if lhsPhoneNumber != rhsPhoneNumber {
+                    return false
+                }
+                if lhsTheme !== rhsTheme {
+                    return false
+                }
+                if lhsStrings !== rhsStrings {
+                    return false
+                }
+                return true
+            } else {
+                return false
+            }
         }
     }
         
     public static func <(lhs: ChatListSearchEntry, rhs: ChatListSearchEntry) -> Bool {
         switch lhs {
-            case let .localPeer(_, _, _, lhsIndex, _, _, _, _, _):
-                if case let .localPeer(_, _, _, rhsIndex, _, _, _, _, _) = rhs {
-                    return lhsIndex <= rhsIndex
-                } else {
-                    return true
-                }
-            case let .globalPeer(_, _, lhsIndex, _, _, _, _, _):
-                switch rhs {
-                    case .localPeer:
-                        return false
-                    case let .globalPeer(_, _, rhsIndex, _, _, _, _, _):
-                        return lhsIndex <= rhsIndex
-                    case .message, .addContact:
-                        return true
-                }
-            case let .message(_, _, _, _, _, _, _, lhsKey, _, _, _):
-                if case let .message(_, _, _, _, _, _, _, rhsKey, _, _, _) = rhs {
-                    return lhsKey < rhsKey
-                } else if case .addContact = rhs {
-                    return true
-                } else {
-                    return false
-                }
-            case .addContact:
+        case let .recentlySearchedPeer(_, _, _, lhsIndex, _, _, _, _):
+            if case let .recentlySearchedPeer(_, _, _, rhsIndex, _, _, _, _) = rhs {
+                return lhsIndex <= rhsIndex
+            } else {
+                return true
+            }
+        case let .localPeer(_, _, _, lhsIndex, _, _, _, _, _):
+            switch rhs {
+            case .recentlySearchedPeer:
                 return false
+            case let .localPeer(_, _, _, rhsIndex, _, _, _, _, _):
+                return lhsIndex <= rhsIndex
+            case .globalPeer, .message, .addContact:
+                return true
+            }
+        case let .globalPeer(_, _, lhsIndex, _, _, _, _, _):
+            switch rhs {
+            case .recentlySearchedPeer, .localPeer:
+                return false
+            case let .globalPeer(_, _, rhsIndex, _, _, _, _, _):
+                return lhsIndex <= rhsIndex
+            case .message, .addContact:
+                return true
+            }
+        case let .message(_, _, _, _, _, _, _, lhsKey, _, _, _):
+            if case let .message(_, _, _, _, _, _, _, rhsKey, _, _, _) = rhs {
+                return lhsKey < rhsKey
+            } else if case .addContact = rhs {
+                return true
+            } else {
+                return false
+            }
+        case .addContact:
+            return false
         }
     }
     
     public func item(context: AccountContext, presentationData: PresentationData, enableHeaders: Bool, filter: ChatListNodePeersFilter, key: ChatListSearchPaneKey, tagMask: EngineMessage.Tags?, interaction: ChatListNodeInteraction, listInteraction: ListMessageItemInteraction, peerContextAction: ((EnginePeer, ChatListSearchContextActionSource, ASDisplayNode, ContextGesture?) -> Void)?, toggleExpandLocalResults: @escaping () -> Void, toggleExpandGlobalResults: @escaping () -> Void, searchPeer: @escaping (EnginePeer) -> Void, searchQuery: String?, searchOptions: ChatListSearchOptions?, messageContextAction: ((EngineMessage, ASDisplayNode?, CGRect?, UIGestureRecognizer?, ChatListSearchPaneKey, (id: String, size: Int, isFirstInList: Bool)?) -> Void)?, openClearRecentlyDownloaded: @escaping () -> Void, toggleAllPaused: @escaping () -> Void) -> ListViewItem {
         switch self {
+            case let .recentlySearchedPeer(peer, associatedPeer, unreadBadge, _, theme, strings, nameSortOrder, nameDisplayOrder):
+                let primaryPeer: EnginePeer
+                var chatPeer: EnginePeer?
+                if let associatedPeer = associatedPeer {
+                    primaryPeer = associatedPeer
+                    chatPeer = peer
+                } else {
+                    primaryPeer = peer
+                    chatPeer = peer
+                }
+                
+                var enabled = true
+                if filter.contains(.onlyWriteable) {
+                    if let peer = chatPeer {
+                        enabled = canSendMessagesToPeer(peer._asPeer())
+                    } else {
+                        enabled = false
+                    }
+                }
+                if filter.contains(.onlyPrivateChats) {
+                    if let peer = chatPeer {
+                        switch peer {
+                        case .user, .secretChat:
+                            break
+                        default:
+                            enabled = false
+                        }
+                    } else {
+                        enabled = false
+                    }
+                }
+                if filter.contains(.onlyGroups) {
+                    if let peer = chatPeer {
+                        if case .legacyGroup = peer {
+                        } else if case let .channel(peer) = peer, case .group = peer.info {
+                        } else {
+                            enabled = false
+                        }
+                    } else {
+                        enabled = false
+                    }
+                }
+                
+                var badge: ContactsPeerItemBadge?
+                if let unreadBadge = unreadBadge {
+                    badge = ContactsPeerItemBadge(count: unreadBadge.0, type: unreadBadge.1 ? .inactive : .active)
+                }
+                
+                let header: ChatListSearchItemHeader?
+                if filter.contains(.removeSearchHeader) {
+                    header = nil
+                } else {
+                    let headerType: ChatListSearchItemHeaderType
+                    if filter.contains(.onlyGroups) {
+                        headerType = .chats
+                    } else {
+                        headerType = .recentPeers
+                    }
+                    header = ChatListSearchItemHeader(type: headerType, theme: theme, strings: strings, actionTitle: nil, action: nil)
+                }
+                
+                return ContactsPeerItem(presentationData: ItemListPresentationData(presentationData), sortOrder: nameSortOrder, displayOrder: nameDisplayOrder, context: context, peerMode: .generalSearch, peer: .peer(peer: primaryPeer, chatPeer: chatPeer), status: .none, badge: badge, enabled: enabled, selection: .none, editing: ContactsPeerItemEditing(editable: false, editing: false, revealed: false), index: nil, header: header, action: { contactPeer in
+                    if case let .peer(maybePeer, maybeChatPeer) = contactPeer, let peer = maybePeer, let chatPeer = maybeChatPeer {
+                        interaction.peerSelected(chatPeer, peer, nil)
+                    } else {
+                        interaction.peerSelected(peer, nil, nil)
+                    }
+                }, contextAction: peerContextAction.flatMap { peerContextAction in
+                    return { node, gesture in
+                        if let chatPeer = chatPeer, chatPeer.id.namespace != Namespaces.Peer.SecretChat {
+                            peerContextAction(chatPeer, .search(nil), node, gesture)
+                        } else {
+                            gesture?.cancel()
+                        }
+                    }
+                }, arrowAction: nil)
             case let .localPeer(peer, associatedPeer, unreadBadge, _, theme, strings, nameSortOrder, nameDisplayOrder, expandType):
                 let primaryPeer: EnginePeer
                 var chatPeer: EnginePeer?
@@ -1063,27 +1157,53 @@ final class ChatListSearchListPaneNode: ASDisplayNode, ChatListSearchPaneNode {
             }
             
             let accountPeer = context.account.postbox.loadedPeerWithId(context.account.peerId) |> take(1)
-            let foundLocalPeers: Signal<(peers: [EngineRenderedPeer], unread: [EnginePeer.Id: (Int32, Bool)]), NoError>
+            let foundLocalPeers: Signal<(peers: [EngineRenderedPeer], unread: [EnginePeer.Id: (Int32, Bool)], recentlySearchedPeerIds: Set<EnginePeer.Id>), NoError>
             if let query = query {
-                foundLocalPeers = context.engine.contacts.searchLocalPeers(query: query.lowercased())
-                |> mapToSignal { local -> Signal<([EnginePeer.Id: Optional<EnginePeer.NotificationSettings>], [EnginePeer.Id: Int], [EngineRenderedPeer]), NoError> in
+                foundLocalPeers = combineLatest(
+                    context.engine.contacts.searchLocalPeers(query: query.lowercased()),
+                    context.engine.peers.recentlySearchedPeers()
+                )
+                |> mapToSignal { local, allRecentlySearched -> Signal<([EnginePeer.Id: Optional<EnginePeer.NotificationSettings>], [EnginePeer.Id: Int], [EngineRenderedPeer], Set<EnginePeer.Id>), NoError> in
+                    let recentlySearched = allRecentlySearched.filter { peer in
+                        guard let peer = peer.peer.peer else {
+                            return false
+                        }
+                        return peer.indexName.matchesByTokens(query)
+                    }
+                    
+                    var peerIds = Set<EnginePeer.Id>()
+                    
+                    var peers: [EngineRenderedPeer] = []
+                    for peer in recentlySearched {
+                        if !peerIds.contains(peer.peer.peerId) {
+                            peerIds.insert(peer.peer.peerId)
+                            peers.append(EngineRenderedPeer(peer.peer))
+                        }
+                    }
+                    for peer in local {
+                        if !peerIds.contains(peer.peerId) {
+                            peerIds.insert(peer.peerId)
+                            peers.append(peer)
+                        }
+                    }
+                    
                     return context.engine.data.subscribe(
                         EngineDataMap(
-                            local.map { peer -> TelegramEngine.EngineData.Item.Peer.NotificationSettings in
-                                return TelegramEngine.EngineData.Item.Peer.NotificationSettings(id: peer.peerId)
+                            peerIds.map { peerId -> TelegramEngine.EngineData.Item.Peer.NotificationSettings in
+                                return TelegramEngine.EngineData.Item.Peer.NotificationSettings(id: peerId)
                             }
                         ),
                         EngineDataMap(
-                            local.map { peer -> TelegramEngine.EngineData.Item.Messages.PeerUnreadCount in
-                                return TelegramEngine.EngineData.Item.Messages.PeerUnreadCount(id: peer.peerId)
+                            peerIds.map { peerId -> TelegramEngine.EngineData.Item.Messages.PeerUnreadCount in
+                                return TelegramEngine.EngineData.Item.Messages.PeerUnreadCount(id: peerId)
                             }
                         )
                     )
                     |> map { notificationSettings, unreadCounts in
-                        return (notificationSettings, unreadCounts, local)
+                        return (notificationSettings, unreadCounts, peers, Set(recentlySearched.map(\.peer.peerId)))
                     }
                 }
-                |> map { notificationSettings, unreadCounts, peers -> (peers: [EngineRenderedPeer], unread: [EnginePeer.Id: (Int32, Bool)]) in
+                |> map { notificationSettings, unreadCounts, peers, recentlySearchedPeerIds -> (peers: [EngineRenderedPeer], unread: [EnginePeer.Id: (Int32, Bool)], recentlySearchedPeerIds: Set<EnginePeer.Id>) in
                     var unread: [EnginePeer.Id: (Int32, Bool)] = [:]
                     for peer in peers {
                         var isMuted: Bool = false
@@ -1101,10 +1221,10 @@ final class ChatListSearchListPaneNode: ASDisplayNode, ChatListSearchPaneNode {
                             unread[peer.peerId] = (Int32(unreadCount), isMuted)
                         }
                     }
-                    return (peers: peers, unread: unread)
+                    return (peers: peers, unread: unread, recentlySearchedPeerIds: recentlySearchedPeerIds)
                 }
             } else {
-                foundLocalPeers = .single((peers: [], unread: [:]))
+                foundLocalPeers = .single((peers: [], unread: [:], recentlySearchedPeerIds: Set()))
             }
             
             let foundRemotePeers: Signal<([FoundPeer], [FoundPeer], Bool), NoError>
@@ -1293,10 +1413,9 @@ final class ChatListSearchListPaneNode: ASDisplayNode, ChatListSearchPaneNode {
                     }
                 }
                 
-                var numberOfLocalPeers = 0
                 for renderedPeer in foundLocalPeers.peers {
-                    if case .expand = localExpandType, numberOfLocalPeers >= 3 {
-                        break
+                    if !foundLocalPeers.recentlySearchedPeerIds.contains(renderedPeer.peerId) {
+                        continue
                     }
                     
                     if let peer = renderedPeer.peers[renderedPeer.peerId], peer.id != context.account.peerId, filteredPeer(peer, EnginePeer(accountPeer)) {
@@ -1306,6 +1425,31 @@ final class ChatListSearchListPaneNode: ASDisplayNode, ChatListSearchPaneNode {
                             if case let .secretChat(secretChat) = peer, let associatedPeerId = secretChat.associatedPeerId {
                                 associatedPeer = renderedPeer.peers[associatedPeerId]
                             }
+                            
+                            entries.append(.recentlySearchedPeer(peer, associatedPeer, foundLocalPeers.unread[peer.id], index, presentationData.theme, presentationData.strings, presentationData.nameSortOrder, presentationData.nameDisplayOrder))
+                            
+                            index += 1
+                        }
+                    }
+                }
+                
+                var numberOfLocalPeers = 0
+                for renderedPeer in foundLocalPeers.peers {
+                    if case .expand = localExpandType, numberOfLocalPeers >= 3 {
+                        break
+                    }
+                    if foundLocalPeers.recentlySearchedPeerIds.contains(renderedPeer.peerId) {
+                        continue
+                    }
+                    
+                    if let peer = renderedPeer.peers[renderedPeer.peerId], peer.id != context.account.peerId, filteredPeer(peer, EnginePeer(accountPeer)) {
+                        if !existingPeerIds.contains(peer.id) {
+                            existingPeerIds.insert(peer.id)
+                            var associatedPeer: EnginePeer?
+                            if case let .secretChat(secretChat) = peer, let associatedPeerId = secretChat.associatedPeerId {
+                                associatedPeer = renderedPeer.peers[associatedPeerId]
+                            }
+                            
                             entries.append(.localPeer(peer, associatedPeer, foundLocalPeers.unread[peer.id], index, presentationData.theme, presentationData.strings, presentationData.nameSortOrder, presentationData.nameDisplayOrder, localExpandType))
                             index += 1
                             numberOfLocalPeers += 1