Fetch poll history (PSG-1043)

Riot/Assets/en.lproj/Vector.strings

@@ -2304,10 +2304,13 @@ Tap the + to start adding people.";
 // MARK: - Polls history
 
 "poll_history_title" = "Poll history";
+"poll_history_loading_text" = "Displaying polls";
 "poll_history_active_segment_title" = "Active polls";
 "poll_history_past_segment_title" = "Past polls";
 "poll_history_no_active_poll_text" = "There are no active polls in this room";
 "poll_history_no_past_poll_text" = "There are no past polls in this room";
+"poll_history_no_active_poll_period_text" = "There are no active polls for the past %@ days. Load more polls to view polls for previous months";
+"poll_history_no_past_poll_period_text" = "There are no past polls for the past %@ days. Load more polls to view polls for previous months";
 
 // MARK: - Polls
 

Riot/Generated/Strings.swift

@@ -4851,10 +4851,22 @@ public class VectorL10n: NSObject {
   public static var pollHistoryActiveSegmentTitle: String { 
     return VectorL10n.tr("Vector", "poll_history_active_segment_title") 
   }
+  /// Displaying polls
+  public static var pollHistoryLoadingText: String { 
+    return VectorL10n.tr("Vector", "poll_history_loading_text") 
+  }
+  /// There are no active polls for the past %@ days. Load more polls to view polls for previous months
+  public static func pollHistoryNoActivePollPeriodText(_ p1: String) -> String {
+    return VectorL10n.tr("Vector", "poll_history_no_active_poll_period_text", p1)
+  }
   /// There are no active polls in this room
   public static var pollHistoryNoActivePollText: String { 
     return VectorL10n.tr("Vector", "poll_history_no_active_poll_text") 
   }
+  /// There are no past polls for the past %@ days. Load more polls to view polls for previous months
+  public static func pollHistoryNoPastPollPeriodText(_ p1: String) -> String {
+    return VectorL10n.tr("Vector", "poll_history_no_past_poll_period_text", p1)
+  }
   /// There are no past polls in this room
   public static var pollHistoryNoPastPollText: String { 
     return VectorL10n.tr("Vector", "poll_history_no_past_poll_text") 

Riot/Modules/Room/RoomInfo/RoomInfoCoordinator.swift

@@ -176,7 +176,7 @@ final class RoomInfoCoordinator: NSObject, RoomInfoCoordinatorType {
             coordinator.start()
             push(coordinator: coordinator)
         case .pollHistory:
-            let coordinator: PollHistoryCoordinator = .init(parameters: .init(mode: .active))
+            let coordinator: PollHistoryCoordinator = .init(parameters: .init(mode: .active, room: self.room))
             coordinator.start()
             push(coordinator: coordinator)
         default:

RiotSwiftUI/Modules/Room/PollHistory/Coordinator/PollHistoryCoordinator.swift

@@ -19,6 +19,7 @@ import SwiftUI
 
 struct PollHistoryCoordinatorParameters {
     let mode: PollHistoryMode
+    let room: MXRoom
 }
 
 final class PollHistoryCoordinator: Coordinator, Presentable {
@@ -32,9 +33,7 @@ final class PollHistoryCoordinator: Coordinator, Presentable {
 
     init(parameters: PollHistoryCoordinatorParameters) {
         self.parameters = parameters
-
-        #warning("replace with the real service after that it's done")
-        let viewModel = PollHistoryViewModel(mode: parameters.mode, pollService: MockPollHistoryService())
+        let viewModel = PollHistoryViewModel(mode: parameters.mode, pollService: PollHistoryService(room: parameters.room, chunkSizeInDays: PollHistoryConstants.chunkSizeInDays))
         let view = PollHistory(viewModel: viewModel.context)
         pollHistoryViewModel = viewModel
         pollHistoryHostingController = VectorHostingController(rootView: view)

RiotSwiftUI/Modules/Room/PollHistory/MockPollHistoryScreenState.swift

@@ -14,6 +14,7 @@
 // limitations under the License.
 //
 
+import Combine
 import Foundation
 import SwiftUI
 
@@ -27,6 +28,7 @@ enum MockPollHistoryScreenState: MockScreenState, CaseIterable {
     case past
     case activeEmpty
     case pastEmpty
+    case loading
 
     /// The associated screen
     var screenType: Any.Type {
@@ -45,10 +47,19 @@ enum MockPollHistoryScreenState: MockScreenState, CaseIterable {
             pollHistoryMode = .past
         case .activeEmpty:
             pollHistoryMode = .active
-            pollService.activePollsData = []
+            pollService.nextPublisher = Empty(completeImmediately: true,
+                                              outputType: TimelinePollDetails.self,
+                                              failureType: Error.self).eraseToAnyPublisher()
         case .pastEmpty:
             pollHistoryMode = .past
-            pollService.pastPollsData = []
+            pollService.nextPublisher = Empty(completeImmediately: true,
+                                              outputType: TimelinePollDetails.self,
+                                              failureType: Error.self).eraseToAnyPublisher()
+        case .loading:
+            pollHistoryMode = .active
+            pollService.nextPublisher = Empty(completeImmediately: false,
+                                              outputType: TimelinePollDetails.self,
+                                              failureType: Error.self).eraseToAnyPublisher()
         }
 
         let viewModel = PollHistoryViewModel(mode: pollHistoryMode, pollService: pollService)

RiotSwiftUI/Modules/Room/PollHistory/PollHistoryModels.swift

@@ -16,6 +16,10 @@
 
 // MARK: View model
 
+enum PollHistoryConstants {
+    static let chunkSizeInDays: UInt = 30
+}
+
 enum PollHistoryViewModelResult: Equatable {
     #warning("e.g. show poll detail")
 }
@@ -37,7 +41,9 @@ struct PollHistoryViewState: BindableState {
     }
 
     var bindings: PollHistoryViewBindings
-    var polls: [PollListData] = []
+    var isLoading = false
+    var canLoadMoreContent = true
+    var polls: [TimelinePollDetails]?
 }
 
 enum PollHistoryViewAction {

RiotSwiftUI/Modules/Room/PollHistory/PollHistoryViewModel.swift

@@ -14,18 +14,15 @@
 // limitations under the License.
 //
 
+import Combine
 import SwiftUI
 
 typealias PollHistoryViewModelType = StateStoreViewModel<PollHistoryViewState, PollHistoryViewAction>
 
 final class PollHistoryViewModel: PollHistoryViewModelType, PollHistoryViewModelProtocol {
     private let pollService: PollHistoryServiceProtocol
-    private var polls: [PollListData] = []
-    private var fetchingTask: Task<Void, Error>? {
-        didSet {
-            oldValue?.cancel()
-        }
-    }
+    private var polls: [TimelinePollDetails]?
+    private var subcriptions: Set<AnyCancellable> = .init()
 
     var completion: ((PollHistoryViewModelResult) -> Void)?
 
@@ -39,39 +36,68 @@ final class PollHistoryViewModel: PollHistoryViewModelType, PollHistoryViewModel
     override func process(viewAction: PollHistoryViewAction) {
         switch viewAction {
         case .viewAppeared:
-            fetchingTask = fetchPolls()
+            setupUpdateSubscriptions()
+            fetchFirstBatch()
         case .segmentDidChange:
-            updatePolls()
+            updateViewState()
         }
     }
 }
 
 private extension PollHistoryViewModel {
-    func fetchPolls() -> Task<Void, Error> {
-        Task {
-            let polls = try await pollService.fetchHistory()
-
-            guard Task.isCancelled == false else {
-                return
+    func fetchFirstBatch() {
+        state.isLoading = true
+
+        pollService
+            .next()
+            .collect()
+            .sink { [weak self] _ in
+                #warning("Handle errors")
+                self?.state.isLoading = false
+            } receiveValue: { [weak self] polls in
+                self?.polls = polls
+                self?.updateViewState()
             }
-
-            await MainActor.run {
-                self.polls = polls
-                updatePolls()
+            .store(in: &subcriptions)
+    }
+
+    func setupUpdateSubscriptions() {
+        subcriptions.removeAll()
+
+        pollService
+            .updates
+            .sink { [weak self] detail in
+                self?.updatePolls(with: detail)
+                self?.updateViewState()
+            }
+            .store(in: &subcriptions)
+
+        pollService
+            .pollErrors
+            .sink { detail in
+                #warning("Handle errors")
             }
+            .store(in: &subcriptions)
+    }
+
+    func updatePolls(with poll: TimelinePollDetails) {
+        guard let pollIndex = polls?.firstIndex(where: { $0.id == poll.id }) else {
+            return
         }
+
+        polls?[pollIndex] = poll
     }
 
-    func updatePolls() {
-        let renderedPolls: [PollListData]
+    func updateViewState() {
+        let renderedPolls: [TimelinePollDetails]?
 
         switch context.mode {
         case .active:
-            renderedPolls = polls.filter { $0.winningOption == nil }
+            renderedPolls = polls?.filter { $0.closed == false }
         case .past:
-            renderedPolls = polls.filter { $0.winningOption != nil }
+            renderedPolls = polls?.filter { $0.closed == true }
         }
 
-        state.polls = renderedPolls
+        state.polls = renderedPolls?.sorted(by: { $0.startDate > $1.startDate })
     }
 }

RiotSwiftUI/Modules/Room/PollHistory/Service/MatrixSDK/PollHistoryService.swift

@@ -14,11 +14,141 @@
 // limitations under the License.
 //
 
-import MatrixSDK
+import Combine
 import Foundation
+import MatrixSDK
 
 final class PollHistoryService: PollHistoryServiceProtocol {
-    func fetchHistory() async throws -> [PollListData] {
-        []
+    private let room: MXRoom
+    private let timeline: MXEventTimeline
+    private let chunkSizeInDays: UInt
+    private var timelineListener: Any?
+
+    private let updatesSubject: PassthroughSubject<TimelinePollDetails, Never> = .init()
+    private let pollErrorsSubject: PassthroughSubject<Error, Never> = .init()
+
+    private var pollAggregators: [String: PollAggregator] = [:]
+    private var targetTimestamp: Date
+    private var oldestEventDate: Date = .distantFuture
+    private var currentBatchSubject: PassthroughSubject<TimelinePollDetails, Error>?
+
+    var updates: AnyPublisher<TimelinePollDetails, Never> {
+        updatesSubject.eraseToAnyPublisher()
+    }
+
+    var pollErrors: AnyPublisher<Error, Never> {
+        pollErrorsSubject.eraseToAnyPublisher()
+    }
+
+    init(room: MXRoom, chunkSizeInDays: UInt) {
+        self.room = room
+        self.chunkSizeInDays = chunkSizeInDays
+        timeline = MXRoomEventTimeline(room: room, andInitialEventId: nil)
+        targetTimestamp = Date().addingTimeInterval(-TimeInterval(chunkSizeInDays) * Constants.oneDayInSeconds)
+        setup(timeline: timeline)
+    }
+
+    func next() -> AnyPublisher<TimelinePollDetails, Error> {
+        currentBatchSubject?.eraseToAnyPublisher() ?? startPagination()
+    }
+}
+
+private extension PollHistoryService {
+    enum Constants {
+        static let pageSize: UInt = 500
+        static let oneDayInSeconds: TimeInterval = 8.6 * 10e3
+    }
+
+    func setup(timeline: MXEventTimeline) {
+        timelineListener = timeline.listenToEvents { [weak self] event, _, _ in
+            if event.eventType == .pollStart {
+                self?.aggregatePoll(pollStartEvent: event)
+            }
+
+            self?.updateTimestamp(event: event)
+        }
+    }
+
+    func updateTimestamp(event: MXEvent) {
+        oldestEventDate = min(event.originServerDate, oldestEventDate)
+    }
+
+    func startPagination() -> AnyPublisher<TimelinePollDetails, Error> {
+        let batchSubject = PassthroughSubject<TimelinePollDetails, Error>()
+        currentBatchSubject = batchSubject
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else {
+                return
+            }
+            self.timeline.resetPagination()
+            self.paginate(timeline: self.timeline)
+        }
+
+        return batchSubject.eraseToAnyPublisher()
+    }
+
+    func paginate(timeline: MXEventTimeline) {
+        timeline.paginate(Constants.pageSize, direction: .backwards, onlyFromStore: false) { [weak self] response in
+            guard let self = self else {
+                return
+            }
+
+            switch response {
+            case .success:
+                if timeline.canPaginate(.backwards), self.timestampTargetReached == false {
+                    self.paginate(timeline: timeline)
+                } else {
+                    self.completeBatch(completion: .finished)
+                }
+            case .failure(let error):
+                self.completeBatch(completion: .failure(error))
+            }
+        }
+    }
+
+    func completeBatch(completion: Subscribers.Completion<Error>) {
+        currentBatchSubject?.send(completion: completion)
+        currentBatchSubject = nil
+    }
+
+    func aggregatePoll(pollStartEvent: MXEvent) {
+        guard pollAggregators[pollStartEvent.eventId] == nil else {
+            return
+        }
+
+        guard let aggregator = try? PollAggregator(session: room.mxSession, room: room, pollEvent: pollStartEvent, delegate: self) else {
+            return
+        }
+
+        pollAggregators[pollStartEvent.eventId] = aggregator
+    }
+
+    var timestampTargetReached: Bool {
+        oldestEventDate <= targetTimestamp
+    }
+}
+
+private extension MXEvent {
+    var originServerDate: Date {
+        .init(timeIntervalSince1970: Double(originServerTs) / 1000)
+    }
+}
+
+// MARK: - PollAggregatorDelegate
+
+extension PollHistoryService: PollAggregatorDelegate {
+    func pollAggregatorDidStartLoading(_ aggregator: PollAggregator) {}
+
+    func pollAggregatorDidEndLoading(_ aggregator: PollAggregator) {
+        currentBatchSubject?.send(.init(poll: aggregator.poll, represent: .started))
+    }
+
+    func pollAggregator(_ aggregator: PollAggregator, didFailWithError: Error) {
+        pollErrorsSubject.send(didFailWithError)
+    }
+
+    func pollAggregatorDidUpdateData(_ aggregator: PollAggregator) {
+        updatesSubject.send(.init(poll: aggregator.poll, represent: .started))
     }
 }