import HapiClient import SwiftUI import UIKit /// Post-pairing home: the session list for the active hub, with the "+" /// new-session sheet (A-M3c), the Settings sheet (A-M4e, which also switches, /// adds and signs out of hubs), and a unified session-filter menu. /// Degraded connections appear below navigation, not among its actions. /// iPhone pushes the chat; iPad and foldable iPhones select a stable detail in /// a native split that collapses to a stack when the window is compact. /// Spawn, notification and row selection share the same opening path. struct HomeView: View { let session: HubSession @Environment(AppModel.self) private var model @Environment(\.horizontalSizeClass) private var horizontalSizeClass @State private var listModel: SessionListModel @State private var showNewSession = false @State private var showSettings = false @State private var path: [String] = [] @State private var tabletNavigation = SessionNavigationState() /// Transient connection states show only after `connectionRevealDelay`: /// a foreground reconnect usually finishes first (Telegram-style). @State private var connectionStatusRevealed = false private let connectionRevealDelay: Duration = .seconds(2) private var usesSplitNavigation: Bool { let idiom = UIDevice.current.userInterfaceIdiom return idiom == .pad || idiom == .mac || FoldableDevice.shared.hasHinge } /// The sidebar is visible next to the chat (not collapsed into a stack). private var showsSideBySide: Bool { usesSplitNavigation && horizontalSizeClass == .regular } /// iPhone Duo outer screen: the system moves toolbar actions into its /// vertical bar, leaving the top bar to the title alone. private var isFoldedOuterScreen: Bool { FoldableDevice.shared.hasHinge && horizontalSizeClass == .compact } init(session: HubSession) { self.session = session _listModel = State(initialValue: SessionListModel(session: session)) } var body: some View { @Bindable var model = model Group { if usesSplitNavigation { SessionSplitView(navigation: tabletNavigation, onNewSession: { showNewSession = true }) { sessionList } detail: { sessionId in chat(sessionId) } } else { NavigationStack(path: $path) { sessionList .navigationDestination(for: String.self) { sessionId in chat(sessionId) } } } } .background(HingeProbe()) // The hinge is reported after the first render; carry a chat that was // already pushed (e.g. a cold-start notification) into the split. .onChange(of: usesSplitNavigation) { _, split in guard split else { return } if let sessionId = path.last { openSession(sessionId) } path = [] } // Notification tap (P3): consume the pending target into this hub's // navigation path. `initial: true` covers a tap that cold-started // the app before this view existed. .onChange(of: model.pendingOpenSessionId, initial: true) { _, sessionId in guard let sessionId else { return } model.pendingOpenSessionId = nil openSession(sessionId) } .onChange(of: session.sessionRemoval) { _, removal in guard let removal else { return } if usesSplitNavigation { tabletNavigation.remove(removal.sessionId) } else if let index = path.firstIndex(of: removal.sessionId) { // Deleted or archived elsewhere: leave the emptied chat. path.removeSubrange(index...) } } .sheet(isPresented: $model.showAddHub) { PairingFlowView(context: .addHub) .macSheetSizing() } .sheet(isPresented: $showNewSession) { NewSessionView(session: session) { sessionId in // Navigate-replace: drop the sheet, push the fresh chat. showNewSession = false openSession(sessionId) } .macSheetSizing() } .sheet(isPresented: $showSettings) { SettingsView(session: session) .macSheetSizing() } .focusedSceneValue(\.homeCommands, HomeCommandActions( newSession: { showNewSession = true }, openSettings: { showSettings = true }, toggleSidebar: usesSplitNavigation ? toggleSidebar : nil, selectAdjacentSession: usesSplitNavigation ? selectAdjacentSession : nil )) } private func toggleSidebar() { tabletNavigation.columnVisibility = tabletNavigation.columnVisibility == .detailOnly ? .all : .detailOnly } /// Steps through the list as shown (filters and search applied). private func selectAdjacentSession(_ offset: Int) { let ids = listModel.rows.map(\.id) guard !ids.isEmpty else { return } let target: Int if let current = tabletNavigation.selectedSessionId, let index = ids.firstIndex(of: current) { target = index + offset } else { target = offset > 0 ? 0 : ids.count - 1 } guard ids.indices.contains(target) else { return } openSession(ids[target]) } private var sessionList: some View { VStack(spacing: 0) { if let failedHub = model.authFailureNotice { authFailureBanner(failedHub: failedHub) } connectionNotice SessionListView(model: listModel, selection: usesSplitNavigation ? Binding( get: { tabletNavigation.selectedSessionId }, // Native list deselection (e.g. a filter hides the row) is // not an authoritative removal and must not close the chat. set: { if let id = $0 { openSession(id) } } ) : nil, onOpenSession: openSession) } .task(id: session.connectionState == .connected) { connectionStatusRevealed = false guard session.connectionState != .connected else { return } try? await Task.sleep(for: connectionRevealDelay) if !Task.isCancelled { connectionStatusRevealed = true } } .modifier(ConnectionSubtitle(message: subtitleCarriesConnectionStatus ? connectionNotice.transientMessage(revealed: connectionStatusRevealed) : nil)) .searchable(text: $listModel.searchQuery, prompt: Text("Search sessions")) .onChange(of: tabletNavigation.selectedSessionId, initial: true) { _, sessionId in listModel.selectedSessionId = sessionId } .navigationTitle("Sessions") // Inline: it shares the toolbar row, so the list starts right below // and Pinned/Recent headers carry the structure. .navigationBarTitleDisplayMode(.inline) .modifier(SidebarTitleRemoval(isSidebar: showsSideBySide || isFoldedOuterScreen)) .toolbar { ToolbarItem(placement: .topBarLeading) { settingsButton } if listModel.showsFilterMenu { // Beside Settings when the system sidebar toggle shares the // trailing edge, so the icons do not bunch up. ToolbarItem(placement: showsSideBySide ? .topBarLeading : .topBarTrailing) { SessionFilterMenu(model: listModel) } } if !showsNewSessionBesideSearch { ToolbarItem(placement: .topBarTrailing) { newSessionButton } } } .modifier(NewSessionBesideSearch(isEnabled: showsNewSessionBesideSearch) { newSessionButton }) } private var connectionNotice: SessionConnectionNotice { SessionConnectionNotice( state: session.connectionState, showsCachedSessions: listModel.isOffline && listModel.hasLoaded, lastRefreshedAt: listModel.lastRefreshedAt, showsTransientStatus: connectionStatusRevealed && !subtitleCarriesConnectionStatus, onRetry: { Task { await listModel.refresh() } } ) } /// iOS 26 puts transient status under the inline title (Mail-style), so /// the list never shifts. A sidebar or folded Duo has no title to carry it. private var subtitleCarriesConnectionStatus: Bool { guard #available(iOS 26.0, *) else { return false } return !(showsSideBySide || isFoldedOuterScreen) } /// iOS 26 bottom search bar, as in Messages: New Session sits beside the /// field. A side-by-side sidebar keeps search at its top, and older /// systems keep search under the title. private var showsNewSessionBesideSearch: Bool { guard #available(iOS 26.0, *) else { return false } return !showsSideBySide } private var newSessionButton: some View { Button { showNewSession = true } label: { Label("New Session", systemImage: "plus") .modifier(TouchTarget()) } .accessibilityIdentifier("home.new-session") } private var settingsButton: some View { Button { showSettings = true } label: { Label("Settings", systemImage: "gearshape") .modifier(TouchTarget()) } .accessibilityIdentifier("home.settings") } private func openSession(_ sessionId: String) { if usesSplitNavigation { tabletNavigation.open(sessionId) } else if path.last != sessionId { path.append(sessionId) } } private func chat(_ sessionId: String) -> some View { ChatView(session: session, sessionId: sessionId) { superseding in if usesSplitNavigation { tabletNavigation.supersede(sessionId, with: superseding) } else if let last = path.indices.last, path[last] == sessionId { path[last] = superseding } // A late response from a chat already left must not steal focus. } .id(sessionId) } private func authFailureBanner(failedHub: String) -> some View { HStack(alignment: .top, spacing: 12) { Image(systemName: "exclamationmark.triangle.fill") .foregroundStyle(.orange) Text("\(HubDisplay.host(failedHub)) rejected its stored credentials and was signed out. Pair it again from Settings.") .font(.footnote) Spacer(minLength: 0) Button { model.authFailureNotice = nil } label: { Image(systemName: "xmark") .font(.footnote.bold()) .foregroundStyle(.secondary) } } .padding(12) .background(.orange.opacity(0.12), in: RoundedRectangle(cornerRadius: 12)) .padding(.horizontal, 16) .padding(.top, 8) } } /// A side-by-side sidebar's bar already holds settings, filter, new session and /// the system sidebar toggle; at 320pt the inline "Sessions" title only got a /// truncated sliver. The title stays set for VoiceOver and collapsed stacks. private struct SidebarTitleRemoval: ViewModifier { let isSidebar: Bool func body(content: Content) -> some View { if #available(iOS 18.0, *) { content.toolbar(removing: isSidebar ? .title : nil) } else { content } } } /// Places the system search field in the bottom bar with New Session on its /// trailing side. The OS branch is static and the toggle lives inside the /// toolbar, so resizing never replaces the session list's identity. private struct NewSessionBesideSearch: ViewModifier { let isEnabled: Bool @ViewBuilder var newSessionButton: () -> NewSessionButton func body(content: Content) -> some View { if #available(iOS 26.0, *) { content.toolbar { if isEnabled { DefaultToolbarItem(kind: .search, placement: .bottomBar) ToolbarSpacer(.fixed, placement: .bottomBar) ToolbarItem(placement: .bottomBar) { newSessionButton() } } } } else { content } } } /// Home connection status. Transient SSE states are quiet: the iOS 26 nav /// subtitle, else a gray line with a spinner. Only a failed list refresh /// (cached data on screen) is amber, with when it last updated and Retry. struct SessionConnectionNotice: View { @Environment(\.hapiTheme) private var theme @Environment(\.locale) private var locale let state: SSEConnectionState let showsCachedSessions: Bool var lastRefreshedAt: Date? = nil var showsTransientStatus = true var onRetry: (() -> Void)? = nil var message: String? { if showsCachedSessions { return String(localized: "Offline — showing cached sessions") } switch state { case .connected: return nil case .connecting: return String(localized: "Connecting…") case .backoff: return String(localized: "Reconnecting…") case .suspended: return String(localized: "Paused") case .idle: return String(localized: "Offline") } } func transientMessage(revealed: Bool) -> String? { revealed && !showsCachedSessions ? message : nil } var body: some View { if showsCachedSessions { offlineBanner } else if showsTransientStatus, let message { HStack(spacing: 6) { ProgressView() .controlSize(.mini) Text(message) } .font(.footnote) .foregroundStyle(theme.textSecondary) .frame(maxWidth: .infinity) .padding(.vertical, 4) .accessibilityElement(children: .combine) .accessibilityIdentifier("home.connection-notice") } } private var offlineBanner: some View { HStack(spacing: 8) { Image(systemName: "icloud.slash") .foregroundStyle(attentionColor) offlineText .lineLimit(2) Spacer(minLength: 8) if let onRetry { Button("Retry", action: onRetry) .font(.footnote.weight(.semibold)) .buttonStyle(.borderless) } } .font(.footnote) .foregroundStyle(theme.textPrimary) .padding(.horizontal, 12) .padding(.vertical, 8) .background(attentionColor.opacity(0.12), in: RoundedRectangle(cornerRadius: 12)) .padding(.horizontal, 16) .padding(.vertical, 4) .accessibilityElement(children: .combine) .accessibilityIdentifier("home.connection-notice") } @ViewBuilder private var offlineText: some View { if let lastRefreshedAt { // Minute ticks keep "updated … ago" honest while offline. TimelineView(.periodic(from: .now, by: 60)) { context in Text("Offline · updated \(relativeAge(of: lastRefreshedAt, now: context.date))") } } else { Text("Offline — showing cached sessions") } } private func relativeAge(of date: Date, now: Date) -> String { let formatter = RelativeDateTimeFormatter() formatter.locale = locale formatter.dateTimeStyle = .named return formatter.localizedString(for: date, relativeTo: now) } private var attentionColor: Color { theme.isDark ? theme.warning : Color(hex: 0x9A6700) } } /// iOS 26 navigation subtitle. Always applied (empty when connected) so the /// session list keeps one identity as the connection state changes. private struct ConnectionSubtitle: ViewModifier { let message: String? func body(content: Content) -> some View { if #available(iOS 26.0, *) { content.navigationSubtitle(Text(verbatim: message ?? "")) } else { content } } } /// 44pt touch slots; Mac toolbar buttons use the system's pointer sizing. private struct TouchTarget: ViewModifier { func body(content: Content) -> some View { #if targetEnvironment(macCatalyst) content #else content.frame(minWidth: 44, minHeight: 44) #endif } }