wip: refactor

crates/chat/src/registry.rs

@@ -0,0 +1,142 @@
+use anyhow::Error;
+use common::utils::{compare, room_hash};
+use gpui::{App, AppContext, Entity, Global, WeakEntity};
+use nostr_sdk::prelude::*;
+use state::get_client;
+
+use crate::{inbox::Inbox, room::Room};
+
+pub struct ChatRegistry {
+    inbox: Entity<Inbox>,
+}
+
+impl Global for ChatRegistry {}
+
+impl ChatRegistry {
+    pub fn set_global(cx: &mut App) {
+        let inbox = cx.new(|_| Inbox::default());
+
+        cx.observe_new::<Room>(|this, _window, cx| {
+            // Get all pubkeys to load metadata
+            let pubkeys = this.get_pubkeys();
+
+            cx.spawn(|weak_model, mut async_cx| async move {
+                let query: Result<Vec<(PublicKey, Metadata)>, Error> = async_cx
+                    .background_executor()
+                    .spawn(async move {
+                        let client = get_client();
+                        let mut profiles = Vec::new();
+
+                        for public_key in pubkeys.into_iter() {
+                            let query = client.database().metadata(public_key).await?;
+                            let metadata = query.unwrap_or_default();
+
+                            profiles.push((public_key, metadata));
+                        }
+
+                        Ok(profiles)
+                    })
+                    .await;
+
+                if let Ok(profiles) = query {
+                    if let Some(model) = weak_model.upgrade() {
+                        _ = async_cx.update_entity(&model, |model, cx| {
+                            for profile in profiles.into_iter() {
+                                model.set_metadata(profile.0, profile.1);
+                            }
+                            cx.notify();
+                        });
+                    }
+                }
+            })
+            .detach();
+        })
+        .detach();
+
+        cx.set_global(Self { inbox });
+    }
+
+    pub fn load(&mut self, cx: &mut App) {
+        self.inbox.update(cx, |this, cx| {
+            let task = this.load(cx.to_async());
+
+            cx.spawn(|this, mut async_cx| async move {
+                if let Some(inbox) = this.upgrade() {
+                    if let Ok(events) = task.await {
+                        _ = async_cx.update_entity(&inbox, |this, cx| {
+                            let current_rooms = this.get_room_ids(cx);
+                            let items: Vec<Entity<Room>> = events
+                                .into_iter()
+                                .filter_map(|ev| {
+                                    let id = room_hash(&ev.tags);
+                                    // Filter all seen events
+                                    if !current_rooms.iter().any(|h| h == &id) {
+                                        Some(cx.new(|_| Room::parse(&ev)))
+                                    } else {
+                                        None
+                                    }
+                                })
+                                .collect();
+
+                            this.rooms.extend(items);
+                            this.is_loading = false;
+
+                            cx.notify();
+                        });
+                    }
+                }
+            })
+            .detach();
+        });
+    }
+
+    pub fn inbox(&self) -> WeakEntity<Inbox> {
+        self.inbox.downgrade()
+    }
+
+    pub fn get_room(&self, id: &u64, cx: &App) -> Option<WeakEntity<Room>> {
+        self.inbox
+            .read(cx)
+            .rooms
+            .iter()
+            .find(|model| &model.read(cx).id == id)
+            .map(|model| model.downgrade())
+    }
+
+    pub fn new_room(&mut self, room: Room, cx: &mut App) {
+        let room = cx.new(|_| room);
+
+        self.inbox.update(cx, |this, cx| {
+            if !this.rooms.iter().any(|r| r.read(cx) == room.read(cx)) {
+                this.rooms.insert(0, room);
+                cx.notify();
+            }
+        })
+    }
+
+    pub fn new_room_message(&mut self, event: Event, cx: &mut App) {
+        let mut pubkeys: Vec<_> = event.tags.public_keys().copied().collect();
+        pubkeys.push(event.pubkey);
+
+        self.inbox.update(cx, |this, cx| {
+            if let Some(room) = this.rooms.iter().find(|room| {
+                let all_keys = room.read(cx).get_pubkeys();
+                compare(&all_keys, &pubkeys)
+            }) {
+                room.update(cx, |this, cx| {
+                    this.new_messages.push(event);
+                    cx.notify();
+                })
+            } else {
+                let room = cx.new(|_| Room::parse(&event));
+
+                self.inbox.update(cx, |this, cx| {
+                    this.rooms.insert(0, room);
+                    cx.notify();
+                })
+            }
+
+            cx.notify();
+        })
+    }
+}