Pinned Events Timeline actions and differentiation (#3182)

ElementX/Sources/Screens/RoomScreen/RoomScreenModels.swift

@@ -75,10 +75,10 @@ enum PinnedEventsBannerState: Equatable {
         }
     }
     
-    var selectedPinEventID: String? {
+    var selectedPinnedEventID: String? {
         switch self {
         case .loaded(let state):
-            return state.selectedPinEventID
+            return state.selectedPinnedEventID
         default:
             return nil
         }
@@ -93,10 +93,10 @@ enum PinnedEventsBannerState: Equatable {
         }
     }
     
-    var selectedPinIndex: Int {
+    var selectedPinnedIndex: Int {
         switch self {
         case .loaded(let state):
-            return state.selectedPinIndex
+            return state.selectedPinnedIndex
         case .loading(let numbersOfEvents):
             // We always want the index to be the last one when loading, since is the default one.
             return numbersOfEvents - 1
@@ -108,12 +108,12 @@ enum PinnedEventsBannerState: Equatable {
         case .loading:
             return AttributedString(L10n.screenRoomPinnedBannerLoadingDescription)
         case .loaded(let state):
-            return state.selectedPinContent
+            return state.selectedPinnedContent
         }
     }
     
     var bannerIndicatorDescription: AttributedString {
-        let index = selectedPinIndex + 1
+        let index = selectedPinnedIndex + 1
         let boldPlaceholder = "{bold}"
         var finalString = AttributedString(L10n.screenRoomPinnedBannerIndicatorDescription(boldPlaceholder))
         var boldString = AttributedString(L10n.screenRoomPinnedBannerIndicator(index, count))
@@ -136,10 +136,72 @@ enum PinnedEventsBannerState: Equatable {
         switch self {
         case .loading:
             // The default selected event should always be the last one.
-            self = .loaded(state: .init(pinnedEventContents: pinnedEventContents, selectedPinEventID: pinnedEventContents.keys.last))
+            self = .loaded(state: .init(pinnedEventContents: pinnedEventContents, selectedPinnedEventID: pinnedEventContents.keys.last))
         case .loaded(var state):
             state.pinnedEventContents = pinnedEventContents
             self = .loaded(state: state)
         }
     }
+    
+    // Note that if we are setting this value, this is definitely sent from the pinned events timeline
+    // so we can assume that the pinned events timeline is already loaded and we only need to set the
+    // selection for the loaded state
+    mutating func setSelectedPinnedEventID(_ eventID: String) {
+        switch self {
+        case .loaded(var state):
+            state.selectedPinnedEventID = eventID
+            self = .loaded(state: state)
+        case .loading:
+            break
+        }
+    }
+}
+
+struct PinnedEventsState: Equatable {
+    var pinnedEventContents: OrderedDictionary<String, AttributedString> = [:] {
+        didSet {
+            if selectedPinnedEventID == nil, !pinnedEventContents.keys.isEmpty {
+                // The default selected event should always be the last one.
+                selectedPinnedEventID = pinnedEventContents.keys.last
+            } else if pinnedEventContents.isEmpty {
+                selectedPinnedEventID = nil
+            } else if let selectedPinnedEventID, !pinnedEventContents.keys.set.contains(selectedPinnedEventID) {
+                self.selectedPinnedEventID = pinnedEventContents.keys.last
+            }
+        }
+    }
+    
+    var selectedPinnedEventID: String?
+    
+    var selectedPinnedIndex: Int {
+        let defaultValue = pinnedEventContents.isEmpty ? 0 : pinnedEventContents.count - 1
+        guard let selectedPinnedEventID else {
+            return defaultValue
+        }
+        return pinnedEventContents.keys.firstIndex(of: selectedPinnedEventID) ?? defaultValue
+    }
+    
+    var selectedPinnedContent: AttributedString {
+        var content = AttributedString(" ")
+        if let selectedPinnedEventID,
+           let pinnedEventContent = pinnedEventContents[selectedPinnedEventID] {
+            content = pinnedEventContent
+        }
+        content.font = .compound.bodyMD
+        content.link = nil
+        return content
+    }
+    
+    mutating func previousPin() {
+        guard !pinnedEventContents.isEmpty else {
+            return
+        }
+        let currentIndex = selectedPinnedIndex
+        let nextIndex = currentIndex - 1
+        if nextIndex == -1 {
+            selectedPinnedEventID = pinnedEventContents.keys.last
+        } else {
+            selectedPinnedEventID = pinnedEventContents.keys[nextIndex % pinnedEventContents.count]
+        }
+    }
 }