Add debug logging for thread position

swiftchan/Environment/UserSettings.swift

@@ -54,6 +54,52 @@ extension UserDefaults {
         return UserDefaults.standard.bool(forKey: "hiddenPosts board=\(boardName) postId=\(postId)")
     }
 
+    static func getThreadPosition(boardName: String, threadId: Int) -> Int? {
+        let key = "threadPosition board=\(boardName) thread=\(threadId)"
+        if UserDefaults.standard.object(forKey: key) == nil {
+            print("No saved thread position for \(key)")
+            return nil
+        }
+        let value = UserDefaults.standard.integer(forKey: key)
+        print("Retrieved thread position \(value) for \(key)")
+        return value
+    }
+
+    static func getThreadOffset(boardName: String, threadId: Int) -> Double? {
+        let key = "threadOffset board=\(boardName) thread=\(threadId)"
+        if UserDefaults.standard.object(forKey: key) == nil {
+            print("No saved thread offset for \(key)")
+            return nil
+        }
+        let value = UserDefaults.standard.double(forKey: key)
+        print("Retrieved thread offset \(value) for \(key)")
+        return value
+    }
+
+    static func setThreadPosition(boardName: String, threadId: Int, index: Int) {
+        let key = "threadPosition board=\(boardName) thread=\(threadId)"
+        print("Saving thread position \(index) for \(key)")
+        UserDefaults.standard.set(index, forKey: key)
+    }
+
+    static func setThreadOffset(boardName: String, threadId: Int, offset: Double) {
+        let key = "threadOffset board=\(boardName) thread=\(threadId)"
+        print("Saving thread offset \(offset) for \(key)")
+        UserDefaults.standard.set(offset, forKey: key)
+    }
+
+    static func removeThreadPosition(boardName: String, threadId: Int) {
+        let key = "threadPosition board=\(boardName) thread=\(threadId)"
+        print("Removing thread position for \(key)")
+        UserDefaults.standard.removeObject(forKey: key)
+    }
+
+    static func removeThreadOffset(boardName: String, threadId: Int) {
+        let key = "threadOffset board=\(boardName) thread=\(threadId)"
+        print("Removing thread offset for \(key)")
+        UserDefaults.standard.removeObject(forKey: key)
+    }
+
     // MARK: Setters
     static func setDidUnlokcBiometrics(value: Bool) {
         UserDefaults.standard.set(value, forKey: "didUnlokcBiometrics")

swiftchan/Views/Boards/Catalog/Thread/ThreadView.swift

@@ -9,6 +9,7 @@ import SwiftUI
 import FourChan
 import Combine
 import SpriteKit
+import UIKit
 
 func createThreadUpdateTimer() -> Publishers.Autoconnect<Timer.TimerPublisher> {
     return Timer.publish(every: 1, on: .current, in: .common).autoconnect()
@@ -18,6 +19,7 @@ struct ThreadView: View {
     @AppStorage("autoRefreshEnabled") private var autoRefreshEnabled = true
     @AppStorage("autoRefreshThreadTime") private var autoRefreshThreadTime = 10
     @AppStorage("hideTabOnBoards") var hideTabOnBoards = false
+    @AppStorage("rememberThreadPositions") var rememberThreadPositions = true
     @Environment(\.scenePhase) private var scenePhase
     @Environment(AppState.self) private var appState
 
@@ -29,6 +31,11 @@ struct ThreadView: View {
     @State private var replyId: Int = 0
     @State private var showThread: Bool = false
     @State private var threadDestination = ThreadDestination(board: "", id: 0)
+    @State private var savedIndex: Int?
+    @State private var lastVisibleIndex: Int?
+    @State private var savedOffset: CGFloat?
+    @State private var scrollViewRef: UIScrollView?
+    @State private var didRestoreOffset = false
 
     var scene: SKScene {
         let scene = SnowScene()
@@ -47,6 +54,15 @@ struct ThreadView: View {
                 id: postNumber
             )
         )
+        let savedIndex = UserDefaults.getThreadPosition(boardName: boardName, threadId: Int(postNumber))
+        self._savedIndex = State(wrappedValue: savedIndex)
+
+        if let offset = UserDefaults.getThreadOffset(boardName: boardName, threadId: Int(postNumber)) {
+            self._savedOffset = State(wrappedValue: CGFloat(offset))
+        } else {
+            self._savedOffset = State(initialValue: nil)
+        }
+        print("ThreadView init: board=\(boardName), threadId=\(postNumber), savedIndex=\(String(describing: savedIndex)), savedOffset=\(String(describing: _savedOffset.wrappedValue))")
     }
 
     @ViewBuilder
@@ -75,6 +91,10 @@ struct ThreadView: View {
                                 if !post.isHidden(boardName: viewModel.boardName) {
                                     PostView(index: postIndex)
                                         .environment(viewModel)
+                                        .onAppear {
+                                            lastVisibleIndex = postIndex
+                                            print("Last visible index updated to \(postIndex)")
+                                        }
                                 }
                             }
                         }
@@ -87,6 +107,26 @@ struct ThreadView: View {
                         }
                         .opacity(opacity)
                     }
+                    .introspect(
+                        .scrollView,
+                        on: .iOS(.v15, .v16, .v17)
+                    ) { scrollView in
+                        scrollViewRef = scrollView
+                        print("Got scroll view reference")
+                        restoreSavedPosition(reader: reader)
+                    }
+                    .onDisappear {
+                        print("ScrollView onDisappear - saving position")
+                        savePosition()
+                    }
+                    .onAppear {
+                        print("ScrollView onAppear")
+                        restoreSavedPosition(reader: reader)
+                    }
+                    .onChange(of: viewModel.posts.count) { _, _ in
+                        print("Posts count changed, attempting to restore")
+                        restoreSavedPosition(reader: reader)
+                    }
                 }
             }
             .overlay {
@@ -112,9 +152,11 @@ struct ThreadView: View {
                     .environment(presentationState)
                     .environment(viewModel)
                     .onAppear {
+                        print("Gallery onAppear - canceling autorefresh")
                         threadAutorefresher.cancelTimer()
                     }
                     .onDisappear {
+                        print("Gallery onDisappear - starting autorefresh")
                         threadAutorefresher.setTimer()
                     }
                 }
@@ -132,10 +174,17 @@ struct ThreadView: View {
                 }
             }
             .onAppear {
+                print("ThreadView onAppear - prefetching")
                 viewModel.prefetch()
             }
             .onDisappear {
                 viewModel.stopPrefetching()
+                savePosition()
+            }
+            .onChange(of: scenePhase) { _, newPhase in
+                if newPhase != .active {
+                    savePosition()
+                }
             }
             .onReceive(threadAutorefresher.timer) { _ in
                 if threadAutorefresher.incrementRefreshTimer() {
@@ -237,6 +286,63 @@ struct ThreadView: View {
         viewModel.prefetch()
     }
 
+    private func restoreSavedPosition(reader: ScrollViewProxy) {
+        guard rememberThreadPositions, let scrollView = scrollViewRef else { return }
+        guard !didRestoreOffset else { return }
+
+        print("Attempting restore: savedOffset=\(String(describing: savedOffset)), savedIndex=\(String(describing: savedIndex))")
+
+        if let offset = savedOffset {
+            print("Restoring using offset \(offset)")
+            applyOffset(offset, to: scrollView)
+            didRestoreOffset = true
+        } else if let index = savedIndex, index < viewModel.posts.count {
+            print("Restoring using index \(index)")
+            DispatchQueue.main.async {
+                reader.scrollTo(index, anchor: .top)
+                didRestoreOffset = true
+            }
+        }
+    }
+
+    private func savePosition() {
+        if rememberThreadPositions {
+            if let index = lastVisibleIndex {
+                print("Saving index \(index)")
+                UserDefaults.setThreadPosition(
+                    boardName: viewModel.boardName,
+                    threadId: viewModel.id,
+                    index: index
+                )
+            }
+            if let scrollView = scrollViewRef {
+                let offset = scrollView.contentOffset.y
+                print("Saving offset \(offset)")
+                UserDefaults.setThreadOffset(
+                    boardName: viewModel.boardName,
+                    threadId: viewModel.id,
+                    offset: Double(offset)
+                )
+            } else {
+                print("No scrollView reference to save offset")
+            }
+        } else {
+            print("Removing saved position and offset")
+            UserDefaults.removeThreadPosition(boardName: viewModel.boardName, threadId: viewModel.id)
+            UserDefaults.removeThreadOffset(boardName: viewModel.boardName, threadId: viewModel.id)
+        }
+    }
+
+    private func applyOffset(_ offset: CGFloat, to scrollView: UIScrollView) {
+        let delays: [Double] = [0.0, 0.1, 0.4, 0.8, 1.2]
+        for delay in delays {
+            DispatchQueue.main.asyncAfter(deadline: .now() + delay) {
+                print("Applying offset \(offset) after delay \(delay)")
+                scrollView.setContentOffset(CGPoint(x: 0, y: offset), animated: false)
+            }
+        }
+    }
+
     private func scrollToPost(reader: ScrollViewProxy) {
         if presentationState.presentingIndex != presentationState.galleryIndex,
            let mediaI = viewModel.postMediaMapping.firstIndex(where: { $0.value == presentationState.galleryIndex }) {

swiftchan/Views/SettingsView.swift

@@ -67,6 +67,7 @@ struct SettingsView: View {
     var threadSection: some View {
         Section(header: Text("Thread").font(.title)) {
             Toggle("Auto Refresh Enabled", isOn: $autoRefreshEnabled)
+            Toggle("Remember Thread Position", isOn: $rememberThreadPositions)
             HStack {
                 Text("Auto Refresh Time")
                 Spacer()