1use std::cell::{Cell, RefCell};
9use std::collections::HashMap;
10
11use day_spec::{AppProgress, StatusItemSpec};
12
13#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
16pub enum KeepRunning {
17 #[default]
20 Automatic,
21 Always,
25 Never,
27}
28
29day_reactive::tls_slots! {
30 status;
31 static POLICY: Cell<KeepRunning> = const { Cell::new(KeepRunning::Automatic) };
32 static ITEMS: RefCell<Vec<(StatusItemSpec, Vec<u64>)>> = const { RefCell::new(Vec::new()) };
35 static TOLD_KEEP: Cell<Option<bool>> = const { Cell::new(None) };
37 static TRACKING: RefCell<HashMap<String, Tracking>> = RefCell::new(HashMap::new());
38 static NEXT_TRACKING: Cell<u64> = const { Cell::new(1) };
39}
40
41struct Tracking {
42 token: u64,
43 pending: Option<StatusItemSpec>,
44}
45
46#[must_use]
50pub fn begin_menu_tracking(id: &str) -> u64 {
51 let token = NEXT_TRACKING.with(|next| {
52 let token = next.get();
53 next.set(token.wrapping_add(1).max(1));
54 token
55 });
56 TRACKING.with(|tracking| {
57 let mut tracking = tracking.borrow_mut();
58 let pending = tracking.remove(id).and_then(|old| old.pending);
59 tracking.insert(id.to_owned(), Tracking { token, pending });
60 });
61 token
62}
63
64pub fn end_menu_tracking(id: &str, token: u64) {
68 let pending = TRACKING.with(|tracking| {
69 let mut tracking = tracking.borrow_mut();
70 if tracking.get(id).is_some_and(|t| t.token == token) {
71 tracking.remove(id).and_then(|t| t.pending)
72 } else {
73 None
74 }
75 });
76 if let Some(spec) = pending {
77 set_status_item(spec);
78 }
79}
80
81pub fn set_keep_running(policy: KeepRunning) {
83 POLICY.with(|p| p.set(policy));
84 sync_keep_running();
85}
86
87#[must_use]
89pub fn keep_running_policy() -> KeepRunning {
90 POLICY.with(std::cell::Cell::get)
91}
92
93pub(crate) fn keeps_running() -> bool {
95 match keep_running_policy() {
96 KeepRunning::Always => true,
97 KeepRunning::Never => false,
98 KeepRunning::Automatic => ITEMS.with(|i| !i.borrow().is_empty()),
99 }
100}
101
102fn sync_keep_running() {
104 let keep = keeps_running();
105 if TOLD_KEEP.with(|t| t.replace(Some(keep))) != Some(keep) && crate::tree::has_tree() {
106 crate::with_tree(|t| t.set_keep_running(keep));
107 }
108}
109
110pub(crate) fn boot_sync() {
113 TOLD_KEEP.with(|t| t.set(None));
114 if keeps_running() {
115 sync_keep_running();
116 }
117}
118
119fn action_ids(spec: &StatusItemSpec) -> Vec<u64> {
120 let mut ids = crate::menu::collect_ids(&spec.menu);
121 if spec.activate != 0 {
122 ids.push(spec.activate);
123 }
124 ids
125}
126
127#[expect(
131 clippy::missing_panics_doc,
132 reason = "each `unwrap` reads the `Option` this function filled and has not yet taken"
133)]
134pub fn set_status_item(spec: StatusItemSpec) {
135 let mut spec = Some(spec);
136 let superseded = TRACKING.with(|tracking| {
137 let mut tracking = tracking.borrow_mut();
138 let active = tracking.get_mut(&spec.as_ref().unwrap().id)?;
139 active.pending.replace(spec.take().unwrap())
140 });
141 if spec.is_none() {
142 if let Some(old) = superseded {
143 let mut keep = ITEMS.with(|items| {
146 items
147 .borrow()
148 .iter()
149 .find(|(s, _)| s.id == old.id)
150 .map_or_default(|(_, ids)| ids.clone())
151 });
152 TRACKING.with(|tracking| {
153 if let Some(next) = tracking
154 .borrow()
155 .get(&old.id)
156 .and_then(|t| t.pending.as_ref())
157 {
158 keep.extend(action_ids(next));
159 }
160 });
161 let stale: Vec<_> = action_ids(&old)
162 .into_iter()
163 .filter(|id| !keep.contains(id))
164 .collect();
165 crate::menu::forget_actions(&stale);
166 }
167 return;
168 }
169 let spec = spec.unwrap();
170 let ids = action_ids(&spec);
171 let stale = ITEMS.with(|items| {
172 let mut items = items.borrow_mut();
173 if let Some((s, old)) = items.iter_mut().find(|(s, _)| s.id == spec.id) {
174 let stale: Vec<u64> = old.iter().copied().filter(|i| !ids.contains(i)).collect();
175 *s = spec;
176 *old = ids;
177 stale
178 } else {
179 items.push((spec, ids));
180 Vec::new()
181 }
182 });
183 crate::menu::forget_actions(&stale);
184 send_items();
185}
186
187pub fn remove_status_item(id: &str) {
189 let pending =
190 TRACKING.with(|tracking| tracking.borrow_mut().remove(id).and_then(|t| t.pending));
191 if let Some(pending) = pending {
192 crate::menu::forget_actions(&action_ids(&pending));
193 }
194 let stale = ITEMS.with(|items| {
195 let mut items = items.borrow_mut();
196 let i = items.iter().position(|(s, _)| s.id == id)?;
197 Some(items.remove(i).1)
198 });
199 if let Some(stale) = stale {
200 crate::menu::forget_actions(&stale);
201 send_items();
202 }
203}
204
205#[must_use]
207pub fn status_items() -> Vec<StatusItemSpec> {
208 ITEMS.with(|i| i.borrow().iter().map(|(s, _)| s.clone()).collect())
209}
210
211fn send_items() {
212 let items = status_items();
213 crate::with_tree(|t| t.set_status_items(&items));
214 sync_keep_running();
215}
216
217pub fn set_app_progress(progress: AppProgress) {
219 crate::with_tree(|t| t.set_app_progress(progress));
220}
221
222pub fn set_dock_visible(visible: bool) {
226 crate::with_tree(|t| t.set_dock_visible(visible));
227}
228
229pub fn reset_status() {
231 TRACKING.with(|tracking| tracking.borrow_mut().clear());
232 ITEMS.with(|i| i.borrow_mut().clear());
233 POLICY.with(|p| p.set(KeepRunning::Automatic));
234 TOLD_KEEP.with(|t| t.set(None));
235}