Add preference-controlled full timeline fetch option (#2351)

* Add optional full timeline fetching

* Cleanup

Author: Dimillian

IceCubesApp/App/Tabs/Settings/SettingsTab.swift

@@ -235,10 +235,12 @@ struct SettingsTabs: View {
         Label("Stream home timeline", systemImage: "antenna.radiowaves.left.and.right")
           .symbolVariant(preferences.streamHomeTimeline ? .none : .slash)
       }
+      Toggle(isOn: $preferences.fullTimelineFetch) {
+        Label("Full timeline fetch", systemImage: "arrow.triangle.2.circlepath")
+          .symbolVariant(preferences.fullTimelineFetch ? .none : .slash)
+      }
     } header: {
       Text("settings.section.other")
-    } footer: {
-      Text("settings.section.other.footer")
     }
     #if !os(visionOS)
       .listRowBackground(theme.primaryBackgroundColor)

Packages/Env/Sources/Env/UserPreferences.swift

@@ -73,6 +73,7 @@ import SwiftUI
     @AppStorage("sidebar_expanded") public var isSidebarExpanded: Bool = false
 
     @AppStorage("stream_home_timeline") public var streamHomeTimeline: Bool = false
+    @AppStorage("full_timeline_fetch") public var fullTimelineFetch: Bool = false
 
     // Notifications
     @AppStorage("notifications-truncate-status-content")
@@ -369,6 +370,12 @@ import SwiftUI
     }
   }
 
+  public var fullTimelineFetch: Bool {
+    didSet {
+      storage.fullTimelineFetch = fullTimelineFetch
+    }
+  }
+
   // Notifications
   public var notificationsTruncateStatusContent: Bool {
     didSet {
@@ -554,6 +561,7 @@ import SwiftUI
     isSidebarExpanded = storage.isSidebarExpanded
     notificationsTruncateStatusContent = storage.notificationsTruncateStatusContent
     streamHomeTimeline = storage.streamHomeTimeline
+    fullTimelineFetch = storage.fullTimelineFetch
   }
 }
 

Packages/Timeline/Sources/Timeline/View/TimelineViewModel.swift

@@ -66,6 +66,15 @@ import SwiftUI
   @ObservationIgnored
   private let cache = TimelineCache()
 
+  private enum Constants {
+    static let fullTimelineFetchLimit = 800
+    static let fullTimelineFetchMaxPages = fullTimelineFetchLimit / 40
+  }
+
+  private var isFullTimelineFetchEnabled: Bool {
+    UserPreferences.shared.fullTimelineFetch
+  }
+
   private var isCacheEnabled: Bool {
     canFilterTimeline && timeline.supportNewestPagination && client?.isAuth == true
   }
@@ -296,20 +305,58 @@ extension TimelineViewModel: GapLoadingFetcher {
       return
     }
 
+    var statusesToInsert = actuallyNewStatuses
+
+    if isFullTimelineFetchEnabled, statusesToInsert.count < Constants.fullTimelineFetchLimit {
+      let additionalStatuses: [Status] = try await statusFetcher.fetchNewPages(
+        client: client,
+        timeline: timeline,
+        minId: latestStatus,
+        maxPages: Constants.fullTimelineFetchMaxPages)
+
+      if !additionalStatuses.isEmpty {
+        var knownIds = Set(currentIds)
+        knownIds.formUnion(statusesToInsert.map(\.id))
+
+        let filteredAdditional = additionalStatuses.filter { status in
+          guard status.id > latestStatus else { return false }
+          if knownIds.contains(status.id) {
+            return false
+          }
+          knownIds.insert(status.id)
+          return true
+        }
+
+        if !filteredAdditional.isEmpty {
+          let remainingCapacity = max(0, Constants.fullTimelineFetchLimit - statusesToInsert.count)
+          if remainingCapacity > 0 {
+            statusesToInsert.append(contentsOf: filteredAdditional.prefix(remainingCapacity))
+          }
+        }
+      }
+    }
+
+    statusesToInsert.sort { $0.id > $1.id }
+
+    if statusesToInsert.count > Constants.fullTimelineFetchLimit {
+      statusesToInsert = Array(statusesToInsert.prefix(Constants.fullTimelineFetchLimit))
+    }
+
     StatusDataControllerProvider.shared.updateDataControllers(
-      for: actuallyNewStatuses, client: client)
+      for: statusesToInsert, client: client)
 
     // Pass the original count to determine if we need a gap
     await updateTimelineWithNewStatuses(
-      actuallyNewStatuses,
+      statusesToInsert,
       latestStatus: latestStatus,
-      fetchedCount: newestStatuses.count
+      fetchedCount: newestStatuses.count,
+      shouldCreateGap: !isFullTimelineFetchEnabled
     )
     canStreamEvents = true
   }
 
   private func updateTimelineWithNewStatuses(
-    _ newStatuses: [Status], latestStatus: String, fetchedCount: Int
+    _ newStatuses: [Status], latestStatus: String, fetchedCount: Int, shouldCreateGap: Bool
   ) async {
     let topStatus = await datasource.getFiltered().first
 
@@ -319,7 +366,11 @@ extension TimelineViewModel: GapLoadingFetcher {
     // Only create a gap if:
     // 1. We fetched a full page (suggesting there might be more)
     // 2. AND we have a significant number of actually new statuses
-    if fetchedCount >= 40 && newStatuses.count >= 40, let oldestNewStatus = newStatuses.last {
+    if shouldCreateGap,
+      fetchedCount >= 40,
+      newStatuses.count >= 40,
+      let oldestNewStatus = newStatuses.last
+    {
       // Create a gap to load statuses between the oldest new status and our previous top
       let gap = TimelineGap(sinceId: latestStatus, maxId: oldestNewStatus.id)
       // Insert the gap after all the new statuses
@@ -471,6 +522,7 @@ extension TimelineViewModel: GapLoadingFetcher {
 
   private func createGapForOlderStatuses(sinceId: String? = nil, maxId: String, at index: Int) async
   {
+    guard !isFullTimelineFetchEnabled else { return }
     let gap = TimelineGap(sinceId: sinceId, maxId: maxId)
     await datasource.insertGap(gap, at: index)
   }

Packages/Timeline/Sources/Timeline/actors/TimelineStatusFetcher.swift

@@ -41,27 +41,25 @@ struct TimelineStatusFetcher: TimelineStatusFetching {
     async throws -> [Status]
   {
     guard let client = client else { throw StatusFetcherError.noClientAvailable }
+    guard maxPages > 0 else { return [] }
+
+    var pagesLoaded = 0
     var allStatuses: [Status] = []
     var latestMinId = minId
-    let targetCount = 50
-
-    for _ in 1...maxPages {
-      if Task.isCancelled { break }
-
-      // If we already have enough statuses, stop fetching
-      if allStatuses.count >= targetCount { break }
 
+    while !Task.isCancelled, pagesLoaded < maxPages {
       let newStatuses: [Status] = try await client.get(
         endpoint: timeline.endpoint(
           sinceId: nil,
           maxId: nil,
           minId: latestMinId,
           offset: nil,
-          limit: min(40, targetCount - allStatuses.count)
+          limit: 40
         ))
 
       if newStatuses.isEmpty { break }
 
+      pagesLoaded += 1
       allStatuses.insert(contentsOf: newStatuses, at: 0)
       latestMinId = newStatuses.first?.id ?? latestMinId
     }