local thread subscriptions

This adds local nostrdb thread subscriptions. When navigating to a
thread, we first check to see if we have any active nostrdb
subscriptions for that thread. If not, we create a new subscription. If
we do, we re-use that subscription.

This works by storing thread state in the Threads struct in the Damus
application state.

When we pop a route, we check to see if its a thread route. If it is,
then we try to unsubscribe, but only if that is the last remaining
subscriber for that thread, as there could be more than one.

Signed-off-by: William Casarin <jb55@jb55.com>

src/error.rs

@@ -1,8 +1,41 @@
 use std::{fmt, io};
 
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+pub enum SubscriptionError {
+    //#[error("No active subscriptions")]
+    NoActive,
+
+    /// When a timeline has an unexpected number
+    /// of active subscriptions. Should only happen if there
+    /// is a bug in notedeck
+    //#[error("Unexpected subscription count")]
+    UnexpectedSubscriptionCount(i32),
+}
+
+impl Error {
+    pub fn unexpected_sub_count(c: i32) -> Self {
+        Error::SubscriptionError(SubscriptionError::UnexpectedSubscriptionCount(c))
+    }
+
+    pub fn no_active_sub() -> Self {
+        Error::SubscriptionError(SubscriptionError::NoActive)
+    }
+}
+
+impl fmt::Display for SubscriptionError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::NoActive => write!(f, "No active subscriptions"),
+            Self::UnexpectedSubscriptionCount(c) => {
+                write!(f, "Unexpected subscription count: {}", c)
+            }
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum Error {
-    NoActiveSubscription,
+    SubscriptionError(SubscriptionError),
     LoadFailed,
     Io(io::Error),
     Nostr(enostr::Error),
@@ -14,8 +47,8 @@ pub enum Error {
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::NoActiveSubscription => {
-                write!(f, "subscription not active in timeline")
+            Self::SubscriptionError(sub_err) => {
+                write!(f, "{sub_err}")
             }
             Self::LoadFailed => {
                 write!(f, "load failed")