fix: cancellable/pause-aware rest notifications, no double-fire, resumed session UI, stale ATH notification

Agent-Logs-Url: https://github.com/gfauredev/LogOut/sessions/feeac486-69ef-4414-beff-795baf8bb24b

Co-authored-by: gfauredev <19304085+gfauredev@users.noreply.github.com>

Author: Copilot

src/components/active_session/mod.rs

@@ -14,7 +14,10 @@ use dioxus_i18n::t;
 use futures_channel::mpsc::UnboundedReceiver;
 #[cfg(target_arch = "wasm32")]
 use gloo_timers::future::TimeoutFuture;
-use std::sync::Arc;
+use std::sync::{
+    atomic::{AtomicBool, AtomicU64, Ordering},
+    Arc,
+};
 
 mod completed_exercises;
 mod header;
@@ -488,15 +491,33 @@ pub fn GlobalSessionHeader() -> Element {
             .map(|start| (start, rd))
     });
 
-    // Track how many rest-exceeded intervals have fired for the current rest
-    // period.  Reset to 0 each time a new rest period begins.
-    let mut rest_bell_count = use_signal(|| 0u64);
+    // How many rest-exceeded intervals have fired for the current rest period.
+    // Stored as an Arc<AtomicU64> so it can be read/written from both the
+    // Dioxus thread and spawned async tasks without Signal's !Send constraint.
+    let rest_bell_count = use_hook(|| Arc::new(AtomicU64::new(0)));
+    // Clone used by the tick coroutine (the scheduling effect takes the original).
+    let bc_tick = rest_bell_count.clone();
+
+    // Cancel token for the current one-shot scheduled notification.
+    // Set to `true` to invalidate a pending spawn before it fires.
+    let mut rest_cancel = use_signal(|| Arc::new(AtomicBool::new(false)));
+
+    // Memo tracking whether the session is currently paused.
+    let session_paused_at = use_memo(move || session().and_then(|s| s.paused_at));
 
     // Pre-localise the notification strings in the reactive context so they
     // can be moved into async closures without requiring i18n context access.
     let rest_notif_title = use_memo(move || t!("notif-rest-title").to_string());
     let rest_notif_body = use_memo(move || t!("notif-rest-body").to_string());
 
+    // When the session is paused, cancel any pending one-shot notification so
+    // it doesn't fire at a wall-clock time that ignores the pause duration.
+    use_effect(move || {
+        if session_paused_at().is_some() {
+            rest_cancel.peek().store(true, Ordering::Relaxed);
+        }
+    });
+
     // Schedule a precise one-shot rest-over notification whenever a new rest
     // period begins.  Fires ~250 ms early to compensate for jitter.
     use_effect(move || {
@@ -507,7 +528,12 @@ pub fn GlobalSessionHeader() -> Element {
             return;
         }
         // Reset the exceeded-interval counter for the new rest period.
-        rest_bell_count.set(0);
+        rest_bell_count.store(0, Ordering::Relaxed);
+
+        // Invalidate any previously scheduled notification and issue a new token.
+        rest_cancel.peek().store(true, Ordering::Relaxed);
+        let cancel = Arc::new(AtomicBool::new(false));
+        rest_cancel.set(cancel.clone());
 
         let title = rest_notif_title.peek().clone();
         let body = rest_notif_body.peek().clone();
@@ -519,11 +545,23 @@ pub fn GlobalSessionHeader() -> Element {
             if fire_at_secs > now {
                 let delay_ms = ((fire_at_secs - now) * 1_000)
                     .saturating_sub(crate::components::session_timers::NOTIF_EARLY_MS);
+                let bc = rest_bell_count.clone();
                 tokio::spawn(async move {
                     tokio::time::sleep(std::time::Duration::from_millis(delay_ms)).await;
-                    crate::services::notifications::send_notification(&title, &body, "logout-rest");
+                    if !cancel.load(Ordering::Relaxed) {
+                        // Mark first interval done so the tick coroutine doesn't
+                        // fire a duplicate for interval 1.
+                        bc.store(1, Ordering::Relaxed);
+                        crate::services::notifications::send_notification(
+                            &title,
+                            &body,
+                            "logout-rest",
+                        );
+                    }
                 });
             } else {
+                // Already past; send immediately and mark interval 1 done.
+                rest_bell_count.store(1, Ordering::Relaxed);
                 crate::services::notifications::send_notification(&title, &body, "logout-rest");
             }
         }
@@ -537,35 +575,50 @@ pub fn GlobalSessionHeader() -> Element {
             } else {
                 0
             };
+            let bc = rest_bell_count.clone();
             wasm_bindgen_futures::spawn_local(async move {
                 gloo_timers::future::TimeoutFuture::new(delay_ms).await;
-                crate::services::notifications::send_notification(&title, &body, "logout-rest");
+                if !cancel.load(Ordering::Relaxed) {
+                    // Mark first interval done so the tick coroutine doesn't
+                    // fire a duplicate for interval 1.
+                    bc.store(1, Ordering::Relaxed);
+                    crate::services::notifications::send_notification(&title, &body, "logout-rest");
+                }
             });
         }
     });
 
     // Tick-based coroutine: fires a notification for every completed exceeded
     // interval (2nd, 3rd, … ring) so the user keeps being reminded.
-    use_coroutine(move |_: UnboundedReceiver<()>| async move {
-        loop {
-            crate::utils::sleep_ms(1_000).await;
-            let Some((start, duration)) = *rest_key.peek() else {
-                continue;
-            };
-            if duration == 0 {
-                continue;
-            }
-            let now = crate::models::get_current_timestamp();
-            let elapsed = now.saturating_sub(start);
-            let intervals = elapsed / duration;
-            let prev = *rest_bell_count.peek();
-            if intervals > prev {
-                rest_bell_count.set(intervals);
-                crate::services::notifications::send_notification(
-                    &rest_notif_title.peek(),
-                    &rest_notif_body.peek(),
-                    "logout-rest",
-                );
+    // Also handles the first notification on native (as a fallback).
+    use_coroutine(move |_: UnboundedReceiver<()>| {
+        // Clone inside the FnMut closure so each invocation gets its own Arc.
+        let bc = bc_tick.clone();
+        async move {
+            loop {
+                crate::utils::sleep_ms(1_000).await;
+                // Skip all checks while the session is paused.
+                if session_paused_at.peek().is_some() {
+                    continue;
+                }
+                let Some((start, duration)) = *rest_key.peek() else {
+                    continue;
+                };
+                if duration == 0 {
+                    continue;
+                }
+                let now = crate::models::get_current_timestamp();
+                let elapsed = now.saturating_sub(start);
+                let intervals = elapsed / duration;
+                let prev = bc.load(Ordering::Relaxed);
+                if intervals > prev {
+                    bc.store(intervals, Ordering::Relaxed);
+                    crate::services::notifications::send_notification(
+                        &rest_notif_title.peek(),
+                        &rest_notif_body.peek(),
+                        "logout-rest",
+                    );
+                }
             }
         }
     });

src/components/home.rs

@@ -66,10 +66,28 @@ pub fn Home() -> Element {
             .filter(|s| !s.is_active() && !viewed_ids.contains(&s.id))
             .cloned()
             .collect();
-        if !newly_completed.is_empty() {
+
+        // Sessions that became active again (e.g. resumed from completed state).
+        let active_ids: std::collections::HashSet<String> = sessions
+            .peek()
+            .iter()
+            .filter(|s| s.is_active())
+            .map(|s| s.id.clone())
+            .collect();
+        let has_resumed = !active_ids.is_empty()
+            && completed_sessions
+                .peek()
+                .iter()
+                .any(|s| active_ids.contains(&s.id));
+
+        if !newly_completed.is_empty() || has_resumed {
             newly_completed.sort_by(|a, b| b.start_time.cmp(&a.start_time));
             let new_len = {
                 let mut cs = completed_sessions.write();
+                // Remove sessions that have been re-activated.
+                if has_resumed {
+                    cs.retain(|s| !active_ids.contains(&s.id));
+                }
                 let mut new_cs = Vec::with_capacity(newly_completed.len() + cs.len());
                 new_cs.extend(newly_completed);
                 new_cs.extend(cs.drain(..));
@@ -157,6 +175,11 @@ pub fn Home() -> Element {
                             let mut s = last_sess.clone();
                             s.end_time = None;
                             s.paused_at = None;
+                            // Clear transient fields that are stale after the
+                            // session was completed (rest/exercise timers).
+                            s.rest_start_time = None;
+                            s.current_exercise_id = None;
+                            s.current_exercise_start = None;
                             s
                         };
                         rsx! {