// use crate::{chat_panel::ChatPanel, render_avatar, NotificationPanelSettings};
// use anyhow::Result;
// use channel::ChannelStore;
// use client::{Client, Notification, User, UserStore};
// use collections::HashMap;
// use db::kvp::KEY_VALUE_STORE;
// use futures::StreamExt;
// use gpui::{
//     actions,
//     elements::*,
//     platform::{CursorStyle, MouseButton},
//     serde_json, AnyViewHandle, AppContext, AsyncAppContext, Entity, ModelHandle, Task, View,
//     ViewContext, ViewHandle, WeakViewHandle, WindowContext,
// };
// use notifications::{NotificationEntry, NotificationEvent, NotificationStore};
// use project::Fs;
// use rpc::proto;
// use serde::{Deserialize, Serialize};
// use settings::SettingsStore;
// use std::{sync::Arc, time::Duration};
// use theme::{ui, Theme};
// use time::{OffsetDateTime, UtcOffset};
// use util::{ResultExt, TryFutureExt};
// use workspace::{
//     dock::{DockPosition, Panel},
//     Workspace,
// };

// const LOADING_THRESHOLD: usize = 30;
// const MARK_AS_READ_DELAY: Duration = Duration::from_secs(1);
// const TOAST_DURATION: Duration = Duration::from_secs(5);
// const NOTIFICATION_PANEL_KEY: &'static str = "NotificationPanel";

// pub struct NotificationPanel {
//     client: Arc<Client>,
//     user_store: ModelHandle<UserStore>,
//     channel_store: ModelHandle<ChannelStore>,
//     notification_store: ModelHandle<NotificationStore>,
//     fs: Arc<dyn Fs>,
//     width: Option<f32>,
//     active: bool,
//     notification_list: ListState<Self>,
//     pending_serialization: Task<Option<()>>,
//     subscriptions: Vec<gpui::Subscription>,
//     workspace: WeakViewHandle<Workspace>,
//     current_notification_toast: Option<(u64, Task<()>)>,
//     local_timezone: UtcOffset,
//     has_focus: bool,
//     mark_as_read_tasks: HashMap<u64, Task<Result<()>>>,
// }

// #[derive(Serialize, Deserialize)]
// struct SerializedNotificationPanel {
//     width: Option<f32>,
// }

// #[derive(Debug)]
// pub enum Event {
//     DockPositionChanged,
//     Focus,
//     Dismissed,
// }

// pub struct NotificationPresenter {
//     pub actor: Option<Arc<client::User>>,
//     pub text: String,
//     pub icon: &'static str,
//     pub needs_response: bool,
//     pub can_navigate: bool,
// }

// actions!(notification_panel, [ToggleFocus]);

// pub fn init(_cx: &mut AppContext) {}

// impl NotificationPanel {
//     pub fn new(workspace: &mut Workspace, cx: &mut ViewContext<Workspace>) -> ViewHandle<Self> {
//         let fs = workspace.app_state().fs.clone();
//         let client = workspace.app_state().client.clone();
//         let user_store = workspace.app_state().user_store.clone();
//         let workspace_handle = workspace.weak_handle();

//         cx.add_view(|cx| {
//             let mut status = client.status();
//             cx.spawn(|this, mut cx| async move {
//                 while let Some(_) = status.next().await {
//                     if this
//                         .update(&mut cx, |_, cx| {
//                             cx.notify();
//                         })
//                         .is_err()
//                     {
//                         break;
//                     }
//                 }
//             })
//             .detach();

//             let mut notification_list =
//                 ListState::<Self>::new(0, Orientation::Top, 1000., move |this, ix, cx| {
//                     this.render_notification(ix, cx)
//                         .unwrap_or_else(|| Empty::new().into_any())
//                 });
//             notification_list.set_scroll_handler(|visible_range, count, this, cx| {
//                 if count.saturating_sub(visible_range.end) < LOADING_THRESHOLD {
//                     if let Some(task) = this
//                         .notification_store
//                         .update(cx, |store, cx| store.load_more_notifications(false, cx))
//                     {
//                         task.detach();
//                     }
//                 }
//             });

//             let mut this = Self {
//                 fs,
//                 client,
//                 user_store,
//                 local_timezone: cx.platform().local_timezone(),
//                 channel_store: ChannelStore::global(cx),
//                 notification_store: NotificationStore::global(cx),
//                 notification_list,
//                 pending_serialization: Task::ready(None),
//                 workspace: workspace_handle,
//                 has_focus: false,
//                 current_notification_toast: None,
//                 subscriptions: Vec::new(),
//                 active: false,
//                 mark_as_read_tasks: HashMap::default(),
//                 width: None,
//             };

//             let mut old_dock_position = this.position(cx);
//             this.subscriptions.extend([
//                 cx.observe(&this.notification_store, |_, _, cx| cx.notify()),
//                 cx.subscribe(&this.notification_store, Self::on_notification_event),
//                 cx.observe_global::<SettingsStore, _>(move |this: &mut Self, cx| {
//                     let new_dock_position = this.position(cx);
//                     if new_dock_position != old_dock_position {
//                         old_dock_position = new_dock_position;
//                         cx.emit(Event::DockPositionChanged);
//                     }
//                     cx.notify();
//                 }),
//             ]);
//             this
//         })
//     }

//     pub fn load(
//         workspace: WeakViewHandle<Workspace>,
//         cx: AsyncAppContext,
//     ) -> Task<Result<ViewHandle<Self>>> {
//         cx.spawn(|mut cx| async move {
//             let serialized_panel = if let Some(panel) = cx
//                 .background()
//                 .spawn(async move { KEY_VALUE_STORE.read_kvp(NOTIFICATION_PANEL_KEY) })
//                 .await
//                 .log_err()
//                 .flatten()
//             {
//                 Some(serde_json::from_str::<SerializedNotificationPanel>(&panel)?)
//             } else {
//                 None
//             };

//             workspace.update(&mut cx, |workspace, cx| {
//                 let panel = Self::new(workspace, cx);
//                 if let Some(serialized_panel) = serialized_panel {
//                     panel.update(cx, |panel, cx| {
//                         panel.width = serialized_panel.width;
//                         cx.notify();
//                     });
//                 }
//                 panel
//             })
//         })
//     }

//     fn serialize(&mut self, cx: &mut ViewContext<Self>) {
//         let width = self.width;
//         self.pending_serialization = cx.background().spawn(
//             async move {
//                 KEY_VALUE_STORE
//                     .write_kvp(
//                         NOTIFICATION_PANEL_KEY.into(),
//                         serde_json::to_string(&SerializedNotificationPanel { width })?,
//                     )
//                     .await?;
//                 anyhow::Ok(())
//             }
//             .log_err(),
//         );
//     }

//     fn render_notification(
//         &mut self,
//         ix: usize,
//         cx: &mut ViewContext<Self>,
//     ) -> Option<AnyElement<Self>> {
//         let entry = self.notification_store.read(cx).notification_at(ix)?;
//         let notification_id = entry.id;
//         let now = OffsetDateTime::now_utc();
//         let timestamp = entry.timestamp;
//         let NotificationPresenter {
//             actor,
//             text,
//             needs_response,
//             can_navigate,
//             ..
//         } = self.present_notification(entry, cx)?;

//         let theme = theme::current(cx);
//         let style = &theme.notification_panel;
//         let response = entry.response;
//         let notification = entry.notification.clone();

//         let message_style = if entry.is_read {
//             style.read_text.clone()
//         } else {
//             style.unread_text.clone()
//         };

//         if self.active && !entry.is_read {
//             self.did_render_notification(notification_id, &notification, cx);
//         }

//         enum Decline {}
//         enum Accept {}

//         Some(
//             MouseEventHandler::new::<NotificationEntry, _>(ix, cx, |_, cx| {
//                 let container = message_style.container;

//                 Flex::row()
//                     .with_children(actor.map(|actor| {
//                         render_avatar(actor.avatar.clone(), &style.avatar, style.avatar_container)
//                     }))
//                     .with_child(
//                         Flex::column()
//                             .with_child(Text::new(text, message_style.text.clone()))
//                             .with_child(
//                                 Flex::row()
//                                     .with_child(
//                                         Label::new(
//                                             format_timestamp(timestamp, now, self.local_timezone),
//                                             style.timestamp.text.clone(),
//                                         )
//                                         .contained()
//                                         .with_style(style.timestamp.container),
//                                     )
//                                     .with_children(if let Some(is_accepted) = response {
//                                         Some(
//                                             Label::new(
//                                                 if is_accepted {
//                                                     "You accepted"
//                                                 } else {
//                                                     "You declined"
//                                                 },
//                                                 style.read_text.text.clone(),
//                                             )
//                                             .flex_float()
//                                             .into_any(),
//                                         )
//                                     } else if needs_response {
//                                         Some(
//                                             Flex::row()
//                                                 .with_children([
//                                                     MouseEventHandler::new::<Decline, _>(
//                                                         ix,
//                                                         cx,
//                                                         |state, _| {
//                                                             let button =
//                                                                 style.button.style_for(state);
//                                                             Label::new(
//                                                                 "Decline",
//                                                                 button.text.clone(),
//                                                             )
//                                                             .contained()
//                                                             .with_style(button.container)
//                                                         },
//                                                     )
//                                                     .with_cursor_style(CursorStyle::PointingHand)
//                                                     .on_click(MouseButton::Left, {
//                                                         let notification = notification.clone();
//                                                         move |_, view, cx| {
//                                                             view.respond_to_notification(
//                                                                 notification.clone(),
//                                                                 false,
//                                                                 cx,
//                                                             );
//                                                         }
//                                                     }),
//                                                     MouseEventHandler::new::<Accept, _>(
//                                                         ix,
//                                                         cx,
//                                                         |state, _| {
//                                                             let button =
//                                                                 style.button.style_for(state);
//                                                             Label::new(
//                                                                 "Accept",
//                                                                 button.text.clone(),
//                                                             )
//                                                             .contained()
//                                                             .with_style(button.container)
//                                                         },
//                                                     )
//                                                     .with_cursor_style(CursorStyle::PointingHand)
//                                                     .on_click(MouseButton::Left, {
//                                                         let notification = notification.clone();
//                                                         move |_, view, cx| {
//                                                             view.respond_to_notification(
//                                                                 notification.clone(),
//                                                                 true,
//                                                                 cx,
//                                                             );
//                                                         }
//                                                     }),
//                                                 ])
//                                                 .flex_float()
//                                                 .into_any(),
//                                         )
//                                     } else {
//                                         None
//                                     }),
//                             )
//                             .flex(1.0, true),
//                     )
//                     .contained()
//                     .with_style(container)
//                     .into_any()
//             })
//             .with_cursor_style(if can_navigate {
//                 CursorStyle::PointingHand
//             } else {
//                 CursorStyle::default()
//             })
//             .on_click(MouseButton::Left, {
//                 let notification = notification.clone();
//                 move |_, this, cx| this.did_click_notification(&notification, cx)
//             })
//             .into_any(),
//         )
//     }

//     fn present_notification(
//         &self,
//         entry: &NotificationEntry,
//         cx: &AppContext,
//     ) -> Option<NotificationPresenter> {
//         let user_store = self.user_store.read(cx);
//         let channel_store = self.channel_store.read(cx);
//         match entry.notification {
//             Notification::ContactRequest { sender_id } => {
//                 let requester = user_store.get_cached_user(sender_id)?;
//                 Some(NotificationPresenter {
//                     icon: "icons/plus.svg",
//                     text: format!("{} wants to add you as a contact", requester.github_login),
//                     needs_response: user_store.has_incoming_contact_request(requester.id),
//                     actor: Some(requester),
//                     can_navigate: false,
//                 })
//             }
//             Notification::ContactRequestAccepted { responder_id } => {
//                 let responder = user_store.get_cached_user(responder_id)?;
//                 Some(NotificationPresenter {
//                     icon: "icons/plus.svg",
//                     text: format!("{} accepted your contact invite", responder.github_login),
//                     needs_response: false,
//                     actor: Some(responder),
//                     can_navigate: false,
//                 })
//             }
//             Notification::ChannelInvitation {
//                 ref channel_name,
//                 channel_id,
//                 inviter_id,
//             } => {
//                 let inviter = user_store.get_cached_user(inviter_id)?;
//                 Some(NotificationPresenter {
//                     icon: "icons/hash.svg",
//                     text: format!(
//                         "{} invited you to join the #{channel_name} channel",
//                         inviter.github_login
//                     ),
//                     needs_response: channel_store.has_channel_invitation(channel_id),
//                     actor: Some(inviter),
//                     can_navigate: false,
//                 })
//             }
//             Notification::ChannelMessageMention {
//                 sender_id,
//                 channel_id,
//                 message_id,
//             } => {
//                 let sender = user_store.get_cached_user(sender_id)?;
//                 let channel = channel_store.channel_for_id(channel_id)?;
//                 let message = self
//                     .notification_store
//                     .read(cx)
//                     .channel_message_for_id(message_id)?;
//                 Some(NotificationPresenter {
//                     icon: "icons/conversations.svg",
//                     text: format!(
//                         "{} mentioned you in #{}:\n{}",
//                         sender.github_login, channel.name, message.body,
//                     ),
//                     needs_response: false,
//                     actor: Some(sender),
//                     can_navigate: true,
//                 })
//             }
//         }
//     }

//     fn did_render_notification(
//         &mut self,
//         notification_id: u64,
//         notification: &Notification,
//         cx: &mut ViewContext<Self>,
//     ) {
//         let should_mark_as_read = match notification {
//             Notification::ContactRequestAccepted { .. } => true,
//             Notification::ContactRequest { .. }
//             | Notification::ChannelInvitation { .. }
//             | Notification::ChannelMessageMention { .. } => false,
//         };

//         if should_mark_as_read {
//             self.mark_as_read_tasks
//                 .entry(notification_id)
//                 .or_insert_with(|| {
//                     let client = self.client.clone();
//                     cx.spawn(|this, mut cx| async move {
//                         cx.background().timer(MARK_AS_READ_DELAY).await;
//                         client
//                             .request(proto::MarkNotificationRead { notification_id })
//                             .await?;
//                         this.update(&mut cx, |this, _| {
//                             this.mark_as_read_tasks.remove(&notification_id);
//                         })?;
//                         Ok(())
//                     })
//                 });
//         }
//     }

//     fn did_click_notification(&mut self, notification: &Notification, cx: &mut ViewContext<Self>) {
//         if let Notification::ChannelMessageMention {
//             message_id,
//             channel_id,
//             ..
//         } = notification.clone()
//         {
//             if let Some(workspace) = self.workspace.upgrade(cx) {
//                 cx.app_context().defer(move |cx| {
//                     workspace.update(cx, |workspace, cx| {
//                         if let Some(panel) = workspace.focus_panel::<ChatPanel>(cx) {
//                             panel.update(cx, |panel, cx| {
//                                 panel
//                                     .select_channel(channel_id, Some(message_id), cx)
//                                     .detach_and_log_err(cx);
//                             });
//                         }
//                     });
//                 });
//             }
//         }
//     }

//     fn is_showing_notification(&self, notification: &Notification, cx: &AppContext) -> bool {
//         if let Notification::ChannelMessageMention { channel_id, .. } = &notification {
//             if let Some(workspace) = self.workspace.upgrade(cx) {
//                 return workspace
//                     .read_with(cx, |workspace, cx| {
//                         if let Some(panel) = workspace.panel::<ChatPanel>(cx) {
//                             return panel.read_with(cx, |panel, cx| {
//                                 panel.is_scrolled_to_bottom()
//                                     && panel.active_chat().map_or(false, |chat| {
//                                         chat.read(cx).channel_id == *channel_id
//                                     })
//                             });
//                         }
//                         false
//                     })
//                     .unwrap_or_default();
//             }
//         }

//         false
//     }

//     fn render_sign_in_prompt(
//         &self,
//         theme: &Arc<Theme>,
//         cx: &mut ViewContext<Self>,
//     ) -> AnyElement<Self> {
//         enum SignInPromptLabel {}

//         MouseEventHandler::new::<SignInPromptLabel, _>(0, cx, |mouse_state, _| {
//             Label::new(
//                 "Sign in to view your notifications".to_string(),
//                 theme
//                     .chat_panel
//                     .sign_in_prompt
//                     .style_for(mouse_state)
//                     .clone(),
//             )
//         })
//         .with_cursor_style(CursorStyle::PointingHand)
//         .on_click(MouseButton::Left, move |_, this, cx| {
//             let client = this.client.clone();
//             cx.spawn(|_, cx| async move {
//                 client.authenticate_and_connect(true, &cx).log_err().await;
//             })
//             .detach();
//         })
//         .aligned()
//         .into_any()
//     }

//     fn render_empty_state(
//         &self,
//         theme: &Arc<Theme>,
//         _cx: &mut ViewContext<Self>,
//     ) -> AnyElement<Self> {
//         Label::new(
//             "You have no notifications".to_string(),
//             theme.chat_panel.sign_in_prompt.default.clone(),
//         )
//         .aligned()
//         .into_any()
//     }

//     fn on_notification_event(
//         &mut self,
//         _: ModelHandle<NotificationStore>,
//         event: &NotificationEvent,
//         cx: &mut ViewContext<Self>,
//     ) {
//         match event {
//             NotificationEvent::NewNotification { entry } => self.add_toast(entry, cx),
//             NotificationEvent::NotificationRemoved { entry }
//             | NotificationEvent::NotificationRead { entry } => self.remove_toast(entry.id, cx),
//             NotificationEvent::NotificationsUpdated {
//                 old_range,
//                 new_count,
//             } => {
//                 self.notification_list.splice(old_range.clone(), *new_count);
//                 cx.notify();
//             }
//         }
//     }

//     fn add_toast(&mut self, entry: &NotificationEntry, cx: &mut ViewContext<Self>) {
//         if self.is_showing_notification(&entry.notification, cx) {
//             return;
//         }

//         let Some(NotificationPresenter { actor, text, .. }) = self.present_notification(entry, cx)
//         else {
//             return;
//         };

//         let notification_id = entry.id;
//         self.current_notification_toast = Some((
//             notification_id,
//             cx.spawn(|this, mut cx| async move {
//                 cx.background().timer(TOAST_DURATION).await;
//                 this.update(&mut cx, |this, cx| this.remove_toast(notification_id, cx))
//                     .ok();
//             }),
//         ));

//         self.workspace
//             .update(cx, |workspace, cx| {
//                 workspace.dismiss_notification::<NotificationToast>(0, cx);
//                 workspace.show_notification(0, cx, |cx| {
//                     let workspace = cx.weak_handle();
//                     cx.add_view(|_| NotificationToast {
//                         notification_id,
//                         actor,
//                         text,
//                         workspace,
//                     })
//                 })
//             })
//             .ok();
//     }

//     fn remove_toast(&mut self, notification_id: u64, cx: &mut ViewContext<Self>) {
//         if let Some((current_id, _)) = &self.current_notification_toast {
//             if *current_id == notification_id {
//                 self.current_notification_toast.take();
//                 self.workspace
//                     .update(cx, |workspace, cx| {
//                         workspace.dismiss_notification::<NotificationToast>(0, cx)
//                     })
//                     .ok();
//             }
//         }
//     }

//     fn respond_to_notification(
//         &mut self,
//         notification: Notification,
//         response: bool,
//         cx: &mut ViewContext<Self>,
//     ) {
//         self.notification_store.update(cx, |store, cx| {
//             store.respond_to_notification(notification, response, cx);
//         });
//     }
// }

// impl Entity for NotificationPanel {
//     type Event = Event;
// }

// impl View for NotificationPanel {
//     fn ui_name() -> &'static str {
//         "NotificationPanel"
//     }

//     fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
//         let theme = theme::current(cx);
//         let style = &theme.notification_panel;
//         let element = if self.client.user_id().is_none() {
//             self.render_sign_in_prompt(&theme, cx)
//         } else if self.notification_list.item_count() == 0 {
//             self.render_empty_state(&theme, cx)
//         } else {
//             Flex::column()
//                 .with_child(
//                     Flex::row()
//                         .with_child(Label::new("Notifications", style.title.text.clone()))
//                         .with_child(ui::svg(&style.title_icon).flex_float())
//                         .align_children_center()
//                         .contained()
//                         .with_style(style.title.container)
//                         .constrained()
//                         .with_height(style.title_height),
//                 )
//                 .with_child(
//                     List::new(self.notification_list.clone())
//                         .contained()
//                         .with_style(style.list)
//                         .flex(1., true),
//                 )
//                 .into_any()
//         };
//         element
//             .contained()
//             .with_style(style.container)
//             .constrained()
//             .with_min_width(150.)
//             .into_any()
//     }

//     fn focus_in(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {
//         self.has_focus = true;
//     }

//     fn focus_out(&mut self, _: AnyViewHandle, _: &mut ViewContext<Self>) {
//         self.has_focus = false;
//     }
// }

// impl Panel for NotificationPanel {
//     fn position(&self, cx: &gpui::WindowContext) -> DockPosition {
//         settings::get::<NotificationPanelSettings>(cx).dock
//     }

//     fn position_is_valid(&self, position: DockPosition) -> bool {
//         matches!(position, DockPosition::Left | DockPosition::Right)
//     }

//     fn set_position(&mut self, position: DockPosition, cx: &mut ViewContext<Self>) {
//         settings::update_settings_file::<NotificationPanelSettings>(
//             self.fs.clone(),
//             cx,
//             move |settings| settings.dock = Some(position),
//         );
//     }

//     fn size(&self, cx: &gpui::WindowContext) -> f32 {
//         self.width
//             .unwrap_or_else(|| settings::get::<NotificationPanelSettings>(cx).default_width)
//     }

//     fn set_size(&mut self, size: Option<f32>, cx: &mut ViewContext<Self>) {
//         self.width = size;
//         self.serialize(cx);
//         cx.notify();
//     }

//     fn set_active(&mut self, active: bool, cx: &mut ViewContext<Self>) {
//         self.active = active;
//         if self.notification_store.read(cx).notification_count() == 0 {
//             cx.emit(Event::Dismissed);
//         }
//     }

//     fn icon_path(&self, cx: &gpui::WindowContext) -> Option<&'static str> {
//         (settings::get::<NotificationPanelSettings>(cx).button
//             && self.notification_store.read(cx).notification_count() > 0)
//             .then(|| "icons/bell.svg")
//     }

//     fn icon_tooltip(&self) -> (String, Option<Box<dyn gpui::Action>>) {
//         (
//             "Notification Panel".to_string(),
//             Some(Box::new(ToggleFocus)),
//         )
//     }

//     fn icon_label(&self, cx: &WindowContext) -> Option<String> {
//         let count = self.notification_store.read(cx).unread_notification_count();
//         if count == 0 {
//             None
//         } else {
//             Some(count.to_string())
//         }
//     }

//     fn should_change_position_on_event(event: &Self::Event) -> bool {
//         matches!(event, Event::DockPositionChanged)
//     }

//     fn should_close_on_event(event: &Self::Event) -> bool {
//         matches!(event, Event::Dismissed)
//     }

//     fn has_focus(&self, _cx: &gpui::WindowContext) -> bool {
//         self.has_focus
//     }

//     fn is_focus_event(event: &Self::Event) -> bool {
//         matches!(event, Event::Focus)
//     }
// }

// pub struct NotificationToast {
//     notification_id: u64,
//     actor: Option<Arc<User>>,
//     text: String,
//     workspace: WeakViewHandle<Workspace>,
// }

// pub enum ToastEvent {
//     Dismiss,
// }

// impl NotificationToast {
//     fn focus_notification_panel(&self, cx: &mut AppContext) {
//         let workspace = self.workspace.clone();
//         let notification_id = self.notification_id;
//         cx.defer(move |cx| {
//             workspace
//                 .update(cx, |workspace, cx| {
//                     if let Some(panel) = workspace.focus_panel::<NotificationPanel>(cx) {
//                         panel.update(cx, |panel, cx| {
//                             let store = panel.notification_store.read(cx);
//                             if let Some(entry) = store.notification_for_id(notification_id) {
//                                 panel.did_click_notification(&entry.clone().notification, cx);
//                             }
//                         });
//                     }
//                 })
//                 .ok();
//         })
//     }
// }

// impl Entity for NotificationToast {
//     type Event = ToastEvent;
// }

// impl View for NotificationToast {
//     fn ui_name() -> &'static str {
//         "ContactNotification"
//     }

//     fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
//         let user = self.actor.clone();
//         let theme = theme::current(cx).clone();
//         let theme = &theme.contact_notification;

//         MouseEventHandler::new::<Self, _>(0, cx, |_, cx| {
//             Flex::row()
//                 .with_children(user.and_then(|user| {
//                     Some(
//                         Image::from_data(user.avatar.clone()?)
//                             .with_style(theme.header_avatar)
//                             .aligned()
//                             .constrained()
//                             .with_height(
//                                 cx.font_cache()
//                                     .line_height(theme.header_message.text.font_size),
//                             )
//                             .aligned()
//                             .top(),
//                     )
//                 }))
//                 .with_child(
//                     Text::new(self.text.clone(), theme.header_message.text.clone())
//                         .contained()
//                         .with_style(theme.header_message.container)
//                         .aligned()
//                         .top()
//                         .left()
//                         .flex(1., true),
//                 )
//                 .with_child(
//                     MouseEventHandler::new::<ToastEvent, _>(0, cx, |state, _| {
//                         let style = theme.dismiss_button.style_for(state);
//                         Svg::new("icons/x.svg")
//                             .with_color(style.color)
//                             .constrained()
//                             .with_width(style.icon_width)
//                             .aligned()
//                             .contained()
//                             .with_style(style.container)
//                             .constrained()
//                             .with_width(style.button_width)
//                             .with_height(style.button_width)
//                     })
//                     .with_cursor_style(CursorStyle::PointingHand)
//                     .with_padding(Padding::uniform(5.))
//                     .on_click(MouseButton::Left, move |_, _, cx| {
//                         cx.emit(ToastEvent::Dismiss)
//                     })
//                     .aligned()
//                     .constrained()
//                     .with_height(
//                         cx.font_cache()
//                             .line_height(theme.header_message.text.font_size),
//                     )
//                     .aligned()
//                     .top()
//                     .flex_float(),
//                 )
//                 .contained()
//         })
//         .with_cursor_style(CursorStyle::PointingHand)
//         .on_click(MouseButton::Left, move |_, this, cx| {
//             this.focus_notification_panel(cx);
//             cx.emit(ToastEvent::Dismiss);
//         })
//         .into_any()
//     }
// }

// impl workspace::notifications::Notification for NotificationToast {
//     fn should_dismiss_notification_on_event(&self, event: &<Self as Entity>::Event) -> bool {
//         matches!(event, ToastEvent::Dismiss)
//     }
// }

// fn format_timestamp(
//     mut timestamp: OffsetDateTime,
//     mut now: OffsetDateTime,
//     local_timezone: UtcOffset,
// ) -> String {
//     timestamp = timestamp.to_offset(local_timezone);
//     now = now.to_offset(local_timezone);

//     let today = now.date();
//     let date = timestamp.date();
//     if date == today {
//         let difference = now - timestamp;
//         if difference >= Duration::from_secs(3600) {
//             format!("{}h", difference.whole_seconds() / 3600)
//         } else if difference >= Duration::from_secs(60) {
//             format!("{}m", difference.whole_seconds() / 60)
//         } else {
//             "just now".to_string()
//         }
//     } else if date.next_day() == Some(today) {
//         format!("yesterday")
//     } else {
//         format!("{:02}/{}/{}", date.month() as u32, date.day(), date.year())
//     }
// }