PinnedBanner is now managed by the RoomScreenViewModel (#3163)

ElementX/Sources/Screens/RoomScreen/RoomScreenViewModel.swift

@@ -16,24 +16,148 @@
 
 import Combine
 import Foundation
+import OrderedCollections
 import SwiftUI
 
 typealias RoomScreenViewModelType = StateStoreViewModel<RoomScreenViewState, RoomScreenViewAction>
 
 class RoomScreenViewModel: RoomScreenViewModelType, RoomScreenViewModelProtocol {
+    private let roomProxy: RoomProxyProtocol
+    private let appMediator: AppMediatorProtocol
+    private let appSettings: AppSettings
+    private let pinnedEventStringBuilder: RoomEventStringBuilder
+    
     private let actionsSubject: PassthroughSubject<RoomScreenViewModelAction, Never> = .init()
     var actions: AnyPublisher<RoomScreenViewModelAction, Never> {
         actionsSubject.eraseToAnyPublisher()
     }
     
-    init() {
+    private var pinnedEventsTimelineProvider: RoomTimelineProviderProtocol? {
+        didSet {
+            guard let pinnedEventsTimelineProvider else {
+                return
+            }
+            
+            buildPinnedEventContents(timelineItems: pinnedEventsTimelineProvider.itemProxies)
+            pinnedEventsTimelineProvider.updatePublisher
+                // When pinning or unpinning an item, the timeline might return empty for a short while, so we need to debounce it to prevent weird UI behaviours like the banner disappearing
+                .debounce(for: .milliseconds(100), scheduler: DispatchQueue.main)
+                .sink { [weak self] updatedItems, _ in
+                    guard let self else { return }
+                    buildPinnedEventContents(timelineItems: updatedItems)
+                }
+                .store(in: &cancellables)
+        }
+    }
+    
+    init(roomProxy: RoomProxyProtocol,
+         appMediator: AppMediatorProtocol,
+         appSettings: AppSettings) {
+        self.roomProxy = roomProxy
+        self.appMediator = appMediator
+        self.appSettings = appSettings
+        pinnedEventStringBuilder = .pinnedEventStringBuilder(userID: roomProxy.ownUserID)
+
         super.init(initialViewState: .init(bindings: .init()))
+        
+        setupSubscriptions()
+    }
+    
+    override func process(viewAction: RoomScreenViewAction) {
+        switch viewAction {
+        case .tappedPinnedEventsBanner:
+            if let eventID = state.pinnedEventsBannerState.selectedPinEventID {
+                actionsSubject.send(.focusEvent(eventID: eventID))
+            }
+            state.pinnedEventsBannerState.previousPin()
+        case .viewAllPins:
+            actionsSubject.send(.displayPinnedEventsTimeline)
+        }
+    }
+    
+    func timelineHasScrolled(direction: ScrollDirection) {
+        state.lastScrollDirection = direction
+    }
+    
+    private func setupSubscriptions() {
+        let roomInfoSubscription = roomProxy
+            .actionsPublisher
+            .filter { $0 == .roomInfoUpdate }
+        
+        Task { [weak self] in
+            // Don't guard let self here, otherwise the for await will strongify the self reference creating a strong reference cycle.
+            // If the subscription has sent a value before the Task has started it might be lost, so before entering the loop we always do an update.
+            await self?.updatePinnedEventIDs()
+            for await _ in roomInfoSubscription.receive(on: DispatchQueue.main).values {
+                guard !Task.isCancelled else {
+                    return
+                }
+                await self?.updatePinnedEventIDs()
+            }
+        }
+        .store(in: &cancellables)
+        
+        let pinningEnabledPublisher = appSettings.$pinningEnabled
+        
+        pinningEnabledPublisher
+            .weakAssign(to: \.state.isPinningEnabled, on: self)
+            .store(in: &cancellables)
+        
+        pinningEnabledPublisher
+            .combineLatest(appMediator.networkMonitor.reachabilityPublisher)
+            .filter { $0.0 && $0.1 == .reachable }
+            .receive(on: DispatchQueue.main)
+            .sink { [weak self] _ in
+                self?.setupPinnedEventsTimelineProviderIfNeeded()
+            }
+            .store(in: &cancellables)
+    }
+    
+    private func buildPinnedEventContents(timelineItems: [TimelineItemProxy]) {
+        var pinnedEventContents = OrderedDictionary<String, AttributedString>()
+        
+        for item in timelineItems {
+            // Only remote events are pinned
+            if case let .event(event) = item,
+               let eventID = event.id.eventID {
+                pinnedEventContents.updateValue(pinnedEventStringBuilder.buildAttributedString(for: event) ?? AttributedString(L10n.commonUnsupportedEvent),
+                                                forKey: eventID)
+            }
+        }
+        
+        state.pinnedEventsBannerState.setPinnedEventContents(pinnedEventContents)
+    }
+    
+    private func updatePinnedEventIDs() async {
+        let pinnedEventIDs = await roomProxy.pinnedEventIDs
+        // Only update the loading state of the banner
+        if state.pinnedEventsBannerState.isLoading {
+            state.pinnedEventsBannerState = .loading(numbersOfEvents: pinnedEventIDs.count)
+        }
+    }
+    
+    private func setupPinnedEventsTimelineProviderIfNeeded() {
+        guard pinnedEventsTimelineProvider == nil else {
+            return
+        }
+        
+        Task {
+            guard let timelineProvider = await roomProxy.pinnedEventsTimeline?.timelineProvider else {
+                return
+            }
+            
+            if pinnedEventsTimelineProvider == nil {
+                pinnedEventsTimelineProvider = timelineProvider
+            }
+        }
     }
 }
 
 extension RoomScreenViewModel {
     static func mock() -> RoomScreenViewModel {
-        RoomScreenViewModel()
+        RoomScreenViewModel(roomProxy: RoomProxyMock(.init()),
+                            appMediator: AppMediatorMock.default,
+                            appSettings: ServiceLocator.shared.settings)
     }
 }