sioul_app/

everywhere.rs

// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright © 2026 Aurélien Pierre

//! Do-not-disturb on every device, as this device applies and says it
//! (docs/do-not-disturb.md; the rules are `sioul_core::everywhere`). The one
//! caller of the do-not-disturb layer (`crate::dnd`): the pauses
//! (`pauses::apply`), the switch, the focus timer and the minute all come
//! here, and every device reads the same shared files: `quiet.toml` (the
//! pauses), `time/running.toml` (focus), Health (the night),
//! `state/do-not-disturb.toml` (the switch) and the `[dnd]` settings.
//!
//! - **Apply**: the system's do-not-disturb on for each reason that holds,
//!   off for each that does not; nothing redone when nothing changed (the
//!   layer keeps what it did). On Android, only in the window's process (where
//!   the layer's modes are kept): the background service asks it to
//!   (`steps`), and an alarm comes back at the next end (`steps::next`).
//! - **Say**: this device's table in the switch's file tells the others what
//!   holds here and whether its system is silenced; the status line, the
//!   phone's card and the service's notification say where it holds.
//! - **The list**: Always through (« Passent toujours »), edited in
//!   Settings ▸ Do not disturb; its people get through as its rows of the
//!   matrix of what reaches you say (`sioul_core::attention`), and on a phone
//!   Sioul says who is not starred there.
//! - **Both ways**: a change of this device's own do-not-disturb, heard as it
//!   happens, presses the switch when it disagrees with what holds here
//!   (`heard_from_system`); Sioul's going off here turns the system's own off too, where
//!   Sioul can (`apply`), and says what stays.

use crate::backend::qobject::Sioul;
use crate::backend::{QtThread, Shared, load_config, mode_json, say, tr};
use crate::dnd::{Ask, Report, Which};
use cxx_qt::Threading;
use cxx_qt_lib::QString;
use jiff::Zoned;
use std::pin::Pin;
use sioul_core::config::Config;
use sioul_core::everywhere::{self as rules, Now, People, Person, Sources, Switch, Why};
use sioul_core::quiet::Overrides;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex, PoisonError};
use std::time::{Duration, Instant};

/// This device's name in the sharing (share/here.toml), made once.
fn here_id() -> String {
    sioul_sync::share::Here::load(&sioul_core::config::state_dir()).id
}

/// What the reasons' sources say now (`rules::sources_at`, as every reader builds them).
fn sources(overrides: &Overrides, blocks: &sioul_core::quiet::Blocks, now: &Zoned) -> Sources {
    rules::sources_at(overrides, blocks, now)
}

/// When the devices gone were last noted (milliseconds; `note_gone`).
static GONE_NOTED: Mutex<i64> = Mutex::new(0);

/// A device forgotten, or its files removed, here: the devices gone noted
/// again at the next exchange, not an hour later (review of part 3, I1).
pub(crate) fn gone_soon() {
    if let Ok(mut last) = GONE_NOTED.lock() {
        *last = 0;
    }
}

/// At the window's exchanges, at most once an hour (and at the one after a
/// device was forgotten here: `gone_soon`): the devices the sharing has gone
/// by a sealed fact written down (`sioul_sync::share::asking`), for the
/// switch's reading. Never on a dose's path: the window's own exchanges only.
pub(crate) fn note_gone(folder: &std::path::Path, key: &[u8; 32], here: &str) {
    let now = jiff::Timestamp::now().as_millisecond();
    {
        let Ok(mut last) = GONE_NOTED.lock() else { return };
        if now - *last < 3_600_000 {
            return;
        }
        *last = now;
    }
    let (_, gone) = sioul_sync::share::asking(folder, key, &crate::share::memory_path(), here, now);
    if gone != rules::gone_devices()
        && let Ok(text) = serde_json::to_vec(&gone)
    {
        let path = rules::gone_path();
        let fresh = path.with_extension(format!("json.{}", std::process::id()));
        if std::fs::write(&fresh, text).and_then(|()| std::fs::rename(&fresh, &path)).is_err() {
            let _ = std::fs::remove_file(&fresh);
        }
    }
}

/// The switch as this device reads it (`rules::read_switch`): the devices gone from the sharing read as As usual.
fn switch_here(here: &str) -> Switch {
    rules::read_switch(here)
}

/// Health's nights, naps and meals: as the window has them; in the background
/// service's process, without the day's events (only the meals move for them,
/// and reading every calendar at each step would cost a phone's battery).
fn blocks(now: &Zoned) -> sioul_core::quiet::Blocks {
    if crate::steps::in_service() { sioul_core::quiet::Blocks::read(now, &[]) } else { crate::hours::blocks(now) }
}

/// Asleep (the night from winding down, a nap), and paused, now: for the
/// background service's rhythm, whatever the settings of do-not-disturb.
pub(crate) fn rest_now() -> (bool, bool) {
    let now = Zoned::now();
    let paused = Overrides::load(&Overrides::default_path()).paused_from().is_some();
    (blocks(&now).at(now.timestamp().as_second(), &["sleep", "nap"]).is_some(), paused)
}

/// What is read for one look: the settings, the pauses, the switch, why it
/// holds, and what now is for (the time under do-not-disturb's layer).
struct Look {
    config: Config,
    overrides: Overrides,
    switch: Switch,
    state: Now,
    mode: sioul_core::quiet::Mode,
    now: Zoned,
}

impl Look {
    fn now() -> Look {
        let config = load_config();
        let now = Zoned::now();
        let overrides = Overrides::load(&Overrides::default_path());
        let switch = switch_here(&here_id());
        let blocks = blocks(&now);
        let state = rules::now(&config.dnd, &sources(&overrides, &blocks, &now), switch.latest().as_ref(), now.timestamp().as_second());
        let mode = sioul_core::quiet::mode(&config.week_hours(), &config.time_off, &overrides, &blocks, &now);
        Look { config, overrides, switch, state, mode, now }
    }

    /// What each mode of Sioul's asks of the system now; none: off. Whom it
    /// lets through is the matrix of what reaches you's (`attention::silence_at`):
    /// at the pause's column; at Free time's ("Nothing at all" holding all but
    /// Always through); do-not-disturb's at sleep's, or at the time now under
    /// the switch's or a focus session's layer, as the matrix reads a layer.
    /// While this phone screens calls, every contact's call goes through the
    /// mode, Sioul having declined the others already, and anyone's when the
    /// call screening lets numbers nobody knows ring then; else the starred;
    /// and anyone's while Expecting a call holds.
    fn asks(&self) -> [(Which, Option<Ask>); 3] {
        use sioul_core::attention::{Column, Now as Moment, Senders};
        let (config, state) = (&self.config, &self.state);
        let gnome = config.pause.gnome;
        let paused = state.has(Why::Paused);
        let free = state.has(Why::FreeTime) && !paused;
        let attention = sioul_core::attention::Attention::of(config);
        let phone = phone_does();
        // While this phone screens calls: whether the call screening lets numbers nobody knows ring at each
        // mode's moment by itself (`calls::unknown_rings`), so that the mode silences nothing it lets ring; the
        // matrix then lets them through only where your contacts may ring (`attention::Phone::unknown`).
        let phone_at = |moment: &Moment| sioul_core::attention::Phone { unknown: phone.screens && crate::calls::unknown_rings(config, moment.times.iter().any(|c| matches!(c, Column::Work | Column::Admin))), ..phone };
        let mode = &self.mode;
        let through = self.through();
        let moment = |times: Vec<Column>, dnd: bool, nothing: bool| {
            let mut moment = Moment::of(mode);
            moment.times = times;
            moment.dnd = dnd;
            moment.nothing = nothing;
            moment.through = through;
            moment
        };
        let ask = |which: Which, moment: Moment| {
            let silence = attention.silence_at(&moment, phone_at(&moment));
            Ask { which, people: silence.calls != Senders::None, doses: silence.doses, desktop: gnome, silence: Some(silence), stack: true }
        };
        // The switch's mode adds nothing over this device's own do-not-disturb
        // when that alone turned it on (docs/do-not-disturb.md, "Both ways").
        let latest = self.switch.latest();
        let from_system = latest.as_ref().is_some_and(|p| p.on && p.via == rules::VIA_SYSTEM);
        let stack = !(from_system && rules::held_by_system(state, latest.as_ref(), &here_id()));
        let global = if state.has(Why::Sleep) { vec![Column::Sleep] } else { Moment::of(mode).times };
        [
            (Which::Paused, paused.then(|| ask(Which::Paused, moment(vec![Column::Pause], false, false)))),
            (Which::FreeTime, free.then(|| ask(Which::FreeTime, moment(vec![Column::Free], false, sioul_core::pause::nothing_now(&self.overrides, &config.free_time))))),
            (Which::Global, state.global().then(|| Ask { stack, ..ask(Which::Global, moment(global, state.gates(), false)) })),
        ]
    }

    /// Expecting a call (once "Let every call through") holds now, as this device knows it.
    fn through(&self) -> bool {
        crate::calls::through_now(&self.switch).is_some_and(|t| t.holds(self.now.timestamp().as_millisecond()))
    }

    /// What this device asks, in a few words: the background service compares
    /// it with what was applied last, and asks the window's process only on a change.
    fn signature(&self) -> String {
        self.asks().iter().map(|(which, ask)| format!("{which:?}:{}", ask.as_ref().map_or_else(|| "-".to_string(), |a| format!("{}{}{}{}{}", u8::from(a.people), u8::from(a.doses), u8::from(a.desktop), u8::from(a.stack), a.silence.map(|s| format!("{:?}{:?}{}{}{}", s.calls, s.messages, u8::from(s.repeat), u8::from(s.conversations), u8::from(s.events))).unwrap_or_default())))).collect::<Vec<_>>().join(",")
    }

    /// When to look again by itself: a reason's end, the next night or nap
    /// when sleep counts, the time's end while do-not-disturb's layer reads
    /// it, the end of Expecting a call (Unix seconds).
    fn next_change(&self) -> Option<i64> {
        let stamp = self.now.timestamp().as_second();
        let night = if self.config.dnd.sleep { blocks(&self.now).kept.iter().filter(|k| (k.kind == "sleep" || k.kind == "nap") && k.start > stamp).map(|k| k.start).min() } else { None };
        let time = if self.state.gates() { self.mode.until.as_ref().map(|u| u.timestamp().as_second()) } else { None };
        let through = crate::calls::through_now(&self.switch).filter(|t| t.holds(stamp * 1000) && t.until > 0).map(|t| (t.until + 999) / 1000);
        let reachable = self.state.reachable.as_ref().and_then(|r| r.until);
        [self.state.next_end(), night, time, through, reachable].into_iter().flatten().filter(|t| *t > stamp).min()
    }
}

/// What this phone does itself, for whom Sioul's modes let through: it
/// screens calls (Sioul holds the role). A computer nothing. Nothing of
/// the listener, though it may hold other apps' notifications:
/// Android plays a notification's sound before any listener hears of it
/// (docs/android.md, "Notifications from other apps", Sound), so a contact's
/// message let through the mode and then held by Sioul would ring once in a
/// pause or Free time; the mode is what keeps it silent. Calls differ: the
/// screening answers before the phone rings.
fn phone_does() -> sioul_core::attention::Phone {
    if !cfg!(target_os = "android") {
        return sioul_core::attention::Phone::default();
    }
    sioul_core::attention::Phone { screens: crate::calls::screens_here(), unknown: false }
}

/// Why do-not-disturb holds now, on every device alike.
pub(crate) fn now() -> Now {
    Look::now().state
}

/// One file as a reading kept was read from: when it was last changed, its
/// size, and on Unix its inode (each of these files is written beside and
/// renamed: a new one at each change, even within the clock's tick).
type FileSeen = Option<(std::time::SystemTime, u64, u64)>;

fn seen(path: &std::path::Path) -> FileSeen {
    let meta = std::fs::metadata(path).ok()?;
    #[cfg(unix)]
    let inode = std::os::unix::fs::MetadataExt::ino(&meta);
    #[cfg(not(unix))]
    let inode = 0;
    Some((meta.modified().ok()?, meta.len(), inode))
}

/// What Reachable's reading is made of beside the time: the switch, the
/// pauses, the devices gone from the sharing, Health's nights.
fn reach_inputs() -> Vec<FileSeen> {
    [Switch::default_path(), Overrides::default_path(), rules::gone_path(), sioul_core::health::Health::default_path(), sioul_core::needs::Days::default_path()].iter().map(|path| seen(path)).collect()
}

/// Reachable as last read, with what it was read from (`reach_inputs`);
/// forgotten at a press here.
static REACHABLE_KEPT: Mutex<Option<(Vec<FileSeen>, Option<rules::Reach>)>> = Mutex::new(None);

/// Tests only: the tests that write the shared files of this device's state
/// (the switch, the pauses, the listener's ledger and choices), one at a time.
#[cfg(test)]
pub(crate) static FILES: Mutex<()> = Mutex::new(());

/// Tests only: those files taken away, for a test to start from none.
#[cfg(test)]
pub(crate) fn files_cleared() {
    for path in [Switch::default_path(), Overrides::default_path(), rules::gone_path(), sioul_core::appnotes::Ledger::default_path(), sioul_core::appnotes::Choices::default_path()] {
        let _ = std::fs::remove_file(path);
    }
    if let Ok(mut kept) = REACHABLE_KEPT.lock() {
        *kept = None;
    }
}

/// Reachable now, on every device alike (part 3 of "What reaches you"):
/// since, until when, from which device. Asked at every notification: read
/// again whenever one of its files changed or its end passed, never kept by
/// time alone, so that a press brought from another device counts at once
/// (review of part 3, F4).
pub(crate) fn reachable() -> Option<rules::Reach> {
    let inputs = reach_inputs();
    let stamp = jiff::Timestamp::now().as_second();
    if let Ok(kept) = REACHABLE_KEPT.lock()
        && let Some((read_from, reach)) = kept.as_ref()
        && *read_from == inputs
        && reach.as_ref().is_none_or(|r| r.until.is_none_or(|until| stamp < until))
    {
        return reach.clone();
    }
    let reach = now().reachable;
    if let Ok(mut kept) = REACHABLE_KEPT.lock() {
        *kept = Some((inputs, reach.clone()));
    }
    reach
}

/// What the phone is asked to let through, by the device that asks
/// (`rules::Switch::release_stamps`): each device's "Let what your phone
/// holds through", and the Reachable press that holds.
pub(crate) fn release_stamps() -> Vec<(String, i64)> {
    switch_here(&here_id()).release_stamps()
}

/// The latest press of the switch known here (milliseconds): what a pause
/// pressed now knew of (`pause::start_pause`), so that it ends that
/// Reachable whatever the clocks (review of part 3, L2).
pub(crate) fn latest_press() -> i64 {
    switch_here(&here_id()).latest_known(None)
}

/// Whether the switch or a focus session holds do-not-disturb now: a layer
/// of the matrix of what reaches you (`hours::attention_now`), which says
/// what waits then (as usual, the sites' notifications and the suggestions
/// to move; doses, codes asked for, events' reminders and Health's notices
/// come, and Always through). Read again at most every five seconds: asked
/// at every notification.
pub(crate) fn holds_others() -> bool {
    static KEPT: Mutex<Option<(Instant, bool)>> = Mutex::new(None);
    if let Ok(kept) = KEPT.lock()
        && let Some((at, holds)) = *kept
        && at.elapsed() < Duration::from_secs(5)
    {
        return holds;
    }
    let holds = now().gates();
    if let Ok(mut kept) = KEPT.lock() {
        *kept = Some((Instant::now(), holds));
    }
    holds
}

/// Do-not-disturb holding from its switch or a focus session (`gated`):
/// when it ends, when that is known, and which of the two holds.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Gated {
    pub(crate) until: Option<i64>,
    pub(crate) focus: bool,
    pub(crate) switch: bool,
}

/// While do-not-disturb holds from its switch or a focus session (a layer
/// of the matrix of what reaches you): when it ends, when that is known
/// (none: until turned off, or a session open-ended), and which of the two
/// holds (the listener's line in the phone's log: "dnd (focus session)");
/// none otherwise.
pub(crate) fn gated() -> Option<Gated> {
    gated_of(&now())
}

/// The same, of a reading already made (`now`).
pub(crate) fn gated_of(state: &Now) -> Option<Gated> {
    let gates: Vec<&sioul_core::everywhere::Held> = state.holds.iter().filter(|h| matches!(h.why, Why::Focus | Why::Manual)).collect();
    let until = if gates.iter().any(|h| h.until.is_none()) { None } else { gates.iter().filter_map(|h| h.until).max() };
    (!gates.is_empty()).then_some(Gated { until, focus: gates.iter().any(|h| h.why == Why::Focus), switch: gates.iter().any(|h| h.why == Why::Manual) })
}

// ---------------------------------------------------------------- applying

/// Asked again while an apply runs: it goes once more, with what changed meanwhile.
static AGAIN: AtomicBool = AtomicBool::new(false);
static BUSY: Mutex<()> = Mutex::new(());

/// The system's do-not-disturb as the reasons say now, on this device: on
/// for each of Sioul's modes that holds, off for the others (the layer does
/// nothing when nothing changed); this device's table written when what it
/// says changed; the phone's card told; on Android, an alarm at the next end.
/// Called at the start, each minute, at once on a press, and after an
/// exchange brought a change. Never in the background service's process
/// (Android), which asks the window's process instead (`steps`).
pub(crate) fn apply() {
    AGAIN.store(true, Ordering::SeqCst);
    while AGAIN.load(Ordering::SeqCst) {
        let Some(busy) = crate::backend::one_at_a_time(&BUSY) else { return };
        if !AGAIN.swap(false, Ordering::SeqCst) {
            return;
        }
        apply_once();
        drop(busy);
    }
}

fn apply_once() {
    let look = Look::now();
    let mut reports: Vec<(Which, Report)> = Vec::new();
    for (which, ask) in look.asks() {
        match ask {
            Some(ask) => reports.push((which, crate::dnd::enter(&ask))),
            None => {
                crate::dnd::leave(which);
            }
        }
    }
    // This device's words: those of the mode of the reason said first.
    let said = match look.state.why() {
        Some(Why::Paused) => Which::Paused,
        Some(Why::FreeTime) => Which::FreeTime,
        _ => Which::Global,
    };
    let report = reports.iter().find(|(w, _)| *w == said).or(reports.first()).map(|(_, r)| r.clone()).unwrap_or_default();
    let why = look.state.why().map(Why::id).unwrap_or_default().to_string();
    // Both ways (docs/do-not-disturb.md): Sioul's do-not-disturb gone off here
    // turns the system's own off too, once, where Sioul can; while it is off,
    // what the system still holds here is said.
    let on = look.state.on();
    crate::dnd::tell_system(on);
    let was = crate::dnd::on_here(on);
    let acted = was && !on && crate::dnd::system_off(look.config.pause.gnome);
    let still = if on || acted { None } else { crate::dnd::still_on() };
    write_own(|own| {
        // Sioul runs here (again): it follows.
        own.closed = false;
        own.why = why.clone();
        own.silenced = report.on && !why.is_empty();
        own.turned_off = report.turned_off && !why.is_empty();
        own.system_on = still.is_some();
        own.line = match &still {
            _ if !why.is_empty() => report.line.clone(),
            Some(still) => still.line.clone(),
            None => String::new(),
        };
    });
    // The background service's notification says the state now, within a second: told once
    // this device's table is written (its words read it; before, they would say a state
    // between two), before the card and the calls' table, which may take longer.
    crate::steps::tell_note();
    crate::homecard::dnd_seen(moment());
    // On a phone, Android's alarm comes back at the next end, Sioul closed or not.
    crate::steps::next(look.next_change());
    // The calls' table follows the pauses, the times and the switch at once (`calls::refresh`:
    // written again only when what it is made of changed, or every ten minutes).
    crate::calls::refresh(false);
}

/// The background service's notification in words (`steps::note`): its
/// title, what now is for and until when ("Leisure until 22:00"); then
/// do-not-disturb here, as the status line says it while it holds, what this
/// device's own still holds while Sioul's is off, else that it is off. And
/// when what now is for ends (Unix seconds), for the service's next step.
pub(crate) fn note() -> (String, String, Option<i64>) {
    let look = Look::now();
    let tr = tr();
    let moment = moment_of(&look);
    let dnd = if moment["on"] == true {
        moment["line"].as_str().unwrap_or_default().to_string()
    } else if moment["system_on"] == true {
        moment["system_line"].as_str().unwrap_or_default().to_string()
    } else {
        String::new()
    };
    let dnd = if dnd.is_empty() { tr.text("steps-note-dnd-off", None) } else { dnd };
    // What now is for as the window has it, meals moved past events, in every process alike
    // (the service's own look leaves the events aside): the title never changes with the process.
    let mode = crate::hours::mode_at(&look.now);
    let times: Vec<String> = sioul_core::attention::Now::of(&mode).times.iter().map(|c| sioul_core::attention::column_label(tr, *c)).collect();
    let time = match times.as_slice() {
        [] => String::new(),
        [one] => one.clone(),
        [rest @ .., last] => format!("{} {} {}", rest.join(", "), tr.text("word-and", None), last.to_lowercase()),
    };
    let until = if mode.paused() { None } else { mode.until.clone() };
    let mut args = sioul_core::i18n::args();
    args.set("time", time);
    let title = match &until {
        Some(until) => {
            args.set("until", sioul_core::quiet::until_text(tr, until, &look.now));
            tr.text("steps-note-time", Some(&args))
        }
        None => tr.text("steps-note-time-open", Some(&args)),
    };
    (title, dnd, until.map(|u| u.timestamp().as_second()))
}

/// What this device asks of its system now, in a few words, and the status
/// line: the background service pokes the window's process when either
/// changed since it last did (`steps`).
pub(crate) fn wanted() -> (String, String) {
    let look = Look::now();
    (look.signature(), moment_of(&look)["line"].as_str().unwrap_or_default().to_string())
}

/// This device's own table changed (its kind and name always set), under
/// the file's lock; written only when it changed. Sharing off, it is kept
/// here all the same: the switch works on this device alone.
fn write_own(change: impl FnOnce(&mut rules::Device)) {
    let here = here_id();
    let now = jiff::Timestamp::now().as_millisecond();
    let result = rules::change_own(&Switch::default_path(), &here, |switch| {
        let after = switch.latest_known(None) + 1;
        let own = switch.device.entry(here.clone()).or_default();
        let before = own.clone();
        change(own);
        own.kind = crate::devices::kind().to_string();
        own.name = if own.kind == "phone" { String::new() } else { crate::devices::name() };
        let changed = *own != before;
        if changed {
            // Never before a press already known here: the others read it as written after it.
            own.at = now.max(after);
        }
        changed
    });
    if let Err(e) = result {
        eprintln!("sioul: do-not-disturb: {e}");
    }
}

/// The switch pressed in the window: on for `minutes` (0: until turned off;
/// -1: until what now is for ends), or off. Applied here, the status line
/// shown again, and the other devices told at once.
pub(crate) fn toggle(mut sioul: Pin<&mut Sioul>, on: bool, minutes: i32) {
    let now = Zoned::now();
    let until = match minutes {
        m if m > 0 => Some(now.timestamp().as_second() + i64::from(m) * 60),
        -1 => crate::hours::mode_at(&now).until.map(|u| u.timestamp().as_second()),
        _ => None,
    };
    if let Err(e) = press(on, until.filter(|_| on)) {
        sioul.as_mut().set_status(QString::from(&e));
        return;
    }
    let (qt, shared) = (sioul.qt_thread(), sioul.shared());
    std::thread::spawn(move || {
        apply();
        let _ = qt.queue(|mut sioul| sioul.as_mut().set_mode(QString::from(&mode_json())));
        crate::share::exchange(&qt, &shared);
    });
}

/// The switch pressed here: on until `until` (Unix seconds; none, until
/// turned off), or off; on every device once the sharing carries it. Applied
/// by the caller (`apply`).
pub(crate) fn press(on: bool, until: Option<i64>) -> Result<(), String> {
    press_via(on, until, "")
}

/// Tonight: when the night begins next, by day, as Health knows it (Unix
/// seconds); none at night, or with no night known ("Work until tonight").
pub(crate) fn tonight(now: &Zoned) -> Option<i64> {
    match night_and_waking(now) {
        (night, None) => night,
        _ => None,
    }
}

/// When the night begins next (by day) and when the night you are in ends
/// (at night), as Health knows them (Unix seconds): for Reachable's ends.
fn night_and_waking(now: &Zoned) -> (Option<i64>, Option<i64>) {
    let stamp = now.timestamp().as_second();
    let blocks = blocks(now);
    let waking = blocks.at(stamp, &["sleep"]).map(|k| k.end);
    let night = blocks.kept.iter().filter(|k| k.kind == "sleep" && k.start > stamp).map(|k| k.start).min();
    (night, waking)
}

/// The ends Reachable may be pressed for now (Unix seconds; 0 none): the end
/// of the hours you are in, the night's start (or waking, at night), and
/// whether it is night.
fn reachable_ends(now: &Zoned) -> (i64, i64, bool) {
    let stamp = now.timestamp().as_second();
    let (night, waking) = night_and_waking(now);
    let mode = crate::hours::mode_at(now);
    // The hours' end, never past the night's start: Reachable's latest end (F2).
    let hours = mode.until.as_ref().map(|u| u.timestamp().as_second()).filter(|u| *u > stamp && waking.is_none()).map(|u| night.map_or(u, |night| u.min(night)));
    (hours.unwrap_or(0), waking.or(night).unwrap_or(0), waking.is_some())
}

/// One of the three states pressed here (`rules::State`; part 3 of "What
/// reaches you"): Reachable for `length` ("30", "60", "120" minutes,
/// "hours" until the hours you are in end, "tonight", "off" until you turn
/// it off: at the latest the night's start, or waking at night), As usual,
/// or Do not disturb for `length` minutes ("0" until turned off, "-1" until
/// what now is for ends). Applied here, the status line shown again, the
/// other devices told at once; a Reachable press releases what the phone
/// holds (`appnotes::review`, at its next look).
pub(crate) fn choose(mut sioul: Pin<&mut Sioul>, state: &str, length: &str) {
    let now = Zoned::now();
    let stamp = now.timestamp().as_second();
    let (state, until, open) = match rules::State::read(state) {
        Some(rules::State::Reachable) => {
            // Never during a pause (decision 9), by the pause itself, whatever do-not-disturb's
            // settings say of pauses (review of part 3, F6): the pause's button ends it.
            if Look::now().mode.paused() {
                sioul.as_mut().set_status(QString::from(&tr().text("reach-not-in-pause", None)));
                return;
            }
            let length = match length {
                "hours" => rules::Length::HoursEnd,
                "tonight" => rules::Length::Tonight,
                "off" => rules::Length::Off,
                minutes => rules::Length::Minutes(minutes.parse().unwrap_or(60)),
            };
            let (night, waking) = night_and_waking(&now);
            let hours = reachable_ends(&now).0;
            match rules::reachable_until(length, stamp, (hours > 0).then_some(hours), night, waking) {
                Some((until, open)) => (rules::State::Reachable, Some(until), open),
                None => {
                    sioul.as_mut().set_status(QString::from(&tr().text("reach-no-end", None)));
                    return;
                }
            }
        }
        Some(rules::State::Dnd) => {
            let until = match length.parse::<i64>().unwrap_or(0) {
                m if m > 0 => Some(stamp + m * 60),
                -1 => crate::hours::mode_at(&now).until.map(|u| u.timestamp().as_second()),
                _ => None,
            };
            (rules::State::Dnd, until, false)
        }
        _ => (rules::State::Usual, None, false),
    };
    if let Err(e) = press_state(state, until, open) {
        sioul.as_mut().set_status(QString::from(&e));
        return;
    }
    let (qt, shared) = (sioul.qt_thread(), sioul.shared());
    std::thread::spawn(move || {
        apply();
        let _ = qt.queue(|mut sioul| sioul.as_mut().set_mode(QString::from(&mode_json())));
        crate::backend::follow_reachable(&qt, &shared);
        crate::share::exchange(&qt, &shared);
    });
}

/// A press of one of the three states here, until `until` (Unix seconds),
/// "until you turn it off" or not (`open`); applied by the caller.
pub(crate) fn press_state(state: rules::State, until: Option<i64>, open: bool) -> Result<(), String> {
    crate::devices::pressed();
    if let Ok(mut kept) = REACHABLE_KEPT.lock() {
        *kept = None;
    }
    let here = here_id();
    let now = jiff::Timestamp::now().as_millisecond();
    // What it carries of the press before it, as the readers read that press (a gone device's As usual
    // holds nothing off), never as the file says it (review of part 3, R-5).
    let held_off = rules::held_off_of(switch_here(&here).latest().as_ref(), state);
    rules::change_own(&Switch::default_path(), &here, |switch| {
        switch.press_state(&here, state, until.map_or(0, |u| u.saturating_mul(1000)), open, now, "");
        let own = switch.device.entry(here.clone()).or_default();
        own.held_off = held_off;
        own.kind = crate::devices::kind().to_string();
        own.name = if own.kind == "phone" { String::new() } else { crate::devices::name() };
        true
    })?;
    Ok(())
}

/// "Let what your phone holds through", pressed on a computer (3.3): a
/// release stamp in this device's table; the phone lets through what it held
/// before it, once, and the computer never learns what it was. Sent at once.
pub(crate) fn let_through(mut sioul: Pin<&mut Sioul>) {
    let here = here_id();
    let now = jiff::Timestamp::now().as_millisecond();
    let written = rules::change_own(&Switch::default_path(), &here, |switch| {
        switch.release(&here, now);
        true
    });
    if let Err(e) = written {
        eprintln!("sioul: do-not-disturb: {e}");
        sioul.as_mut().set_status(QString::from(&e));
        return;
    }
    sioul.as_mut().set_status(QString::from(&tr().text("reach-let-through-done", None)));
    let (qt, shared) = (sioul.qt_thread(), sioul.shared());
    crate::share::exchange(&qt, &shared);
}

/// A press here, saying where it came from (`rules::VIA_SYSTEM`: this
/// device's own do-not-disturb, heard as it changed; "": the switch).
fn press_via(on: bool, until: Option<i64>, via: &str) -> Result<(), String> {
    // Someone at this computer, said in its entry among your devices at the next
    // export (the press's own exchange carries it): a phone's steps follow it (`devices::pressed`).
    crate::devices::pressed();
    let here = here_id();
    let now = jiff::Timestamp::now().as_millisecond();
    rules::change_own(&Switch::default_path(), &here, |switch| {
        switch.press_via(&here, on, until.map_or(0, |u| u.saturating_mul(1000)), now, via);
        let own = switch.device.entry(here.clone()).or_default();
        own.kind = crate::devices::kind().to_string();
        own.name = if own.kind == "phone" { String::new() } else { crate::devices::name() };
        true
    })?;
    Ok(())
}

// ---------------------------------------------------------------- both ways

/// One heard change at a time: two words of the same change (Android's
/// status and its filter, two of Plasma's) press once.
static HEARING: Mutex<()> = Mutex::new(());

/// A change of this device's own do-not-disturb, heard as it happened
/// (Android's receiver, Plasma's `Inhibited`, GNOME's switch), whatever
/// caused it: a press of the switch here when it disagrees with what holds
/// (`rules::heard`), applied, shown and sent at once; nothing when it agrees,
/// which is what Sioul's own changes look like when they come back
/// (docs/do-not-disturb.md, "Both ways"). Whether it pressed. Any thread.
pub(crate) fn heard_from_system(system_on: bool) -> bool {
    let _one = HEARING.lock().unwrap_or_else(PoisonError::into_inner);
    let Some(on) = rules::heard(now().on(), system_on) else { return false };
    if let Err(e) = press_via(on, None, rules::VIA_SYSTEM) {
        eprintln!("sioul: do-not-disturb: {e}");
        return false;
    }
    apply();
    told();
    true
}

/// The window, when it runs in this process: what is heard or pressed
/// outside it shows there at once, and is sent with its exchange.
static WINDOW: Mutex<Option<(QtThread, Arc<Shared>)>> = Mutex::new(None);

/// The window runs (at the start and each minute, from the pauses' tick):
/// kept, and this system's own do-not-disturb followed (`dnd::listen`), once.
pub(crate) fn started(qt: &QtThread, shared: &Arc<Shared>) {
    let mut window = WINDOW.lock().unwrap_or_else(PoisonError::into_inner);
    if window.is_none() {
        *window = Some((qt.clone(), Arc::clone(shared)));
        crate::dnd::listen(Arc::new(|on| {
            std::thread::spawn(move || heard_from_system(on));
        }));
    }
}

/// A press made outside the window (a system's change heard, the phone's
/// tile): the window's status line at once and the other devices told;
/// without the window (a phone's receiver), the background service sends it.
fn told() {
    let window = WINDOW.lock().ok().and_then(|window| window.clone());
    match window {
        Some((qt, shared)) => {
            let _ = qt.queue(|mut sioul| sioul.as_mut().set_mode(QString::from(&mode_json())));
            crate::share::exchange(&qt, &shared);
        }
        None => crate::steps::send_now(),
    }
}

/// Sioul quits on a computer (its window closed, the tray's Quit, SIGTERM):
/// this device's table as it then holds, for the other devices to say
/// "On laptop: Sioul is closed." and never "silenced" by an inhibition that
/// ended with Sioul; sent by the exchange that follows (`share::closing`).
/// Nothing on a phone, whose modes stay while Sioul is closed.
pub(crate) fn closing() {
    if cfg!(target_os = "android") {
        return;
    }
    let still = crate::dnd::still_after_quit();
    write_own(|own| own.closing(still));
}

/// The switch pressed from the phone's quick settings (Sioul's tile): on
/// until turned off, or off, as it is not now; applied and sent at once.
pub(crate) fn toggle_here() {
    if let Err(e) = press(!now().on(), None) {
        eprintln!("sioul: do-not-disturb: {e}");
        return;
    }
    apply();
    told();
}

/// "Silence this device again": each of Sioul's modes that holds here left
/// and entered afresh, the person's earlier "off" in the system set aside. A
/// switch "on" taken from this device's own system becomes the switch's own,
/// so that Sioul's mode silences the device whatever the system does.
pub(crate) fn again() {
    if Look::now().switch.latest().is_some_and(|p| p.on && p.via == rules::VIA_SYSTEM)
        && let Err(e) = press(true, None)
    {
        eprintln!("sioul: do-not-disturb: {e}");
    }
    for ask in Look::now().asks().into_iter().filter_map(|(_, ask)| ask) {
        crate::dnd::again(&ask);
    }
    apply();
    told();
}

// ---------------------------------------------------------------- saying

/// A device named inside a sentence: "your phone", a computer's name, "another device".
fn name_of(switch: &Switch, id: &str) -> String {
    let (kind, name) = switch.device.get(id).filter(|d| !d.kind.is_empty()).map(|d| (d.kind.clone(), d.name.clone())).or_else(|| crate::devices::kind_and_name(id)).unwrap_or_default();
    match kind.as_str() {
        "phone" => tr().text("dnd-device-phone", None),
        _ if !name.trim().is_empty() => name,
        _ => tr().text("dnd-device-other", None),
    }
}

/// The other devices sharing, and when each was last heard from (Unix seconds).
fn heard(here: &str) -> Vec<(String, i64)> {
    let Some((_, Some((folder, _)))) = crate::share::vault() else { return Vec::new() };
    sioul_sync::share::others(&folder, here).into_iter().map(|o| (o.id, o.heard)).collect()
}

/// "17:00", "tomorrow at 07:00".
fn when(stamp: i64, now: &Zoned) -> String {
    jiff::Timestamp::from_second(stamp).map(|t| sioul_core::quiet::until_text(tr(), &t.to_zoned(now.time_zone().clone()), now)).unwrap_or_default()
}

/// Do-not-disturb as the status line, the phone's card and the background
/// service's notification say it: {on, why, global, manual, until, until_at
/// (0: until switched off), line, why_line, details, everywhere, here,
/// button, end_time, end_at}.
pub(crate) fn moment() -> serde_json::Value {
    moment_of(&Look::now())
}

fn moment_of(look: &Look) -> serde_json::Value {
    let state = &look.state;
    let now = &look.now;
    let stamp = now.timestamp().as_second();
    // The end of what now is for, for "Until 17:00" in the switch's menu (the window's alone).
    let end = if crate::steps::in_service() { None } else { crate::hours::mode_at(now).until.map(|u| u.timestamp().as_second()).filter(|u| *u > stamp && *u - stamp < 24 * 3600) };
    // The three states (part 3): which holds, Reachable's end and words, and the ends it may be pressed for.
    let (hours_end, night_end, at_night) = if crate::steps::in_service() { (0, 0, false) } else { reachable_ends(now) };
    let reach = state.reachable.as_ref().map(|r| {
        let until = r.until.map(|u| when(u, now)).unwrap_or_default();
        let line = match (r.open, until.is_empty()) {
            (_, true) => tr().text("reach-line-open-ended", None),
            (true, false) => say("reach-line-open", &[("until", until.clone())]),
            (false, false) => say("reach-line", &[("until", until.clone())]),
        };
        serde_json::json!({ "until": until, "until_at": r.until.unwrap_or(0), "open": r.open, "line": line, "from": name_of(&look.switch, &r.from) })
    });
    let capped: Vec<bool> = [30, 60, 120].iter().map(|minutes| night_end > 0 && stamp + minutes * 60 > night_end).collect();
    let base = serde_json::json!({
        "button": look.config.dnd.button,
        "end_time": end.map(|e| when(e, now)).unwrap_or_default(),
        "end_at": end.unwrap_or(0),
        "state": if state.reachable.is_some() { "reachable" } else if state.on() { "dnd" } else { "usual" },
        "reachable": reach.unwrap_or(serde_json::Value::Null),
        // The pause itself, whatever do-not-disturb's settings say of pauses (F6).
        "paused": look.mode.paused(),
        // Each of the three minute lengths that meets Reachable's latest end, said so (F2).
        "reach_capped": capped,
        "reach_hours": hours_end,
        "reach_hours_time": if hours_end > 0 { when(hours_end, now) } else { String::new() },
        "reach_tonight": night_end,
        "reach_tonight_time": if night_end > 0 { when(night_end, now) } else { String::new() },
        "reach_at_night": at_night,
    });
    let here = here_id();
    let own = look.switch.device.get(&here);
    if !state.on() {
        // Sioul's off, this device's own still on: said, with what may be opened (both ways).
        let system_line = own.filter(|d| d.system_on && d.why.is_empty()).map(|d| d.line.clone()).unwrap_or_default();
        let mut off = serde_json::json!({
            "on": false, "why": "", "global": false, "manual": false, "until": "", "until_at": 0, "line": "", "why_line": "", "details": [], "everywhere": false, "here": false,
            "here_off": false, "here_offers": [],
            "system_on": !system_line.is_empty(), "system_offers": system_offers(&system_line), "system_line": system_line,
            "last_off": last_off(look),
        });
        merge(&mut off, base);
        return off;
    }
    // What this device's system said for the reason that holds; not applied yet: as Sioul's own alone.
    let (silenced, line) = own.filter(|d| !d.why.is_empty()).map_or((false, String::new()), |d| (d.silenced, d.line.clone()));
    // Since the reason said first began: a device's table older than that says what held before.
    let since = state.holds.first().map_or(0, |h| h.since.saturating_mul(1000));
    // A device with its entry in the devices' registry knows do-not-disturb; one without runs an older Sioul.
    let others = rules::others(&look.switch, &here, &heard(&here), stamp, since, &|id| crate::devices::kind_and_name(id).is_some());
    let until = state.until();
    let until_words = until.map(|u| when(u, now)).unwrap_or_default();
    let turned_off = own.is_some_and(|d| d.turned_off && !d.why.is_empty());
    let said = rules::said(state, rules::Here { silenced, line: &line, turned_off }, &others, &until_words, &|id| name_of(&look.switch, id), tr());
    let mut on = serde_json::json!({
        "on": true,
        "why": state.why().map(Why::id).unwrap_or_default(),
        "global": state.global(),
        "manual": state.has(Why::Manual),
        "until": until_words,
        "until_at": until.unwrap_or(0),
        "line": said.line,
        "why_line": said.why,
        "details": said.details,
        "everywhere": said.everywhere,
        "here": said.here,
        "here_off": turned_off,
        "here_offers": system_offers(if turned_off { &line } else { "" }),
        "system_on": false, "system_line": "", "system_offers": [], "last_off": "",
    });
    merge(&mut on, base);
    on
}

/// The buttons beside a line of this device's own do-not-disturb: on a phone,
/// Android's do-not-disturb settings, where the person turns it off or on again.
fn system_offers(line: &str) -> serde_json::Value {
    if line.is_empty() || !cfg!(target_os = "android") {
        return serde_json::json!([]);
    }
    serde_json::json!([{ "key": "modes", "label": crate::dnd::offer_label("modes") }])
}

/// "Turned off on your phone at 14:02, outside Sioul.": the switch's latest
/// press, when it is an "off" heard from a device's own do-not-disturb within
/// the last twelve hours; "" otherwise.
fn last_off(look: &Look) -> String {
    let Some(press) = look.switch.latest().filter(|p| !p.on && p.via == rules::VIA_SYSTEM) else { return String::new() };
    let at = press.at / 1000;
    if look.now.timestamp().as_second() - at > 12 * 3600 {
        return String::new();
    }
    let Ok(time) = jiff::Timestamp::from_second(at) else { return String::new() };
    let time = time.to_zoned(look.now.time_zone().clone()).strftime("%H:%M").to_string();
    say("dnd-last-off", &[("device", name_of(&look.switch, &press.from)), ("time", time)])
}

fn merge(into: &mut serde_json::Value, from: serde_json::Value) {
    if let (Some(into), serde_json::Value::Object(from)) = (into.as_object_mut(), from) {
        into.extend(from);
    }
}

// ---------------------------------------------------------------- Settings ▸ Do not disturb

/// The numbers' country, for numbers written without one.
fn region(config: &Config) -> Option<&'static sioul_core::phones::Region> {
    sioul_core::phones::chosen(config.contacts.region.as_deref(), &tr().text("qt-locale", None))
}

/// The tab's own part, as JSON: what this device can do (the layer's line
/// and buttons, GNOME's consent, Plasma's word on the list's mail), the
/// list, and on a phone who is starred and the background service.
pub(crate) fn setup() -> String {
    setup_with(String::new())
}

fn setup_with(said: String) -> String {
    let config = load_config();
    let mut here = crate::dnd::can().json();
    let mut lines = Vec::new();
    let offers: Vec<String> = here["offers"].as_array().map(|o| o.iter().filter_map(|x| x["key"].as_str().map(str::to_string)).collect()).unwrap_or_default();
    if !cfg!(target_os = "android") && here["on"] == true {
        // Plasma hiding even critical notifications: the list's mail neither shows meanwhile.
        lines.push(tr().text(if offers.iter().any(|o| o == "plasma") { "dnd-setup-plasma-mail" } else { "dnd-setup-critical" }, None));
    }
    here["lines"] = serde_json::json!(lines);
    let people = People::read(&People::default_path());
    let problem = people.as_ref().err().map(|why| say("dnd-setup-unreadable", &[("why", why.clone())])).unwrap_or_default();
    let people: Vec<serde_json::Value> = people
        .unwrap_or_default()
        .people
        .iter()
        .map(|p| {
            let mut notes = Vec::new();
            if p.phones.is_empty() {
                notes.push(tr().text("dnd-setup-no-number", None));
            }
            if p.emails.is_empty() {
                notes.push(tr().text("dnd-setup-no-email", None));
            }
            serde_json::json!({ "id": p.id, "name": p.name, "phones": p.phones, "emails": p.emails, "notes": notes })
        })
        .collect();
    let mut setup = serde_json::json!({
        "here": here,
        "gnome": config.pause.gnome,
        "people": people,
        "problem": problem,
        "said": said,
        "android": cfg!(target_os = "android"),
    });
    if cfg!(target_os = "android") {
        setup["stars"] = stars(&config);
        setup["steps"] = crate::steps::setup(&config);
    }
    setup.to_string()
}

/// Who on the list is starred on this phone (READ_CONTACTS, never written):
/// {permission, summary, people: [{id, name, state, contact}]}, the state
/// "starred", "not-starred", "unknown" (no contact has their number),
/// "no-number".
fn stars(config: &Config) -> serde_json::Value {
    let people = People::load(&People::default_path());
    let asked: Vec<serde_json::Value> = people.people.iter().map(|p| serde_json::json!({ "id": p.id, "phones": p.phones })).collect();
    let answer = crate::steps::java("stars", &serde_json::json!({ "people": asked }).to_string());
    let _ = config;
    stars_of(&people, &answer, tr())
}

/// Java's answer about the list's people, in words: who is not starred here.
fn stars_of(people: &People, answer: &serde_json::Value, tr: &sioul_core::i18n::Translator) -> serde_json::Value {
    if answer["permission"] != true {
        return serde_json::json!({ "permission": false, "summary": tr.text("dnd-stars-permission", None), "people": [] });
    }
    let found = answer["people"].as_array().cloned().unwrap_or_default();
    let mut missing = 0;
    let listed: Vec<serde_json::Value> = people
        .people
        .iter()
        .map(|p| {
            let seen = found.iter().find(|f| f["id"] == p.id.as_str());
            let state = if p.phones.is_empty() { "no-number" } else { seen.and_then(|f| f["state"].as_str()).unwrap_or("unknown") };
            if state == "not-starred" || state == "unknown" {
                missing += 1;
            }
            serde_json::json!({ "id": p.id, "name": if p.name.is_empty() { p.emails.first().cloned().unwrap_or_default() } else { p.name.clone() }, "state": state, "contact": seen.and_then(|f| f["contact"].as_str()).unwrap_or_default() })
        })
        .collect();
    let summary = if missing == 0 {
        tr.text("dnd-stars-all", None)
    } else {
        tr.text("dnd-stars-missing", Some(&tr.counted(missing)))
    };
    serde_json::json!({ "permission": true, "summary": summary, "missing": missing, "people": listed })
}

/// An action of the tab: the list changed, a contact opened, a permission
/// asked… (`verb`, its JSON). Answers the tab again, with a line said, and
/// whether something to share changed (the list, this device's setting).
pub(crate) fn change(verb: &str, json: &str) -> (String, bool) {
    let changes = matches!(verb, "add-safe" | "add-contact" | "add" | "edit" | "remove" | "gnome");
    let answer = change_here(verb, json);
    if verb == "gnome" {
        std::thread::spawn(apply);
    }
    (answer, changes)
}

fn change_here(verb: &str, json: &str) -> String {
    let asked: serde_json::Value = serde_json::from_str(json).unwrap_or_default();
    let config = load_config();
    let region = region(&config);
    let path = People::default_path();
    let text = |key: &str| asked[key].as_str().unwrap_or_default().trim().to_string();
    let lines = |key: &str| asked[key].as_str().unwrap_or_default().lines().map(str::trim).filter(|l| !l.is_empty()).map(str::to_string).collect::<Vec<_>>();
    let said = match verb {
        // Everyone on the Safe list: their cards' names and numbers; the
        // categories, cards and numbers on it too, as its lines write them.
        "add-safe" => {
            let list = sioul_core::porch::SenderList::load(&config.safe_senders_path());
            let entries: Vec<String> = list
                .entries()
                .into_iter()
                .chain(list.categories().iter().map(|c| format!("{}{c}", sioul_core::porch::CATEGORY)))
                .chain(list.cards().iter().map(|c| format!("{}{c}", sioul_core::porch::CONTACT)))
                .chain(list.numbers().iter().map(|n| format!("{}{n}", sioul_core::porch::TEL)))
                .collect();
            let (found, patterns) = rules::from_safe(&entries, &sioul_core::contacts::all());
            let mut added = 0;
            match rules::change_people(&path, |people| {
                for person in found {
                    let before = people.people.len();
                    people.add(person, region);
                    added += people.people.len() - before;
                }
            }) {
                Ok(_) => {
                    let mut said = tr().text("dnd-setup-added-safe", Some(&tr().counted(added)));
                    if patterns > 0 {
                        said = format!("{said} {}", tr().text("dnd-setup-patterns", Some(&tr().counted(patterns))));
                    }
                    said
                }
                Err(why) => say("dnd-setup-unreadable", &[("why", why)]),
            }
        }
        // A contact picked from the address books; off the blocked list (Q3).
        "add-contact" => {
            let uid = text("uid");
            match sioul_core::contacts::all().into_iter().find(|c| c.uid == uid) {
                Some(card) => {
                    let person = rules::from_contact(&card);
                    let unblocked = unblock(&config, &person);
                    let said = edit_people(&path, |people| {
                        people.add(person, region);
                    });
                    with_unblocked(said, unblocked)
                }
                None => String::new(),
            }
        }
        // By hand, or changed: a name, numbers and addresses, one per line.
        "add" | "edit" => {
            let person = Person { id: text("id"), name: text("name"), phones: lines("phones"), emails: lines("emails"), ..Person::default() };
            if person.name.is_empty() && person.phones.is_empty() && person.emails.is_empty() {
                String::new()
            } else {
                let unblocked = unblock(&config, &person);
                let said = edit_people(&path, |people| match people.people.iter_mut().find(|p| verb == "edit" && p.id == person.id) {
                    Some(known) => {
                        known.name = person.name;
                        known.phones = person.phones;
                        known.emails = person.emails;
                    }
                    None => {
                        people.add(Person { id: String::new(), ..person }, region);
                    }
                });
                with_unblocked(said, unblocked)
            }
        }
        "remove" => edit_people(&path, |people| {
            people.remove(&text("id"));
        }),
        // The contacts that match, to pick one (twenty at most).
        "search" => {
            let all = sioul_core::contacts::all();
            let query = text("query");
            let found: Vec<serde_json::Value> = sioul_core::contacts::search(&all, &query)
                .into_iter()
                .filter(|c| !c.phones.is_empty() || !c.emails.is_empty())
                .take(20)
                .map(|c| serde_json::json!({ "uid": c.uid, "name": c.name, "detail": c.phones.first().map(|p| p.value.clone()).or_else(|| c.emails.first().map(|e| e.value.clone())).unwrap_or_default() }))
                .collect();
            return serde_json::json!({ "found": found, "none": if found.is_empty() { tr().text("dnd-setup-no-match", None) } else { String::new() } }).to_string();
        }
        // A system page: Android's access, Plasma's settings, the starred list.
        "open" => {
            crate::dnd::open(&text("key"));
            String::new()
        }
        // "Silence this device again" (the switch's menu): the person's earlier "off" in the system set aside.
        "again" => {
            std::thread::spawn(again);
            String::new()
        }
        // On a phone: a person's contact (to star it), Android's form to add one, the permission.
        "open-contact" => {
            crate::steps::java("open-contact", &serde_json::json!({ "uri": text("contact") }).to_string());
            String::new()
        }
        "add-to-contacts" => {
            if let Some(p) = People::load(&path).people.into_iter().find(|p| p.id == text("id")) {
                crate::steps::java("add-contact", &serde_json::json!({ "name": p.name, "phones": p.phones, "emails": p.emails }).to_string());
            }
            String::new()
        }
        "allow-contacts" => {
            crate::steps::ask_contacts();
            String::new()
        }
        "battery" => {
            crate::steps::java("ask-battery", "{}");
            String::new()
        }
        // This phone kept in step in the background, or not (its own setting).
        "background" => crate::steps::set_background(asked["on"] == true).err().unwrap_or_default(),
        // GNOME's consent, the same one the pauses use.
        "gnome" => sioul_core::settings::apply(&crate::backend::config_path(), &config, "pause.gnome", &sioul_core::config::SettingValue::Bool(asked["on"] == true)).err().unwrap_or_default(),
        _ => String::new(),
    };
    setup_with(said)
}

/// Someone put on Always through comes off the blocked list: blocked and
/// Always through exclude each other (docs/attention.md, Q3). Whether they were on it.
fn unblock(config: &Config, person: &Person) -> bool {
    sioul_core::porch::unblock_person(config, &person.emails, &person.phones, &person.contact).unwrap_or_else(|e| {
        eprintln!("sioul: {e}");
        false
    })
}

/// What a change said, and that someone came off the blocked list, when they did.
fn with_unblocked(said: String, unblocked: bool) -> String {
    if !unblocked {
        return said;
    }
    [said, tr().text("attention-unblocked", None)].into_iter().filter(|s| !s.is_empty()).collect::<Vec<_>>().join(" ")
}

/// The list changed; "" said, or why it could not be.
fn edit_people(path: &std::path::Path, change: impl FnOnce(&mut People)) -> String {
    match rules::change_people(path, change) {
        Ok(_) => String::new(),
        Err(why) => say("dnd-setup-unreadable", &[("why", why)]),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn the_signature_follows_what_is_asked() {
        let look = |paused: bool, manual: bool| {
            let config = Config::default();
            let press = manual.then(|| rules::Press { at: 1_000, on: true, until: 0, from: "x".into(), via: String::new(), state: rules::State::Dnd, open: false, held_off: 0, gone: false });
            let sources = Sources { paused: paused.then_some(1), ..Sources::default() };
            let state = rules::now(&config.dnd, &sources, press.as_ref(), 100);
            let now = Zoned::now();
            let mode = sioul_core::quiet::mode(&config.week_hours(), &config.time_off, &Overrides::default(), &sioul_core::quiet::Blocks::default(), &now);
            Look { config, overrides: Overrides::default(), switch: Switch::default(), state, mode, now }
        };
        let off = look(false, false).signature();
        assert_eq!(off, "Paused:-,FreeTime:-,Global:-");
        assert_ne!(look(false, true).signature(), off);
        assert_ne!(look(true, false).signature(), look(false, true).signature());
        assert_eq!(look(true, true).asks().iter().filter(|(_, a)| a.is_some()).count(), 2, "the pause and the switch, each its own mode");
        // Expecting a call pressed: anyone's call through the pause's mode, said in what it asks.
        let mut through = look(true, false);
        sioul_core::calls::press(&mut through.switch, "phone", true, 0, Zoned::now().timestamp().as_millisecond());
        let calls = |look: &Look| look.asks()[0].1.as_ref().and_then(|a| a.silence).map(|s| s.calls);
        assert_eq!((calls(&through), calls(&look(true, false))), (Some(sioul_core::attention::Senders::Anyone), Some(sioul_core::attention::Senders::Starred)));
        assert_ne!(through.signature(), look(true, false).signature());
    }

    /// Part 3: the status line's moment says which of the three states
    /// holds, Reachable's end in its words, whether it is "until you turn it
    /// off", and a pause, during which Reachable neither holds nor is offered.
    #[test]
    fn the_moment_says_which_of_the_three_states_holds() {
        let look = |press: Option<rules::Press>, paused: bool| {
            let config = Config::default();
            let now = Zoned::now();
            let stamp = now.timestamp().as_second();
            let overrides = Overrides { paused_since: paused.then_some(stamp - 60), ..Overrides::default() };
            let sources = rules::sources_at(&overrides, &sioul_core::quiet::Blocks::default(), &now);
            let state = rules::now(&config.dnd, &sources, press.as_ref(), stamp);
            let mode = sioul_core::quiet::mode(&config.week_hours(), &config.time_off, &overrides, &sioul_core::quiet::Blocks::default(), &now);
            Look { config, overrides, switch: Switch::default(), state, mode, now }
        };
        let at = jiff::Timestamp::now().as_millisecond();
        let reach = rules::Press { at: at - 1_000, on: false, until: at + 3_600_000, from: "x".into(), via: String::new(), state: rules::State::Reachable, open: false, held_off: 0, gone: false };
        let said = moment_of(&look(Some(reach.clone()), false));
        assert_eq!((said["state"].as_str(), said["paused"].as_bool()), (Some("reachable"), Some(false)), "{said}");
        let line = said["reachable"]["line"].as_str().unwrap_or_default();
        assert!(!line.is_empty() && !line.starts_with("reach-"), "{said}");
        assert_eq!(said["reachable"]["until_at"], (at + 3_600_000) / 1000);
        let open = moment_of(&look(Some(rules::Press { open: true, ..reach.clone() }), false));
        assert_eq!(open["reachable"]["open"], true);
        assert_ne!(open["reachable"]["line"], said["reachable"]["line"], "until you turn it off: said so");
        let dnd = rules::Press { state: rules::State::Dnd, on: true, until: 0, ..reach.clone() };
        assert_eq!(moment_of(&look(Some(dnd), false))["state"], "dnd");
        assert_eq!(moment_of(&look(None, false))["state"], "usual");
        // Past its end: as usual.
        let over = rules::Press { until: at - 500, ..reach.clone() };
        assert_eq!(moment_of(&look(Some(over), false))["state"], "usual");
        // During a pause: no Reachable, and the moment says paused (the menu offers none of its lengths).
        let paused = moment_of(&look(Some(reach), true));
        assert!(paused["reachable"].is_null() && paused["paused"] == true, "{paused}");
    }

    fn device(pressed: i64, state: rules::State, until: i64, seen: i64) -> rules::Device {
        rules::Device { kind: "computer".into(), pressed, on: state == rules::State::Dnd, mode: state.id().into(), until, seen, at: pressed, ..rules::Device::default() }
    }

    fn switch_saved(devices: &[(&str, rules::Device)]) {
        let switch = Switch { device: devices.iter().map(|(id, d)| (id.to_string(), d.clone())).collect(), ..Switch::default() };
        switch.save(&Switch::default_path()).unwrap();
    }

    /// Review of part 3, F1 and F7, in the files: the phone's Do not disturb
    /// until turned off three days ago, the old laptop's As usual two days
    /// ago having seen it, the old laptop gone from the sharing: off, in the
    /// window and in the files' reading (`sioul remind --watch`, `sioul
    /// watch`) alike; a gone device's own Do not disturb holds in neither; a
    /// pause pressed after Reachable ends it in the files' reading too, so
    /// that the focus session begun before holds again there.
    #[test]
    fn every_reading_reads_a_gone_device_and_a_pause_alike() {
        let _files = FILES.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
        files_cleared();
        const DAY: i64 = 86_400_000;
        let ms = jiff::Timestamp::now().as_millisecond();
        std::fs::create_dir_all(rules::gone_path().parent().unwrap()).unwrap();
        std::fs::write(rules::gone_path(), r#"["old-laptop"]"#).unwrap();
        switch_saved(&[("phone-1", device(ms - 3 * DAY, rules::State::Dnd, 0, 0)), ("old-laptop", device(ms - 2 * DAY, rules::State::Usual, 0, ms - 3 * DAY))]);
        let mut config = Config::default();
        config.dnd.focus = true;
        assert!(!now().on(), "the window: the Do not disturb it ended does not come back");
        assert!(!sioul_core::attention::dnd_from_files(&config, ms / 1000), "the files' reading too");
        switch_saved(&[("old-laptop", device(ms - 60_000, rules::State::Dnd, 0, 0))]);
        assert!(!now().on() && !sioul_core::attention::dnd_from_files(&config, ms / 1000), "a gone device's Do not disturb holds nowhere");
        // A focus session since an hour; Reachable for an hour ten minutes ago; a pause from five to two minutes ago.
        let _ = std::fs::remove_file(rules::gone_path());
        let running = sioul_core::timelog::Running { task: String::new(), start: ms / 1000 - 3600, planned: 120, paused_at: None, paused: 0 };
        sioul_core::timelog::keep_running_in(&sioul_core::timelog::folder(), Some(&running)).unwrap();
        switch_saved(&[("laptop-1", device(ms - 600_000, rules::State::Reachable, ms + 3_000_000, 0))]);
        assert!(!sioul_core::attention::dnd_from_files(&config, ms / 1000), "Reachable holds the session off");
        let overrides = Overrides { paused_since: Some(ms / 1000 - 300), paused_ended: Some(ms / 1000 - 120), ..Overrides::default() };
        overrides.save(&Overrides::default_path()).unwrap();
        assert!(sioul_core::attention::dnd_from_files(&config, ms / 1000), "the pause ended Reachable: the session holds again there too");
        assert!(now().reachable.is_none());
        sioul_core::timelog::keep_running_in(&sioul_core::timelog::folder(), None).unwrap();
        files_cleared();
    }

    /// Re-check of part 3, R-5: Reachable pressed after a gone device's As
    /// usual carries nothing of it, as the readers read that As usual.
    #[test]
    fn reachable_pressed_after_a_gone_device_s_as_usual_carries_nothing() {
        let _files = FILES.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
        files_cleared();
        let ms = jiff::Timestamp::now().as_millisecond();
        std::fs::create_dir_all(rules::gone_path().parent().unwrap()).unwrap();
        std::fs::write(rules::gone_path(), r#"["old-laptop"]"#).unwrap();
        switch_saved(&[("old-laptop", device(ms - 600_000, rules::State::Usual, 0, 0))]);
        press_state(rules::State::Reachable, Some(ms / 1000 + 3600), false).unwrap();
        let switch = Switch::load(&Switch::default_path());
        assert_eq!(switch.device[&here_id()].held_off, 0);
        files_cleared();
    }

    /// Review of part 3, F4: Reachable read anew as soon as its files
    /// change, never kept by time alone: As usual pressed elsewhere counts
    /// at once.
    #[test]
    fn reachable_is_read_anew_when_the_switch_changes() {
        let _files = FILES.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
        files_cleared();
        let ms = jiff::Timestamp::now().as_millisecond();
        switch_saved(&[("laptop-1", device(ms - 5_000, rules::State::Reachable, ms + 3_600_000, 0))]);
        assert!(reachable().is_some());
        switch_saved(&[("laptop-1", device(ms - 1_000, rules::State::Usual, 0, ms - 5_000))]);
        assert!(reachable().is_none(), "As usual came: read at once");
        files_cleared();
    }

    /// Review of part 3, F6: with "[dnd] pauses = false" a pause adds no
    /// do-not-disturb reason, yet the moment says paused (the menu then
    /// offers none of Reachable's lengths, nor the computer's release), by
    /// the pause itself.
    #[test]
    fn the_moment_says_a_pause_whatever_do_not_disturb_says_of_pauses() {
        let mut config = Config::default();
        config.dnd.pauses = false;
        let now = Zoned::now();
        let stamp = now.timestamp().as_second();
        let overrides = Overrides { paused_since: Some(stamp - 300), ..Overrides::default() };
        let state = rules::now(&config.dnd, &rules::sources_at(&overrides, &sioul_core::quiet::Blocks::default(), &now), None, stamp);
        assert!(!state.has(Why::Paused));
        let mode = sioul_core::quiet::mode(&config.week_hours(), &config.time_off, &overrides, &sioul_core::quiet::Blocks::default(), &now);
        let look = Look { config, overrides, switch: Switch::default(), state, mode, now };
        assert_eq!(moment_of(&look)["paused"], true);
    }

    #[test]
    fn the_phone_says_who_on_the_list_is_not_starred_there() {
        let mut people = People::default();
        for (name, phone) in [("Alice", "+262639980001"), ("Bob", "+262639980002"), ("Carol", "+262639980003"), ("Dan", "")] {
            people.add(Person { name: name.into(), phones: if phone.is_empty() { Vec::new() } else { vec![phone.into()] }, emails: vec![format!("{name}@example.org")], ..Person::default() }, None);
        }
        let id = |name: &str| people.people.iter().find(|p| p.name == name).unwrap().id.clone();
        let answer = serde_json::json!({ "permission": true, "people": [
            { "id": id("Alice"), "state": "starred", "contact": "" },
            { "id": id("Bob"), "state": "not-starred", "contact": "content://com.android.contacts/contacts/lookup/x/1" },
            { "id": id("Carol"), "state": "unknown", "contact": "" },
        ] });
        let en = sioul_core::i18n::Translator::new("en");
        let said = stars_of(&people, &answer, &en);
        assert_eq!(said["missing"], 2);
        assert_eq!(said["summary"], "Two people on your list are not starred on this phone.");
        let states: Vec<&str> = said["people"].as_array().unwrap().iter().map(|p| p["state"].as_str().unwrap()).collect();
        assert_eq!(states, ["starred", "not-starred", "unknown", "no-number"]);
        assert_eq!(said["people"][1]["contact"], "content://com.android.contacts/contacts/lookup/x/1");
        // Everyone starred, or no permission: said so.
        let all = serde_json::json!({ "permission": true, "people": [{ "id": id("Alice"), "state": "starred" }, { "id": id("Bob"), "state": "starred" }, { "id": id("Carol"), "state": "starred" }] });
        assert_eq!(stars_of(&people, &all, &en)["summary"], "Everyone on your list with a number is starred on this phone: their calls and messages ring during do-not-disturb.");
        let refused = stars_of(&people, &serde_json::json!({ "permission": false }), &en);
        assert_eq!(refused["permission"], false);
        assert!(refused["summary"].as_str().unwrap().contains("read your contacts"));
    }
}