wip: refactor

crates/app/src/ui/block/rooms.rs

@@ -0,0 +1,157 @@
+use components::{indicator::Indicator, Sizable};
+use gpui::*;
+use itertools::Itertools;
+use nostr_sdk::prelude::*;
+use std::{cmp::Reverse, time::Duration};
+
+use super::Block;
+use crate::{
+    get_client,
+    states::{account::AccountState, room::Room},
+};
+
+struct RoomList {
+    rooms: Vec<Room>,
+}
+
+impl RoomList {
+    pub fn new(raw_events: Vec<Event>, cx: &mut ViewContext<'_, Self>) -> Self {
+        let rooms: Vec<Room> = raw_events
+            .into_iter()
+            .map(|event| Room::new(event, cx))
+            .collect();
+
+        Self { rooms }
+    }
+}
+
+impl Render for RoomList {
+    fn render(&mut self, _cx: &mut ViewContext<Self>) -> impl IntoElement {
+        div().flex().flex_col().gap_1().children(self.rooms.clone())
+    }
+}
+
+pub struct Rooms {
+    rooms: Model<Option<View<RoomList>>>,
+    focus_handle: FocusHandle,
+}
+
+impl Rooms {
+    pub fn view(cx: &mut WindowContext) -> View<Self> {
+        cx.new_view(Self::new)
+    }
+
+    fn new(cx: &mut ViewContext<Self>) -> Self {
+        let rooms = cx.new_model(|_| None);
+        let async_rooms = rooms.clone();
+
+        if let Some(public_key) = cx.global::<AccountState>().in_use {
+            let client = get_client();
+            let filter = Filter::new()
+                .kind(Kind::PrivateDirectMessage)
+                .pubkey(public_key);
+
+            let mut async_cx = cx.to_async();
+
+            cx.foreground_executor()
+                .spawn(async move {
+                    let events = async_cx
+                        .background_executor()
+                        .spawn(async move {
+                            if let Ok(events) = client.database().query(vec![filter]).await {
+                                events
+                                    .into_iter()
+                                    .sorted_by_key(|ev| Reverse(ev.created_at))
+                                    .filter(|ev| ev.pubkey != public_key)
+                                    .unique_by(|ev| ev.pubkey)
+                                    .collect::<Vec<_>>()
+                            } else {
+                                Vec::new()
+                            }
+                        })
+                        .await;
+
+                    // Get all public keys
+                    let public_keys: Vec<PublicKey> =
+                        events.iter().map(|event| event.pubkey).collect();
+
+                    // Calculate total public keys
+                    let total = public_keys.len();
+
+                    // Create subscription for metadata events
+                    let filter = Filter::new()
+                        .kind(Kind::Metadata)
+                        .authors(public_keys)
+                        .limit(total);
+
+                    let opts = SubscribeAutoCloseOptions::default()
+                        .filter(FilterOptions::WaitDurationAfterEOSE(Duration::from_secs(2)));
+
+                    async_cx
+                        .background_executor()
+                        .spawn(async move {
+                            if let Err(e) = client.subscribe(vec![filter], Some(opts)).await {
+                                println!("Error: {}", e);
+                            }
+                        })
+                        .await;
+
+                    let view = async_cx.new_view(|cx| RoomList::new(events, cx)).unwrap();
+
+                    _ = async_cx.update_model(&async_rooms, |a, b| {
+                        *a = Some(view);
+                        b.notify();
+                    });
+                })
+                .detach();
+        }
+
+        Self {
+            rooms,
+            focus_handle: cx.focus_handle(),
+        }
+    }
+}
+
+impl Block for Rooms {
+    fn title() -> &'static str {
+        "Rooms"
+    }
+
+    fn new_view(cx: &mut WindowContext) -> View<impl FocusableView> {
+        Self::view(cx)
+    }
+
+    fn zoomable() -> bool {
+        false
+    }
+}
+
+impl FocusableView for Rooms {
+    fn focus_handle(&self, _: &gpui::AppContext) -> gpui::FocusHandle {
+        self.focus_handle.clone()
+    }
+}
+
+impl Render for Rooms {
+    fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
+        let mut content = div();
+
+        if let Some(room_list) = self.rooms.read(cx).as_ref() {
+            content = content
+                .flex()
+                .flex_col()
+                .gap_1()
+                .px_2()
+                .child(room_list.clone());
+        } else {
+            content = content
+                .w_full()
+                .flex()
+                .justify_center()
+                .child(Indicator::new().small())
+        }
+
+        div().child(content)
+    }
+}