Polls history (#2244)

ElementX/Sources/FlowCoordinators/RoomFlowCoordinator.swift

@@ -206,12 +206,22 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                 return .mapNavigator(roomID: roomID)
             case (.mapNavigator(let roomID), .dismissMapNavigator):
                 return .room(roomID: roomID)
-
+            
             case (.room(let roomID), .presentPollForm):
                 return .pollForm(roomID: roomID)
             case (.pollForm(let roomID), .dismissPollForm):
                 return .room(roomID: roomID)
-
+            
+            case (.roomDetails(let roomID, _), .presentPollsHistory):
+                return .pollsHistory(roomID: roomID)
+            case (.pollsHistory(let roomID), .dismissPollsHistory):
+                return .roomDetails(roomID: roomID, isRoot: false)
+            
+            case (.pollsHistory(let roomID), .presentPollForm):
+                return .pollsHistoryForm(roomID: roomID)
+            case (.pollsHistoryForm(let roomID), .dismissPollForm):
+                return .pollsHistory(roomID: roomID)
+            
             default:
                 return nil
             }
@@ -320,6 +330,16 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
             case (.pollForm, .dismissPollForm, .room):
                 break
 
+            case (.roomDetails(let roomID, _), .presentPollsHistory, .pollsHistory):
+                presentPollsHistory(roomID: roomID)
+            case (.pollsHistory, .dismissPollsHistory, .roomDetails):
+                break
+        
+            case (.pollsHistory, .presentPollForm(let mode), .pollsHistoryForm):
+                presentPollForm(mode: mode)
+            case (.pollsHistoryForm, .dismissPollForm, .pollsHistory):
+                break
+            
             default:
                 fatalError("Unknown transition: \(context)")
             }
@@ -516,6 +536,8 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
                 stateMachine.tryEvent(.presentNotificationSettingsScreen)
             case .presentInviteUsersScreen:
                 stateMachine.tryEvent(.presentInviteUsersScreen)
+            case .presentPollsHistory:
+                stateMachine.tryEvent(.presentPollsHistory)
             }
         }
         .store(in: &cancellables)
@@ -845,6 +867,58 @@ class RoomFlowCoordinator: FlowCoordinatorProtocol {
         }
     }
     
+    private func presentPollsHistory(roomID: String) {
+        Task {
+            await asyncPresentRoomPollsHistory(roomID: roomID)
+        }
+    }
+    
+    private func asyncPresentRoomPollsHistory(roomID: String) async {
+        let roomProxy: RoomProxyProtocol
+        
+        guard let proxy = await userSession.clientProxy.roomForIdentifier(roomID) else {
+            MXLog.error("Invalid room identifier: \(roomID)")
+            stateMachine.tryEvent(.dismissPollsHistory)
+            return
+        }
+        
+        roomProxy = proxy
+        
+        await roomProxy.subscribeForUpdates()
+                
+        let userID = userSession.clientProxy.userID
+        
+        let timelineItemFactory = RoomTimelineItemFactory(userID: userID,
+                                                          mediaProvider: userSession.mediaProvider,
+                                                          attributedStringBuilder: AttributedStringBuilder(permalinkBaseURL: appSettings.permalinkBaseURL,
+                                                                                                           mentionBuilder: MentionBuilder()),
+                                                          stateEventStringBuilder: RoomStateEventStringBuilder(userID: userID),
+                                                          appSettings: appSettings)
+                
+        let roomTimelineController = roomTimelineControllerFactory.buildRoomTimelineController(roomProxy: roomProxy,
+                                                                                               timelineItemFactory: timelineItemFactory,
+                                                                                               secureBackupController: userSession.clientProxy.secureBackupController)
+        
+        let parameters = RoomPollsHistoryScreenCoordinatorParameters(roomProxy: roomProxy,
+                                                                     pollInteractionHandler: PollInteractionHandler(analyticsService: analytics, roomProxy: roomProxy),
+                                                                     roomTimelineController: roomTimelineController)
+        let coordinator = RoomPollsHistoryScreenCoordinator(parameters: parameters)
+        coordinator.actions
+            .sink { [weak self] action in
+                guard let self else { return }
+                
+                switch action {
+                case .editPoll(let pollStartID, let poll):
+                    stateMachine.tryEvent(.presentPollForm(mode: .edit(eventID: pollStartID, poll: poll)))
+                }
+            }
+            .store(in: &cancellables)
+        
+        navigationStackCoordinator.push(coordinator) { [weak self] in
+            self?.stateMachine.tryEvent(.dismissPollsHistory)
+        }
+    }
+    
     private func presentRoomMemberDetails(member: RoomMemberProxyProtocol) {
         guard let roomProxy else {
             fatalError()
@@ -1106,6 +1180,8 @@ private extension RoomFlowCoordinator {
         case messageForwarding(roomID: String, itemID: TimelineItemIdentifier)
         case reportContent(roomID: String, itemID: TimelineItemIdentifier, senderID: String)
         case pollForm(roomID: String)
+        case pollsHistory(roomID: String)
+        case pollsHistoryForm(roomID: String)
     }
     
     struct EventUserInfo {
@@ -1158,6 +1234,9 @@ private extension RoomFlowCoordinator {
 
         case presentPollForm(mode: PollFormMode)
         case dismissPollForm
+        
+        case presentPollsHistory
+        case dismissPollsHistory
     }
 }