damus

ContentView.swift (51005B)

---

 //
 //  ContentView.swift
 //  damus
 //
 //  Created by William Casarin on 2022-04-01.
 //
 
 import SwiftUI
 import AVKit
 import MediaPlayer
 import EmojiPicker
 
 struct ZapSheet {
     let target: ZapTarget
     let lnurl: String
 }
 
 struct SelectWallet {
     let invoice: String
 }
 
 enum Sheets: Identifiable {
     case post(PostAction)
     case report(ReportTarget)
     case event(NostrEvent)
     case profile_action(Pubkey)
     case zap(ZapSheet)
     case select_wallet(SelectWallet)
     case filter
     case user_status
     case onboardingSuggestions
     case purple(DamusPurpleURL)
     case purple_onboarding
     case error(ErrorView.UserPresentableError)
 
     static func zap(target: ZapTarget, lnurl: String) -> Sheets {
         return .zap(ZapSheet(target: target, lnurl: lnurl))
     }
     
     static func select_wallet(invoice: String) -> Sheets {
         return .select_wallet(SelectWallet(invoice: invoice))
     }
     
     var id: String {
         switch self {
         case .report: return "report"
         case .user_status: return "user_status"
         case .post(let action): return "post-" + (action.ev?.id.hex() ?? "")
         case .event(let ev): return "event-" + ev.id.hex()
         case .profile_action(let pubkey): return "profile-action-" + pubkey.npub
         case .zap(let sheet): return "zap-" + hex_encode(sheet.target.id)
         case .select_wallet: return "select-wallet"
         case .filter: return "filter"
         case .onboardingSuggestions: return "onboarding-suggestions"
         case .purple(let purple_url): return "purple" + purple_url.url_string()
         case .purple_onboarding: return "purple_onboarding"
         case .error(_): return "error"
         }
     }
 }
 
 /// An item to be presented full screen in a mechanism that is more robust for timeline views.
 ///
 /// ## Implementation notes
 ///
 /// This is part of the `present(full_screen_item: FullScreenItem)` interface that allows views in a timeline to show something full-screen without the lazy stack issues
 /// Full screen cover modifiers are not suitable in those cases because device orientation changes or programmatic scroll commands will cause the view to be unloaded along with the cover,
 /// causing the user to lose the full screen view randomly.
 ///
 /// The `ContentView` is responsible for handling these objects
 ///
 /// New items can be added as needed.
 ///
 enum FullScreenItem: Identifiable, Equatable {
     /// A full screen media carousel for images and videos.
     case full_screen_carousel(urls: [MediaUrl], selectedIndex: Binding<Int>)
     
     var id: String {
         switch self {
             case .full_screen_carousel(let urls, _): return "full_screen_carousel:\(urls.map(\.url))"
         }
     }
     
     static func == (lhs: FullScreenItem, rhs: FullScreenItem) -> Bool {
         return lhs.id == rhs.id
     }
     
     /// The view to display the item
     func view(damus_state: DamusState) -> some View {
         switch self {
             case .full_screen_carousel(let urls, let selectedIndex):
                 return FullScreenCarouselView<AnyView>(video_coordinator: damus_state.video, urls: urls, settings: damus_state.settings, selectedIndex: selectedIndex)
         }
     }
 }
 
 func present_sheet(_ sheet: Sheets) {
     notify(.present_sheet(sheet))
 }
 
 var tabHeight: CGFloat = 0.0
 
 struct ContentView: View {
     let keypair: Keypair
     let appDelegate: AppDelegate?
     
     var pubkey: Pubkey {
         return keypair.pubkey
     }
     
     var privkey: Privkey? {
         return keypair.privkey
     }
     
     @Environment(\.scenePhase) var scenePhase
     
     @State var active_sheet: Sheets? = nil
     @State var active_full_screen_item: FullScreenItem? = nil
     @State var damus_state: DamusState!
     @State var menu_subtitle: String? = nil
     @SceneStorage("ContentView.selected_timeline") var selected_timeline: Timeline = .home {
         willSet {
             self.menu_subtitle = nil
         }
     }
     @State var muting: MuteItem? = nil
     @State var confirm_mute: Bool = false
     @State var hide_bar: Bool = false
     @State var user_muted_confirm: Bool = false
     @State var confirm_overwrite_mutelist: Bool = false
     @State private var isSideBarOpened = false
     @State var headerOffset: CGFloat = 0.0
     var home: HomeModel = HomeModel()
     @StateObject var navigationCoordinator: NavigationCoordinator = NavigationCoordinator()
     @AppStorage("has_seen_suggested_users") private var hasSeenOnboardingSuggestions = false
     let sub_id = UUID().description
     
     // connect retry timer
     let timer = Timer.publish(every: 1, on: .main, in: .common).autoconnect()
     
     func navIsAtRoot() -> Bool {
         return navigationCoordinator.isAtRoot()
     }
     
     func popToRoot() {
         navigationCoordinator.popToRoot()
         isSideBarOpened = false
     }
     
     var timelineNavItem: some View {
         VStack {
             Text(timeline_name(selected_timeline))
                 .bold()
             if let menu_subtitle {
                 Text(menu_subtitle)
                     .font(.caption)
                     .foregroundStyle(.secondary)
             }
         }
     }
     
     func MainContent(damus: DamusState) -> some View {
         VStack {
             switch selected_timeline {
             case .search:
                 if #available(iOS 16.0, *) {
                     SearchHomeView(damus_state: damus_state!, model: SearchHomeModel(damus_state: damus_state!))
                         .scrollDismissesKeyboard(.immediately)
                 } else {
                     // Fallback on earlier versions
                     SearchHomeView(damus_state: damus_state!, model: SearchHomeModel(damus_state: damus_state!))
                 }
                 
             case .home:
                 PostingTimelineView(damus_state: damus_state!, home: home, isSideBarOpened: $isSideBarOpened, active_sheet: $active_sheet, headerOffset: $headerOffset)
                 
             case .notifications:
                 NotificationsView(state: damus, notifications: home.notifications, subtitle: $menu_subtitle)
                 
             case .dms:
                 DirectMessagesView(damus_state: damus_state!, model: damus_state!.dms, settings: damus_state!.settings)
             }
         }
         .background(DamusColors.adaptableWhite)
         .edgesIgnoringSafeArea(selected_timeline != .home ? [] : [.top, .bottom])
         .navigationBarTitle(timeline_name(selected_timeline), displayMode: .inline)
         .toolbar(selected_timeline != .home ? .visible : .hidden)
         .toolbar {
             ToolbarItem(placement: .principal) {
                 VStack {
                     timelineNavItem
                         .opacity(isSideBarOpened ? 0 : 1)
                         .animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
                 }
             }
         }
     }
     
     func MaybeReportView(target: ReportTarget) -> some View {
         Group {
             if let keypair = damus_state.keypair.to_full() {
                 ReportView(postbox: damus_state.postbox, target: target, keypair: keypair)
             } else {
                 EmptyView()
             }
         }
     }
     
     func open_event(ev: NostrEvent) {
         let thread = ThreadModel(event: ev, damus_state: damus_state!)
         navigationCoordinator.push(route: Route.Thread(thread: thread))
     }
     
     func open_wallet(nwc: WalletConnectURL) {
         self.damus_state!.wallet.new(nwc)
         navigationCoordinator.push(route: Route.Wallet(wallet: damus_state!.wallet))
     }
     
     func open_script(_ script: [UInt8]) {
         print("pushing script nav")
         let model = ScriptModel(data: script, state: .not_loaded)
         navigationCoordinator.push(route: Route.Script(script: model))
     }
     
     func open_search(filt: NostrFilter) {
         let search = SearchModel(state: damus_state!, search: filt)
         navigationCoordinator.push(route: Route.Search(search: search))
     }
     
     var body: some View {
         VStack(alignment: .leading, spacing: 0) {
             if let damus = self.damus_state {
                 NavigationStack(path: $navigationCoordinator.path) {
                     TabView { // Prevents navbar appearance change on scroll
                         MainContent(damus: damus)
                             .toolbar() {
                                 ToolbarItem(placement: .navigationBarLeading) {
                                     TopbarSideMenuButton(damus_state: damus, isSideBarOpened: $isSideBarOpened)
                                 }
                                 
                                 ToolbarItem(placement: .navigationBarTrailing) {
                                     HStack(alignment: .center) {
                                         SignalView(state: damus_state!, signal: home.signal)
                                         
                                         // maybe expand this to other timelines in the future
                                         if selected_timeline == .search {
                                             
                                             Button(action: {
                                                 present_sheet(.filter)
                                             }, label: {
                                                 Image("filter")
                                                     .foregroundColor(.gray)
                                             })
                                         }
                                     }
                                 }
                             }
                     }
                     .background(DamusColors.adaptableWhite)
                     .edgesIgnoringSafeArea(selected_timeline != .home ? [] : [.top, .bottom])
                     .tabViewStyle(.page(indexDisplayMode: .never))
                     .overlay(
                         SideMenuView(damus_state: damus_state!, isSidebarVisible: $isSideBarOpened.animation(), selected: $selected_timeline)
                     )
                     .navigationDestination(for: Route.self) { route in
                         route.view(navigationCoordinator: navigationCoordinator, damusState: damus_state!)
                     }
                     .onReceive(handle_notify(.switched_timeline)) { _ in
                         navigationCoordinator.popToRoot()
                     }
                 }
                 .navigationViewStyle(.stack)
                 .damus_full_screen_cover($active_full_screen_item, damus_state: damus, content: { item in
                     return item.view(damus_state: damus)
                 })
                 .overlay(alignment: .bottom) {
                     if !hide_bar {
                         if !isSideBarOpened {
                             TabBar(nstatus: home.notification_status, navIsAtRoot: navIsAtRoot(), selected: $selected_timeline, headerOffset: $headerOffset, settings: damus.settings, action: switch_timeline)
                                 .padding([.bottom], 8)
                                 .background(selected_timeline != .home || (selected_timeline == .home && !self.navIsAtRoot()) ? DamusColors.adaptableWhite : DamusColors.adaptableWhite.opacity(abs(1.25 - (abs(headerOffset/100.0)))))
                                 .anchorPreference(key: HeaderBoundsKey.self, value: .bounds){$0}
                                 .overlayPreferenceValue(HeaderBoundsKey.self) { value in
                                     GeometryReader{ proxy in
                                         if let anchor = value{
                                             Color.clear
                                                 .onAppear {
                                                     tabHeight = proxy[anchor].height
                                                 }
                                         }
                                     }
                                 }
                         }
                     }
                 }
             }
         }
         .ignoresSafeArea(.keyboard)
         .edgesIgnoringSafeArea(hide_bar ? [.bottom] : [])
         .onAppear() {
             self.connect()
             try? AVAudioSession.sharedInstance().setCategory(AVAudioSession.Category.playback, mode: .default, options: .mixWithOthers)
             setup_notifications()
             if !hasSeenOnboardingSuggestions || damus_state!.settings.always_show_onboarding_suggestions {
                 active_sheet = .onboardingSuggestions
                 hasSeenOnboardingSuggestions = true
             }
             self.appDelegate?.state = damus_state
             Task {  // We probably don't need this to be a detached task. According to https://docs.swift.org/swift-book/documentation/the-swift-programming-language/concurrency/#Defining-and-Calling-Asynchronous-Functions, awaits are only suspension points that do not block the thread.
                 await self.listenAndHandleLocalNotifications()
             }
         }
         .sheet(item: $active_sheet) { item in
             switch item {
             case .report(let target):
                 MaybeReportView(target: target)
             case .post(let action):
                 PostView(action: action, damus_state: damus_state!)
             case .user_status:
                 UserStatusSheet(damus_state: damus_state!, postbox: damus_state!.postbox, keypair: damus_state!.keypair, status: damus_state!.profiles.profile_data(damus_state!.pubkey).status)
                     .presentationDragIndicator(.visible)
             case .event:
                 EventDetailView()
             case .profile_action(let pubkey):
                 ProfileActionSheetView(damus_state: damus_state!, pubkey: pubkey)
             case .zap(let zapsheet):
                 CustomizeZapView(state: damus_state!, target: zapsheet.target, lnurl: zapsheet.lnurl)
             case .select_wallet(let select):
                 SelectWalletView(default_wallet: damus_state!.settings.default_wallet, active_sheet: $active_sheet, our_pubkey: damus_state!.pubkey, invoice: select.invoice)
             case .filter:
                 let timeline = selected_timeline
                 RelayFilterView(state: damus_state!, timeline: timeline)
                     .presentationDetents([.height(550)])
                     .presentationDragIndicator(.visible)
             case .onboardingSuggestions:
                 OnboardingSuggestionsView(model: SuggestedUsersViewModel(damus_state: damus_state!))
             case .purple(let purple_url):
                 DamusPurpleURLSheetView(damus_state: damus_state!, purple_url: purple_url)
             case .purple_onboarding:
                 DamusPurpleNewUserOnboardingView(damus_state: damus_state)
             case .error(let error):
                 ErrorView(damus_state: damus_state!, error: error)
             }
         }
         .onOpenURL { url in
             Task {
                 let open_action = await DamusURLHandler.handle_opening_url_and_compute_view_action(damus_state: self.damus_state, url: url)
                 self.execute_open_action(open_action)
             }
         }
         .onReceive(handle_notify(.compose)) { action in
             self.active_sheet = .post(action)
         }
         .onReceive(handle_notify(.display_tabbar)) { display in
             let show = display
             self.hide_bar = !show
         }
         .onReceive(timer) { n in
             self.damus_state?.postbox.try_flushing_events()
             self.damus_state!.profiles.profile_data(self.damus_state!.pubkey).status.try_expire()
         }
         .onReceive(handle_notify(.report)) { target in
             self.active_sheet = .report(target)
         }
         .onReceive(handle_notify(.mute)) { mute_item in
             self.muting = mute_item
             self.confirm_mute = true
         }
         .onReceive(handle_notify(.attached_wallet)) { nwc in
             try? damus_state.pool.add_relay(.nwc(url: nwc.relay))
 
             // update the lightning address on our profile when we attach a
             // wallet with an associated
             guard let ds = self.damus_state,
                   let lud16 = nwc.lud16,
                   let keypair = ds.keypair.to_full(),
                   let profile_txn = ds.profiles.lookup(id: ds.pubkey),
                   let profile = profile_txn.unsafeUnownedValue,
                   lud16 != profile.lud16 else {
                 return
             }
 
             // clear zapper cache for old lud16
             if profile.lud16 != nil {
                 // TODO: should this be somewhere else, where we process profile events!?
                 invalidate_zapper_cache(pubkey: keypair.pubkey, profiles: ds.profiles, lnurl: ds.lnurls)
             }
             
             let prof = Profile(name: profile.name, display_name: profile.display_name, about: profile.about, picture: profile.picture, banner: profile.banner, website: profile.website, lud06: profile.lud06, lud16: lud16, nip05: profile.nip05, damus_donation: profile.damus_donation, reactions: profile.reactions)
 
             guard let ev = make_metadata_event(keypair: keypair, metadata: prof) else { return }
             ds.postbox.send(ev)
         }
         .onReceive(handle_notify(.broadcast)) { ev in
             guard let ds = self.damus_state else { return }
 
             ds.postbox.send(ev)
         }
         .onReceive(handle_notify(.unfollow)) { target in
             guard let state = self.damus_state else { return }
             _ = handle_unfollow(state: state, unfollow: target.follow_ref)
         }
         .onReceive(handle_notify(.unfollowed)) { unfollow in
             home.resubscribe(.unfollowing(unfollow))
         }
         .onReceive(handle_notify(.follow)) { target in
             guard let state = self.damus_state else { return }
             handle_follow_notif(state: state, target: target)
         }
         .onReceive(handle_notify(.followed)) { _ in
             home.resubscribe(.following)
         }
         .onReceive(handle_notify(.post)) { post in
             guard let state = self.damus_state,
                   let keypair = state.keypair.to_full() else {
                       return
             }
 
             if !handle_post_notification(keypair: keypair, postbox: state.postbox, events: state.events, post: post) {
                 self.active_sheet = nil
             }
         }
         .onReceive(handle_notify(.new_mutes)) { _ in
             home.filter_events()
         }
         .onReceive(handle_notify(.mute_thread)) { _ in
             home.filter_events()
         }
         .onReceive(handle_notify(.unmute_thread)) { _ in
             home.filter_events()
         }
         .onReceive(handle_notify(.present_sheet)) { sheet in
             self.active_sheet = sheet
         }
         .onReceive(handle_notify(.present_full_screen_item)) { item in
             self.active_full_screen_item = item
         }
         .onReceive(handle_notify(.zapping)) { zap_ev in
             guard !zap_ev.is_custom else {
                 return
             }
             
             switch zap_ev.type {
             case .failed:
                 break
             case .got_zap_invoice(let inv):
                 if damus_state!.settings.show_wallet_selector {
                     present_sheet(.select_wallet(invoice: inv))
                 } else {
                     let wallet = damus_state!.settings.default_wallet.model
                     do {
                         try open_with_wallet(wallet: wallet, invoice: inv)
                     }
                     catch {
                         present_sheet(.select_wallet(invoice: inv))
                     }
                 }
             case .sent_from_nwc:
                 break
             }
         }
         .onReceive(handle_notify(.disconnect_relays)) { () in
             damus_state.pool.disconnect()
         }
         .onReceive(NotificationCenter.default.publisher(for: UIApplication.willEnterForegroundNotification)) { obj in
             print("txn: 📙 DAMUS ACTIVE NOTIFY")
             if damus_state.ndb.reopen() {
                 print("txn: NOSTRDB REOPENED")
             } else {
                 print("txn: NOSTRDB FAILED TO REOPEN closed:\(damus_state.ndb.is_closed)")
             }
             if damus_state.purple.checkout_ids_in_progress.count > 0 {
                 // For extra assurance, run this after one second, to avoid race conditions if the app is also handling a damus purple welcome url.
                 DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
                     Task {
                         let freshly_completed_checkout_ids = try? await damus_state.purple.check_status_of_checkouts_in_progress()
                         let there_is_a_completed_checkout: Bool = (freshly_completed_checkout_ids?.count ?? 0) > 0
                         let account_info = try await damus_state.purple.fetch_account(pubkey: self.keypair.pubkey)
                         if there_is_a_completed_checkout == true && account_info?.active == true {
                             if damus_state.purple.onboarding_status.user_has_never_seen_the_onboarding_before() {
                                 // Show welcome sheet
                                 self.active_sheet = .purple_onboarding
                             }
                             else {
                                 self.active_sheet = .purple(DamusPurpleURL.init(is_staging: damus_state.purple.environment == .staging, variant: .landing))
                             }
                         }
                     }
                 }
             }
             Task {
                 await damus_state.purple.check_and_send_app_notifications_if_needed(handler: home.handle_damus_app_notification)
             }
         }
         .onChange(of: scenePhase) { (phase: ScenePhase) in
             guard let damus_state else { return }
             switch phase {
             case .background:
                 print("txn: 📙 DAMUS BACKGROUNDED")
                 Task { @MainActor in
                     damus_state.ndb.close()
                 }
                 break
             case .inactive:
                 print("txn: 📙 DAMUS INACTIVE")
                 break
             case .active:
                 print("txn: 📙 DAMUS ACTIVE")
                 damus_state.pool.ping()
             @unknown default:
                 break
             }
         }
         .onReceive(handle_notify(.onlyzaps_mode)) { hide in
             home.filter_events()
 
             guard let ds = damus_state,
                   let profile_txn = ds.profiles.lookup(id: ds.pubkey),
                   let profile = profile_txn.unsafeUnownedValue,
                   let keypair = ds.keypair.to_full()
             else {
                 return
             }
 
             let prof = Profile(name: profile.name, display_name: profile.display_name, about: profile.about, picture: profile.picture, banner: profile.banner, website: profile.website, lud06: profile.lud06, lud16: profile.lud16, nip05: profile.nip05, damus_donation: profile.damus_donation, reactions: !hide)
 
             guard let profile_ev = make_metadata_event(keypair: keypair, metadata: prof) else { return }
             ds.postbox.send(profile_ev)
         }
         .alert(NSLocalizedString("User muted", comment: "Alert message to indicate the user has been muted"), isPresented: $user_muted_confirm, actions: {
             Button(NSLocalizedString("Thanks!", comment: "Button to close out of alert that informs that the action to muted a user was successful.")) {
                 user_muted_confirm = false
             }
         }, message: {
             if case let .user(pubkey, _) = self.muting {
                 let profile_txn = damus_state!.profiles.lookup(id: pubkey)
                 let profile = profile_txn?.unsafeUnownedValue
                 let name = Profile.displayName(profile: profile, pubkey: pubkey).username.truncate(maxLength: 50)
                 Text("\(name) has been muted", comment: "Alert message that informs a user was muted.")
             } else {
                 Text("User has been muted", comment: "Alert message that informs a user was muted.")
             }
         })
         .alert(NSLocalizedString("Create new mutelist", comment: "Title of alert prompting the user to create a new mutelist."), isPresented: $confirm_overwrite_mutelist, actions: {
             Button(NSLocalizedString("Cancel", comment: "Button to cancel out of alert that creates a new mutelist.")) {
                 confirm_overwrite_mutelist = false
                 confirm_mute = false
             }
 
             Button(NSLocalizedString("Yes, Overwrite", comment: "Text of button that confirms to overwrite the existing mutelist.")) {
                 guard let ds = damus_state,
                       let keypair = ds.keypair.to_full(),
                       let muting,
                       let mutelist = create_or_update_mutelist(keypair: keypair, mprev: nil, to_add: muting)
                 else {
                     return
                 }
                 
                 ds.mutelist_manager.set_mutelist(mutelist)
                 ds.postbox.send(mutelist)
 
                 confirm_overwrite_mutelist = false
                 confirm_mute = false
                 user_muted_confirm = true
             }
         }, message: {
             Text("No mute list found, create a new one? This will overwrite any previous mute lists.", comment: "Alert message prompt that asks if the user wants to create a new mute list, overwriting previous mute lists.")
         })
         .alert(NSLocalizedString("Mute/Block User", comment: "Title of alert for muting/blocking a user."), isPresented: $confirm_mute, actions: {
             Button(NSLocalizedString("Cancel", comment: "Alert button to cancel out of alert for muting a user."), role: .cancel) {
                 confirm_mute = false
             }
             Button(NSLocalizedString("Mute", comment: "Alert button to mute a user."), role: .destructive) {
                 guard let ds = damus_state else {
                     return
                 }
 
                 if ds.mutelist_manager.event == nil {
                     confirm_overwrite_mutelist = true
                 } else {
                     guard let keypair = ds.keypair.to_full(),
                           let muting
                     else {
                         return
                     }
 
                     guard let ev = create_or_update_mutelist(keypair: keypair, mprev: ds.mutelist_manager.event, to_add: muting) else {
                         return
                     }
 
                     ds.mutelist_manager.set_mutelist(ev)
                     ds.postbox.send(ev)
                 }
             }
         }, message: {
             if case let .user(pubkey, _) = muting {
                 let profile_txn = damus_state?.profiles.lookup(id: pubkey)
                 let profile = profile_txn?.unsafeUnownedValue
                 let name = Profile.displayName(profile: profile, pubkey: pubkey).username.truncate(maxLength: 50)
                 Text("Mute \(name)?", comment: "Alert message prompt to ask if a user should be muted.")
             } else {
                 Text("Could not find user to mute...", comment: "Alert message to indicate that the muted user could not be found.")
             }
         })
     }
     
     func switch_timeline(_ timeline: Timeline) {
         self.isSideBarOpened = false
         let navWasAtRoot = self.navIsAtRoot()
         self.popToRoot()
 
         notify(.switched_timeline(timeline))
 
         if timeline == self.selected_timeline && navWasAtRoot {
             notify(.scroll_to_top)
             return
         }
         
         self.selected_timeline = timeline
     }
 
     /// Listens to requests to open a push/local user notification
     ///
     /// This function never returns, it just keeps streaming
     func listenAndHandleLocalNotifications() async {
         for await notification in await QueueableNotify<LossyLocalNotification>.shared.stream {
             self.handleNotification(notification: notification)
         }
     }
 
     func handleNotification(notification: LossyLocalNotification) {
         Log.info("ContentView is handling a notification", for: .push_notifications)
         guard let damus_state else {
             // This should never happen because `listenAndHandleLocalNotifications` is called after damus state is initialized in `onAppear`
             assertionFailure("DamusState not loaded when ContentView (new handler) was handling a notification")
             Log.error("DamusState not loaded when ContentView (new handler) was handling a notification", for: .push_notifications)
             return
         }
         let local = notification
         let openAction = local.toViewOpenAction()
         self.execute_open_action(openAction)
     }
 
     func connect() {
         // nostrdb
         var mndb = Ndb()
         if mndb == nil {
             // try recovery
             print("DB ISSUE! RECOVERING")
             mndb = Ndb.safemode()
 
             // out of space or something?? maybe we need a in-memory fallback
             if mndb == nil {
                 logout(nil)
                 return
             }
         }
 
         guard let ndb = mndb else { return  }
 
         let pool = RelayPool(ndb: ndb, keypair: keypair)
         let model_cache = RelayModelCache()
         let relay_filters = RelayFilters(our_pubkey: pubkey)
         let bootstrap_relays = load_bootstrap_relays(pubkey: pubkey)
         
         let settings = UserSettingsStore.globally_load_for(pubkey: pubkey)
 
         let new_relay_filters = load_relay_filters(pubkey) == nil
         for relay in bootstrap_relays {
             let descriptor = RelayDescriptor(url: relay, info: .rw)
             add_new_relay(model_cache: model_cache, relay_filters: relay_filters, pool: pool, descriptor: descriptor, new_relay_filters: new_relay_filters, logging_enabled: settings.developer_mode)
         }
 
         pool.register_handler(sub_id: sub_id, handler: home.handle_event)
         
         if let nwc_str = settings.nostr_wallet_connect,
            let nwc = WalletConnectURL(str: nwc_str) {
             try? pool.add_relay(.nwc(url: nwc.relay))
         }
 
         self.damus_state = DamusState(pool: pool,
                                       keypair: keypair,
                                       likes: EventCounter(our_pubkey: pubkey),
                                       boosts: EventCounter(our_pubkey: pubkey),
                                       contacts: Contacts(our_pubkey: pubkey),
                                       mutelist_manager: MutelistManager(user_keypair: keypair),
                                       profiles: Profiles(ndb: ndb),
                                       dms: home.dms,
                                       previews: PreviewCache(),
                                       zaps: Zaps(our_pubkey: pubkey),
                                       lnurls: LNUrls(),
                                       settings: settings,
                                       relay_filters: relay_filters,
                                       relay_model_cache: model_cache,
                                       drafts: Drafts(),
                                       events: EventCache(ndb: ndb),
                                       bookmarks: BookmarksManager(pubkey: pubkey),
                                       postbox: PostBox(pool: pool),
                                       bootstrap_relays: bootstrap_relays,
                                       replies: ReplyCounter(our_pubkey: pubkey),
                                       wallet: WalletModel(settings: settings),
                                       nav: self.navigationCoordinator,
                                       music: MusicController(onChange: music_changed),
                                       video: DamusVideoCoordinator(),
                                       ndb: ndb,
                                       quote_reposts: .init(our_pubkey: pubkey),
                                       emoji_provider: DefaultEmojiProvider(showAllVariations: true)
         )
         
         home.damus_state = self.damus_state!
         
         if let damus_state, damus_state.purple.enable_purple {
             // Assign delegate so that we can send receipts to the Purple API server as soon as we get updates from user's purchases
             StoreObserver.standard.delegate = damus_state.purple
             Task {
                 await damus_state.purple.check_and_send_app_notifications_if_needed(handler: home.handle_damus_app_notification)
             }
         }
         else {
             // Purple API is an experimental feature. If not enabled, do not connect `StoreObserver` with Purple API to avoid leaking receipts
         }
         
         pool.connect()
     }
 
     func music_changed(_ state: MusicState) {
         guard let damus_state else { return }
         switch state {
         case .playback_state:
             break
         case .song(let song):
             guard let song, let kp = damus_state.keypair.to_full() else { return }
 
             let pdata = damus_state.profiles.profile_data(damus_state.pubkey)
 
             let desc = "\(song.title ?? "Unknown") - \(song.artist ?? "Unknown")"
             let encodedDesc = desc.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)
             let url = encodedDesc.flatMap { enc in
                 URL(string: "spotify:search:\(enc)")
             }
             let music = UserStatus(type: .music, expires_at: Date.now.addingTimeInterval(song.playbackDuration), content: desc, created_at: UInt32(Date.now.timeIntervalSince1970), url: url)
 
             pdata.status.music = music
 
             guard let ev = music.to_note(keypair: kp) else { return }
             damus_state.postbox.send(ev)
         }
     }
     
     /// An open action within the app
     /// This is used to model, store, and communicate a desired view action to be taken as a result of opening an object,
     /// for example a URL
     ///
     /// ## Implementation notes
     ///
     /// - The reason this was created was to separate URL parsing logic, the underlying actions that mutate the state of the app, and the action to be taken on the view layer as a result. This makes it easier to test, to read the URL handling code, and to add new functionality in between the two (e.g. a confirmation screen before proceeding with a given open action)
     enum ViewOpenAction {
         /// Open a page route
         case route(Route)
         /// Open a sheet
         case sheet(Sheets)
         /// Do nothing.
         ///
         /// ## Implementation notes
         /// - This is used here instead of Optional values to make semantics explicit and force better programming intent, instead of accidentally doing nothing because of Swift's syntax sugar.
         case no_action
     }
     
     /// Executes an action to open something in the app view
     ///
     /// - Parameter open_action: The action to perform
     func execute_open_action(_ open_action: ViewOpenAction) {
         switch open_action {
         case .route(let route):
             navigationCoordinator.push(route: route)
         case .sheet(let sheet):
             self.active_sheet = sheet
         case .no_action:
             return
         }
     }
 }
 
 struct TopbarSideMenuButton: View {
     let damus_state: DamusState
     @Binding var isSideBarOpened: Bool
     
     var body: some View {
         Button {
             isSideBarOpened.toggle()
         } label: {
             ProfilePicView(pubkey: damus_state.pubkey, size: 32, highlight: .none, profiles: damus_state.profiles, disable_animation: damus_state.settings.disable_animation)
                 .opacity(isSideBarOpened ? 0 : 1)
                 .animation(isSideBarOpened ? .none : .default, value: isSideBarOpened)
                 .accessibilityHidden(true)  // Knowing there is a profile picture here leads to no actionable outcome to VoiceOver users, so it is best not to show it
         }
         .accessibilityIdentifier(AppAccessibilityIdentifiers.main_side_menu_button.rawValue)
         .accessibilityLabel(NSLocalizedString("Side menu", comment: "Accessibility label for the side menu button at the topbar"))
         .disabled(isSideBarOpened)
     }
 }
 
 struct ContentView_Previews: PreviewProvider {
     static var previews: some View {
         ContentView(keypair: Keypair(pubkey: test_pubkey, privkey: nil), appDelegate: nil)
     }
 }
 
 func get_since_time(last_event: NostrEvent?) -> UInt32? {
     if let last_event = last_event {
         return last_event.created_at - 60 * 10
     }
     
     return nil
 }
 
 extension UINavigationController: UIGestureRecognizerDelegate {
     override open func viewDidLoad() {
         super.viewDidLoad()
         interactivePopGestureRecognizer?.delegate = self
     }
 
     public func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
         return viewControllers.count > 1
     }
 }
 
 struct LastNotification {
     let id: NoteId
     let created_at: Int64
 }
 
 func get_last_event(_ timeline: Timeline) -> LastNotification? {
     let str = timeline.rawValue
     let last = UserDefaults.standard.string(forKey: "last_\(str)")
     let last_created = UserDefaults.standard.string(forKey: "last_\(str)_time")
         .flatMap { Int64($0) }
 
     guard let last,
           let note_id = NoteId(hex: last),
           let last_created
     else {
         return nil
     }
 
     return LastNotification(id: note_id, created_at: last_created)
 }
 
 func save_last_event(_ ev: NostrEvent, timeline: Timeline) {
     let str = timeline.rawValue
     UserDefaults.standard.set(ev.id.hex(), forKey: "last_\(str)")
     UserDefaults.standard.set(String(ev.created_at), forKey: "last_\(str)_time")
 }
 
 func save_last_event(_ ev_id: NoteId, created_at: UInt32, timeline: Timeline) {
     let str = timeline.rawValue
     UserDefaults.standard.set(ev_id.hex(), forKey: "last_\(str)")
     UserDefaults.standard.set(String(created_at), forKey: "last_\(str)_time")
 }
 
 func update_filters_with_since(last_of_kind: [UInt32: NostrEvent], filters: [NostrFilter]) -> [NostrFilter] {
 
     return filters.map { filter in
         let kinds = filter.kinds ?? []
         let initial: UInt32? = nil
         let earliest = kinds.reduce(initial) { earliest, kind in
             let last = last_of_kind[kind.rawValue]
             let since: UInt32? = get_since_time(last_event: last)
 
             if earliest == nil {
                 if since == nil {
                     return nil
                 }
                 return since
             }
             
             if since == nil {
                 return earliest
             }
             
             return since! < earliest! ? since! : earliest!
         }
         
         if let earliest = earliest {
             var with_since = NostrFilter.copy(from: filter)
             with_since.since = earliest
             return with_since
         }
         
         return filter
     }
 }
 
 
 func setup_notifications() {
     this_app.registerForRemoteNotifications()
     let center = UNUserNotificationCenter.current()
     
     center.getNotificationSettings { settings in
         guard settings.authorizationStatus == .authorized else {
             center.requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
                 
             }
             
             return
         }
     }
 }
 
 struct FindEvent {
     let type: FindEventType
     let find_from: [RelayURL]?
 
     static func profile(pubkey: Pubkey, find_from: [RelayURL]? = nil) -> FindEvent {
         return FindEvent(type: .profile(pubkey), find_from: find_from)
     }
 
     static func event(evid: NoteId, find_from: [RelayURL]? = nil) -> FindEvent {
         return FindEvent(type: .event(evid), find_from: find_from)
     }
 }
 
 enum FindEventType {
     case profile(Pubkey)
     case event(NoteId)
 }
 
 enum FoundEvent {
     case profile(Pubkey)
     case event(NostrEvent)
 }
 
 /// Finds an event from NostrDB if it exists, or from the network
 ///
 /// This is the callback version. There is also an asyc/await version of this function.
 ///
 /// - Parameters:
 ///   - state: Damus state
 ///   - query_: The query, including the event being looked for, and the relays to use when looking
 ///   - callback: The function to call with results
 func find_event(state: DamusState, query query_: FindEvent, callback: @escaping (FoundEvent?) -> ()) {
     return find_event_with_subid(state: state, query: query_, subid: UUID().description, callback: callback)
 }
 
 /// Finds an event from NostrDB if it exists, or from the network
 ///
 /// This is a the async/await version of `find_event`. Use this when using callbacks is impossible or cumbersome.
 ///
 /// - Parameters:
 ///   - state: Damus state
 ///   - query_: The query, including the event being looked for, and the relays to use when looking
 ///   - callback: The function to call with results
 func find_event(state: DamusState, query query_: FindEvent) async -> FoundEvent? {
     await withCheckedContinuation { continuation in
         find_event(state: state, query: query_) { event in
             var already_resumed = false
             if !already_resumed {   // Ensure we do not resume twice, as it causes a crash
                 continuation.resume(returning: event)
                 already_resumed = true
             }
         }
     }
 }
 
 func find_event_with_subid(state: DamusState, query query_: FindEvent, subid: String, callback: @escaping (FoundEvent?) -> ()) {
 
     var filter: NostrFilter? = nil
     let find_from = query_.find_from
     let query = query_.type
     
     switch query {
     case .profile(let pubkey):
         if let profile_txn = state.ndb.lookup_profile(pubkey),
            let record = profile_txn.unsafeUnownedValue,
            record.profile != nil
         {
             callback(.profile(pubkey))
             return
         }
         filter = NostrFilter(kinds: [.metadata], limit: 1, authors: [pubkey])
         
     case .event(let evid):
         if let ev = state.events.lookup(evid) {
             callback(.event(ev))
             return
         }
     
         filter = NostrFilter(ids: [evid], limit: 1)
     }
     
     var attempts: Int = 0
     var has_event = false
     guard let filter else { return }
     
     state.pool.subscribe_to(sub_id: subid, filters: [filter], to: find_from) { relay_id, res  in
         guard case .nostr_event(let ev) = res else {
             return
         }
         
         guard ev.subid == subid else {
             return
         }
         
         switch ev {
         case .ok:
             break
         case .event(_, let ev):
             has_event = true
             state.pool.unsubscribe(sub_id: subid)
             
             switch query {
             case .profile:
                 if ev.known_kind == .metadata {
                     callback(.profile(ev.pubkey))
                 }
             case .event:
                 callback(.event(ev))
             }
         case .eose:
             if !has_event {
                 attempts += 1
                 if attempts >= state.pool.our_descriptors.count {
                     callback(nil)   // If we could not find any events in any of the relays we are connected to, send back nil
                 }
             }
             state.pool.unsubscribe(sub_id: subid, to: [relay_id])   // We are only finding an event once, so close subscription on eose
         case .notice:
             break
         case .auth:
             break
         }
     }
 }
 
 
 /// Finds a replaceable event based on an `naddr` address.
 ///
 /// This is the callback version of the function. There is another function that makes use of async/await
 ///
 /// - Parameters:
 ///   - damus_state: The Damus state
 ///   - naddr: the `naddr` address
 ///   - callback: A function to handle the found event
 func naddrLookup(damus_state: DamusState, naddr: NAddr, callback: @escaping (NostrEvent?) -> ()) {
     var nostrKinds: [NostrKind]? = NostrKind(rawValue: naddr.kind).map { [$0] }
 
     let filter = NostrFilter(kinds: nostrKinds, authors: [naddr.author])
     
     let subid = UUID().description
     
     damus_state.pool.subscribe_to(sub_id: subid, filters: [filter], to: nil) { relay_id, res  in
         guard case .nostr_event(let ev) = res else {
             damus_state.pool.unsubscribe(sub_id: subid, to: [relay_id])
             return
         }
         
         if case .event(_, let ev) = ev {
             for tag in ev.tags {
                 if(tag.count >= 2 && tag[0].string() == "d"){
                     if (tag[1].string() == naddr.identifier){
                         damus_state.pool.unsubscribe(sub_id: subid, to: [relay_id])
                         callback(ev)
                         return
                     }
                 }
             }
         }
         damus_state.pool.unsubscribe(sub_id: subid, to: [relay_id])
     }
 }
 
 /// Finds a replaceable event based on an `naddr` address.
 ///
 /// This is the async/await version of the function. Another version of this function which makes use of callback functions also exists .
 ///
 /// - Parameters:
 ///   - damus_state: The Damus state
 ///   - naddr: the `naddr` address
 ///   - callback: A function to handle the found event
 func naddrLookup(damus_state: DamusState, naddr: NAddr) async -> NostrEvent? {
     await withCheckedContinuation { continuation in
         var already_resumed = false
         naddrLookup(damus_state: damus_state, naddr: naddr) { event in
             if !already_resumed {   // Ensure we do not resume twice, as it causes a crash
                 continuation.resume(returning: event)
                 already_resumed = true
             }
         }
     }
 }
 
 func timeline_name(_ timeline: Timeline?) -> String {
     guard let timeline else {
         return ""
     }
     switch timeline {
     case .home:
         return NSLocalizedString("Home", comment: "Navigation bar title for Home view where notes and replies appear from those who the user is following.")
     case .notifications:
         return NSLocalizedString("Notifications", comment: "Toolbar label for Notifications view.")
     case .search:
         return NSLocalizedString("Universe 🛸", comment: "Toolbar label for the universal view where notes from all connected relay servers appear.")
     case .dms:
         return NSLocalizedString("DMs", comment: "Toolbar label for DMs view, where DM is the English abbreviation for Direct Message.")
     }
 }
 
 @discardableResult
 func handle_unfollow(state: DamusState, unfollow: FollowRef) -> Bool {
     guard let keypair = state.keypair.to_full() else {
         return false
     }
 
     let old_contacts = state.contacts.event
 
     guard let ev = unfollow_reference(postbox: state.postbox, our_contacts: old_contacts, keypair: keypair, unfollow: unfollow)
     else {
         return false
     }
 
     notify(.unfollowed(unfollow))
 
     state.contacts.event = ev
 
     switch unfollow {
     case .pubkey(let pk):
         state.contacts.remove_friend(pk)
     case .hashtag:
         // nothing to handle here really
         break
     }
 
     return true
 }
 
 @discardableResult
 func handle_follow(state: DamusState, follow: FollowRef) -> Bool {
     guard let keypair = state.keypair.to_full() else {
         return false
     }
 
     guard let ev = follow_reference(box: state.postbox, our_contacts: state.contacts.event, keypair: keypair, follow: follow)
     else {
         return false
     }
 
     notify(.followed(follow))
 
     state.contacts.event = ev
     switch follow {
     case .pubkey(let pubkey):
         state.contacts.add_friend_pubkey(pubkey)
     case .hashtag:
         // nothing to do
         break
     }
 
     return true
 }
 
 @discardableResult
 func handle_follow_notif(state: DamusState, target: FollowTarget) -> Bool {
     switch target {
     case .pubkey(let pk):
         state.contacts.add_friend_pubkey(pk)
     case .contact(let ev):
         state.contacts.add_friend_contact(ev)
     }
 
     return handle_follow(state: state, follow: target.follow_ref)
 }
 
 func handle_post_notification(keypair: FullKeypair, postbox: PostBox, events: EventCache, post: NostrPostResult) -> Bool {
     switch post {
     case .post(let post):
         //let post = tup.0
         //let to_relays = tup.1
         print("post \(post.content)")
         guard let new_ev = post.to_event(keypair: keypair) else {
             return false
         }
         postbox.send(new_ev)
         for eref in new_ev.referenced_ids.prefix(3) {
             // also broadcast at most 3 referenced events
             if let ev = events.lookup(eref) {
                 postbox.send(ev)
             }
         }
         for qref in new_ev.referenced_quote_ids.prefix(3) {
             // also broadcast at most 3 referenced quoted events
             if let ev = events.lookup(qref.note_id) {
                 postbox.send(ev)
             }
         }
         return true
     case .cancel:
         print("post cancelled")
         return false
     }
 }
 
 extension LossyLocalNotification {
     /// Computes a view open action from a mention reference.
     /// Use this when opening a user-presentable interface to a specific mention reference.
     func toViewOpenAction() -> ContentView.ViewOpenAction {
         switch self.mention {
         case .pubkey(let pubkey):
             return .route(.ProfileByKey(pubkey: pubkey))
         case .note(let noteId):
             return .route(.LoadableNostrEvent(note_reference: .note_id(noteId)))
         case .nevent(let nEvent):
             // TODO: Improve this by implementing a route that handles nevents with their relay hints.
             return .route(.LoadableNostrEvent(note_reference: .note_id(nEvent.noteid)))
         case .nprofile(let nProfile):
             // TODO: Improve this by implementing a profile route that handles nprofiles with their relay hints.
             return .route(.ProfileByKey(pubkey: nProfile.author))
         case .nrelay(let string):
             // We do not need to implement `nrelay` support, it has been deprecated.
             // See https://github.com/nostr-protocol/nips/blob/6e7a618e7f873bb91e743caacc3b09edab7796a0/BREAKING.md?plain=1#L21
             return .sheet(.error(ErrorView.UserPresentableError(
                 user_visible_description: NSLocalizedString("You opened an invalid link. The link you tried to open refers to \"nrelay\", which has been deprecated and is not supported.", comment: "User-visible error description for a user who tries to open a deprecated \"nrelay\" link."),
                 tip: NSLocalizedString("Please contact the person who provided the link, and ask for another link.", comment: "User-visible tip on what to do if a link contains a deprecated \"nrelay\" reference."),
                 technical_info: "`MentionRef.toViewOpenAction` detected deprecated `nrelay` contents"
             )))
         case .naddr(let nAddr):
             return .route(.LoadableNostrEvent(note_reference: .naddr(nAddr)))
         }
     }
 }
 
 
 func logout(_ state: DamusState?)
 {
     state?.close()
     notify(.logout)
 }