sioul_sync/

mailbox.rs

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

//! An account's folders, and what you do to its messages.
//!
//! Sioul writes to the server only when you act: a flag with `UID STORE`, a
//! move with `UID MOVE` (RFC 6851), else a copy, a deletion flag and `UID
//! EXPUNGE` (RFC 4315). The local copy follows: a flag renames its file; a
//! moved message leaves this folder, and the next sync brings it into the other.
//! Changes made elsewhere (read on the phone, deleted in the webmail) come back
//! at each sync (`reconcile`).

use crate::{SyncError, said};
use crate::imap::{self, COMMAND, Imap, Server};
use async_imap::types::NameAttribute;
use futures_util::StreamExt;
use sioul_core::card::ImapOrigin;
use sioul_core::config::{Account, state_dir};
use sioul_core::folders::{self, Folder, Role};
use sioul_core::maildir;
use sioul_core::spam::labels;
use std::collections::{BTreeMap, BTreeSet};
use std::path::{Path, PathBuf};

/// The folders the server lists, with what each is for. Gmail's "All Mail",
/// "Starred" and "Important" are views of the same messages: the first is kept
/// to archive into, the other two are left out (RFC 6154, RFC 8457).
pub async fn list(session: &mut Imap) -> Result<Vec<Folder>, SyncError> {
    let mut found = Vec::new();
    let mut names = imap::within(COMMAND, session.list(Some(""), Some("*"))).await?.map_err(imap::server)?;
    while let Some(name) = names.next().await {
        let name = name.map_err(imap::server)?;
        let attributes = name.attributes();
        if attributes.iter().any(|a| matches!(a, NameAttribute::NoSelect)) {
            continue;
        }
        let special = attributes.iter().find_map(|a| match a {
            NameAttribute::Sent => Some(Role::Sent),
            NameAttribute::Drafts => Some(Role::Drafts),
            NameAttribute::Junk => Some(Role::Junk),
            NameAttribute::Trash => Some(Role::Trash),
            NameAttribute::Archive => Some(Role::Archive),
            NameAttribute::All => Some(Role::All),
            NameAttribute::Flagged => Some(Role::Other),
            _ => None,
        });
        let view = attributes.iter().any(|a| match a {
            NameAttribute::Flagged => true,
            NameAttribute::Extension(name) => name.eq_ignore_ascii_case("\\Important"),
            _ => false,
        });
        if view {
            continue;
        }
        found.push(folders::folder(name.name(), name.delimiter(), special));
    }
    drop(names);
    found.sort_by(|a, b| (a.role, a.display.to_lowercase()).cmp(&(b.role, b.display.to_lowercase())));
    Ok(found)
}

/// Whether a folder is fetched: everything but views of other folders, except
/// where "All Mail" is the only archive there is (Gmail): it is fetched then,
/// and shown as the archive, without what the inbox and Sent already show.
/// Folders you chose not to keep stay on the server; the inbox is always kept.
/// A folder whose name would make it the Maildir itself or the folder above
/// ("INBOX." or "INBOX.." with "." between levels) is not fetched.
pub(crate) fn fetched(folder: &Folder, all: &[Folder], account: &Account) -> bool {
    (folder.role != Role::All || !all.iter().any(|f| f.role == Role::Archive))
        && (folder.role == Role::Inbox || (!account.skip_folders.contains(&folder.name) && own_dir(account, folder).is_some()))
}

/// A folder's own directory in the account's Maildir: one name in it, never
/// the Maildir itself nor what is above it, whatever the server named the folder.
pub(crate) fn own_dir(account: &Account, folder: &Folder) -> Option<PathBuf> {
    let mut parts = Path::new(&folder.local).components();
    match (parts.next(), parts.next()) {
        (Some(std::path::Component::Normal(_)), None) => Some(account.maildir_path().join(&folder.local)),
        _ => None,
    }
}

/// Makes a folder on the server (RFC 9051 §6.3.4), then lists them again.
/// The name you typed goes in modified UTF-7, as servers read folder names
/// ("Reçus" is "Re&AOc-us", RFC 3501 §5.1.3), the way they are listed back.
pub fn create_folder(account: &Account, password: &str, name: &str) -> Result<(), SyncError> {
    let name = name.trim();
    if name.is_empty() {
        return Err(SyncError::Said(said::FOLDER_NAME, String::new()));
    }
    let name = folders::encode_utf7(name);
    let server = Server::of(account)?;
    crate::fetch::block_on(async {
        let mut session = imap::open(&server, password).await?;
        let made = imap::within(COMMAND, session.create(&name)).await?.map_err(imap::server);
        let listed = list(&mut session).await;
        let _ = session.logout().await;
        made?;
        save(&account.id, &listed?)
    })
}

/// The folder still holds messages: said by the window in your language.
pub const NOT_EMPTY: &str = "not-empty";

/// Takes a folder off the server (RFC 9051 §6.3.5): only an empty one, and
/// never one with a purpose (the inbox, Sent, Drafts, the trash, junk, the
/// archive), so no message is ever lost this way.
pub fn delete_folder(account: &Account, password: &str, name: &str) -> Result<(), SyncError> {
    let folder = folders(&account.id).into_iter().find(|f| f.name == name).ok_or_else(|| SyncError::Said(said::NO_FOLDER, name.to_string()))?;
    if folder.role != Role::Other {
        return Err(SyncError::Said(said::PURPOSE, folder.display.clone()));
    }
    let server = Server::of(account)?;
    crate::fetch::block_on(async {
        let mut session = imap::open(&server, password).await?;
        let status = imap::within(COMMAND, session.status(name, "(MESSAGES)")).await?.map_err(imap::server)?;
        if status.exists > 0 {
            let _ = session.logout().await;
            return Err(SyncError::Message(NOT_EMPTY.into()));
        }
        let deleted = imap::within(COMMAND, session.delete(name)).await?.map_err(imap::server);
        let listed = list(&mut session).await;
        let _ = session.logout().await;
        deleted?;
        save(&account.id, &listed?)
    })?;
    // Its empty copy here goes too, and where its sync stopped.
    if let Some(dir) = own_dir(account, &folder) {
        let _ = std::fs::remove_dir_all(dir);
    }
    crate::fetch::forget_folder_state(account, name)
}

/// A folder no longer kept here: its copy goes (the server keeps it all), and
/// where its sync stopped is forgotten, so keeping it again brings it back whole.
pub fn forget_folder(account: &Account, name: &str) -> Result<(), SyncError> {
    if let Some(root) = folders(&account.id).into_iter().find(|f| f.name == name && f.role != Role::Inbox).and_then(|f| own_dir(account, &f)) {
        for sub in ["cur", "new"] {
            for entry in std::fs::read_dir(root.join(sub)).into_iter().flatten().filter_map(Result::ok) {
                let _ = std::fs::remove_file(entry.path());
            }
        }
    }
    crate::fetch::forget_folder_state(account, name)
}

fn folders_path(account: &str) -> PathBuf {
    folders::saved_path(account)
}

#[derive(serde::Serialize, serde::Deserialize, Default)]
struct Saved {
    #[serde(default, rename = "folder")]
    folders: Vec<Folder>,
}

/// Keeps the list for the window and for actions, which need to know where the trash is.
pub(crate) fn save(account: &str, list: &[Folder]) -> Result<(), SyncError> {
    let path = folders_path(account);
    let fail = |e: std::io::Error| SyncError::Disk(format!("{}: {e}", path.display()));
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent).map_err(fail)?;
    }
    let text = toml::to_string(&Saved { folders: list.to_vec() }).map_err(|e| SyncError::Disk(e.to_string()))?;
    std::fs::write(&path, text).map_err(fail)
}

/// The account's folders as last listed: the inbox alone before the first sync.
pub fn folders(account: &str) -> Vec<Folder> {
    let saved = folders::saved(account);
    if saved.is_empty() { vec![folders::folder("INBOX", None, None)] } else { saved }
}

/// The folder a stored message belongs to, from where its file is.
pub fn folder_of(account: &Account, file: &Path) -> Option<Folder> {
    let directory = file.parent()?.parent()?;
    let root = account.maildir_path();
    let all = folders(&account.id);
    if let Some(folder) = all.iter().find(|f| root.join(&f.local) == directory) {
        return Some(folder.clone());
    }
    // Each path as the system resolves it, where a folder sits behind a link (as `Config::account_of`).
    let directory = std::fs::canonicalize(directory).ok()?;
    all.into_iter().find(|f| std::fs::canonicalize(root.join(&f.local)).is_ok_and(|d| d == directory))
}

/// Brings back what changed on the server since the last sync, for the
/// messages kept here: their flags, and those deleted or moved elsewhere,
/// whose local copies go. The folder must be open (`EXAMINE` or `SELECT`).
pub(crate) async fn reconcile(session: &mut Imap, root: &Path, validity: u32) -> Result<(), SyncError> {
    let local = local_files(root);
    let uids: BTreeSet<u32> = local.iter().filter(|(o, _)| o.validity == validity).map(|(o, _)| o.uid).collect();
    if uids.is_empty() {
        return Ok(());
    }
    let mut server: BTreeMap<u32, String> = BTreeMap::new();
    {
        let mut fetches = imap::within(COMMAND, session.uid_fetch(ranges(&uids), "(UID FLAGS)")).await?.map_err(imap::server)?;
        while let Some(fetch) = fetches.next().await {
            let fetch = fetch.map_err(imap::server)?;
            if let Some(uid) = fetch.uid {
                server.insert(uid, crate::fetch::maildir_flags(fetch.flags()));
            }
        }
    }
    for (origin, path) in local.into_iter().filter(|(o, _)| o.validity == validity) {
        match server.get(&origin.uid) {
            None => {
                let _ = std::fs::remove_file(&path);
            }
            Some(flags) if sorted(flags) != sorted(&maildir::flags_of(&path)) => {
                let _ = maildir::set_flags(&path, flags);
            }
            Some(_) => {}
        }
    }
    Ok(())
}

fn sorted(flags: &str) -> String {
    let mut letters: Vec<char> = flags.chars().collect();
    letters.sort_unstable();
    letters.dedup();
    letters.into_iter().collect()
}

/// The stored messages of a Maildir folder, with where each sits on the server.
fn local_files(root: &Path) -> Vec<(ImapOrigin, PathBuf)> {
    ["new", "cur"]
        .iter()
        .filter_map(|sub| std::fs::read_dir(root.join(sub)).ok())
        .flatten()
        .filter_map(Result::ok)
        .map(|e| e.path())
        .filter_map(|p| Some((maildir::origin_of(&p)?, p)))
        .collect()
}

/// "1:5,7,9:12": a UID set as short as it gets.
pub(crate) fn ranges(uids: &BTreeSet<u32>) -> String {
    let mut parts: Vec<String> = Vec::new();
    let mut iter = uids.iter().copied().peekable();
    while let Some(start) = iter.next() {
        let mut end = start;
        while iter.peek() == Some(&(end + 1)) {
            end += 1;
            iter.next();
        }
        parts.push(if start == end { start.to_string() } else { format!("{start}:{end}") });
    }
    parts.join(",")
}

/// What you do to a message.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Action {
    /// Read (true) or unread (false).
    Read(bool),
    /// Flagged to follow up, or not.
    Flag(bool),
    /// Into another folder, by its server name.
    Move(String),
    /// To the trash; from the trash, gone for good.
    Trash,
    /// To the junk folder, marked `$Junk` for the server's filter to learn.
    Junk,
    /// Out of the inbox, into the archive (Gmail: into "All Mail").
    Archive,
    /// Out of the junk folder, back into the inbox, marked `$NotJunk`.
    NotJunk,
    /// Not spam, said of mail set aside as spam or flagged by your own
    /// filter: marked `$NotJunk` (and no longer `$Junk`), it stays where it
    /// is, and the Porch puts it back in its lane.
    NotSpam,
    /// Into the account's Junk folder by your own spam filter (the matrix's
    /// "Move to spam", for a message of this class): no keyword set, no line
    /// in the label log, which is yours alone; the move goes into this
    /// device's log of what the filter moved (`spam::labels::Moved`), which
    /// the Porch's lane of its catches and the training read (in the Junk
    /// folder, learned as spam until you say otherwise).
    Filtered(sioul_core::spam::Class),
}

/// Does `action` to the message stored at `file`, on the server, then here.
/// What it says of the message, junk or not, goes into this device's label
/// log (`spam::labels`) once the server has taken it; what your own filter
/// moved, into this device's log of its moves.
pub fn act(account: &Account, password: &str, file: &Path, action: &Action) -> Result<(), SyncError> {
    let server = Server::of(account)?;
    let origin = maildir::origin_of(file).ok_or_else(|| SyncError::Said(said::NOT_FETCHED, String::new()))?;
    let folder = folder_of(account, file).ok_or_else(|| SyncError::Said(said::UNKNOWN_FOLDER, String::new()))?;
    if *action == Action::Archive && matches!(folder.role, Role::Archive | Role::All) {
        return Ok(());
    }
    // Already in a Junk folder: nothing for the filter to move.
    if matches!(action, Action::Filtered(_)) && folder.role == Role::Junk {
        return Ok(());
    }
    // Read here before the message leaves this folder; written once the server took the act.
    let label = said(action).and_then(|source| labels::Entry::of_file(&account.id, &folder.name, file, source));
    let moved = match action {
        Action::Filtered(class) => labels::Moved::of_file(&account.id, &folder.name, file, *class),
        _ => None,
    };
    crate::fetch::block_on(async {
        let mut session = imap::open(&server, password).await?;
        let result = act_in(&mut session, account, &folder, origin, action).await;
        let _ = session.logout().await;
        result
    })?;
    // Done on the server: a log that cannot be written is said, after the rest is done here.
    let root = labels::state();
    let logged = match (&label, &moved) {
        (Some(label), _) => labels::append_to(&labels::own_log(&root, &device()), label),
        (_, Some(moved)) => labels::append_to(&labels::own_moved_log(&root, &device()), moved),
        _ => Ok(()),
    }
    .map_err(SyncError::Disk);
    // A sync may have renamed the file meanwhile; gone, there is nothing left to do here.
    let Some(file) = maildir::locate(file) else { return logged };
    match kept_with(action, &maildir::flags_of(&file), folder.role) {
        Some(flags) => {
            maildir::set_flags(&file, &flags).map_err(|e| SyncError::Disk(e.to_string()))?;
        }
        None => {
            let _ = std::fs::remove_file(&file);
        }
    }
    logged
}

/// What becomes of the local copy once the server took `action` on it in a
/// folder of `role`: its letters now, or none when it left this folder (the
/// next sync brings the copy into the other). Said not spam, it keeps its
/// keyword here as on the server; said spam in a Junk folder, it stays there.
fn kept_with(action: &Action, flags: &str, role: Role) -> Option<String> {
    match action {
        Action::Read(read) => Some(if *read { format!("{flags}S") } else { flags.replace('S', "") }),
        Action::Flag(flag) => Some(if *flag { format!("{flags}F") } else { flags.replace('F', "") }),
        Action::NotSpam => Some(format!("{}{}", flags.replace(maildir::JUNK, ""), maildir::NOT_JUNK)),
        Action::Junk if role == Role::Junk => Some(format!("{}{}", flags.replace(maildir::NOT_JUNK, "").replace(maildir::JUNK, ""), maildir::JUNK)),
        Action::Move(_) | Action::Trash | Action::Junk | Action::Archive | Action::NotJunk | Action::Filtered(_) => None,
    }
}

/// This device's name in the sharing (a UUID made once, `share::Here`): its
/// label log and its logs of what the filter moved or flagged are its own files.
fn device() -> String {
    crate::share::Here::load(&state_dir()).id
}

/// Writes into the spam filter's label log what you said of the message
/// stored at `file`, without acting on it there: a sender blocked from it.
pub fn label(account: &Account, file: &Path, source: labels::Source) -> Result<(), SyncError> {
    let folder = folder_of(account, file).ok_or_else(|| SyncError::Said(said::UNKNOWN_FOLDER, String::new()))?;
    let entry = labels::Entry::of_file(&account.id, &folder.name, file, source).ok_or_else(|| SyncError::Said(said::NOT_FETCHED, String::new()))?;
    labels::append_to(&labels::own_log(&labels::state(), &device()), &entry).map_err(SyncError::Disk)
}

/// Writes into this device's log of what your own filter flagged where it
/// is (`spam::labels::Flagged`) the message stored at `file`, judged
/// `class`, as it arrived: nothing changes on the server nor here. The
/// training learns from it as it is until you say otherwise: a probable spam
/// as spam, a maybe spam not at all.
pub fn flagged(account: &Account, file: &Path, class: sioul_core::spam::Class) -> Result<(), SyncError> {
    let folder = folder_of(account, file).ok_or_else(|| SyncError::Said(said::UNKNOWN_FOLDER, String::new()))?;
    let flag = labels::Flagged::of_file(&account.id, &folder.name, file, class).ok_or_else(|| SyncError::Said(said::NOT_FETCHED, String::new()))?;
    labels::append_to(&labels::own_flagged_log(&labels::state(), &device()), &flag).map_err(SyncError::Disk)
}

/// What an act says of a message, for the label log: none for those that
/// say nothing of spam, nor for your own filter's move (its own log's).
fn said(action: &Action) -> Option<labels::Source> {
    match action {
        Action::Junk => Some(labels::Source::Junk),
        Action::NotJunk => Some(labels::Source::NotJunk),
        Action::NotSpam => Some(labels::Source::NotSpam),
        Action::Read(_) | Action::Flag(_) | Action::Move(_) | Action::Trash | Action::Archive | Action::Filtered(_) => None,
    }
}

/// Moves the message stored at `file` into `folder` of another account: a
/// copy is appended there, its flags kept, and only once that server has it
/// is the original taken off the first one. Nothing is lost on the way: if the
/// copy fails, the original stays; if removing the original fails, both remain.
pub fn move_across(from: &Account, from_password: &str, file: &Path, to: &Account, to_password: &str, folder: &str) -> Result<(), SyncError> {
    let raw = std::fs::read(file).map_err(|e| SyncError::Disk(format!("{}: {e}", file.display())))?;
    let origin = maildir::origin_of(file).ok_or_else(|| SyncError::Said(said::NOT_FETCHED, String::new()))?;
    let source = folder_of(from, file).ok_or_else(|| SyncError::Said(said::UNKNOWN_FOLDER, String::new()))?;
    append_then_remove(from, from_password, &source, origin, &raw, &maildir::flags_of(file), to, to_password, folder)?;
    if let Some(file) = maildir::locate(file) {
        let _ = std::fs::remove_file(&file);
    }
    Ok(())
}

/// The same for a message seen on its server only (a search's): read whole
/// from its folder first, its flags with it, then copied and taken off.
pub fn move_across_from_server(from: &Account, from_password: &str, source: &str, origin: ImapOrigin, to: &Account, to_password: &str, folder: &str) -> Result<(), SyncError> {
    let source = folders(&from.id).into_iter().find(|f| f.name == source).unwrap_or_else(|| folders::folder(source, None, None));
    let server = Server::of(from)?;
    let (raw, flags) = crate::fetch::block_on(async {
        let mut session = imap::open(&server, from_password).await?;
        let result = read_whole(&mut session, &source, origin).await;
        let _ = session.logout().await;
        result
    })?;
    append_then_remove(from, from_password, &source, origin, &raw, &flags, to, to_password, folder)
}

/// A message of `folder`, whole, with its flags as Maildir letters.
async fn read_whole(session: &mut Imap, folder: &Folder, origin: ImapOrigin) -> Result<(Vec<u8>, String), SyncError> {
    let examined = imap::within(COMMAND, session.examine(&folder.name)).await?.map_err(imap::server)?;
    if examined.uid_validity.unwrap_or(0) != origin.validity {
        return Err(SyncError::Said(said::RENUMBERED, String::new()));
    }
    let mut fetches = imap::within(COMMAND, session.uid_fetch(origin.uid.to_string(), "(UID FLAGS BODY.PEEK[])")).await?.map_err(imap::server)?;
    let mut found = None;
    while let Some(fetch) = fetches.next().await {
        let fetch = fetch.map_err(imap::server)?;
        if fetch.uid == Some(origin.uid)
            && let Some(body) = fetch.body()
        {
            found = Some((body.to_vec(), crate::fetch::maildir_flags(fetch.flags())));
        }
    }
    found.ok_or_else(|| SyncError::Said(said::GONE, String::new()))
}

/// Copies `raw` into `folder` of `to`, its flags kept (Maildir letters), and
/// only once that server has it takes the original off `source` of `from`.
#[allow(clippy::too_many_arguments)]
fn append_then_remove(from: &Account, from_password: &str, source: &Folder, origin: ImapOrigin, raw: &[u8], letters: &str, to: &Account, to_password: &str, folder: &str) -> Result<(), SyncError> {
    let flags: Vec<&str> = [('S', "\\Seen"), ('F', "\\Flagged"), ('R', "\\Answered")].into_iter().filter(|(c, _)| letters.contains(*c)).map(|(_, f)| f).collect();
    let flags = format!("({})", flags.join(" "));
    let target = Server::of(to)?;
    crate::fetch::block_on(async {
        let mut session = imap::open(&target, to_password).await?;
        let result = imap::within(COMMAND, session.append(folder, Some(&flags), None, raw)).await?.map_err(imap::server);
        let _ = session.logout().await;
        result
    })?;
    let server = Server::of(from)?;
    crate::fetch::block_on(async {
        let mut session = imap::open(&server, from_password).await?;
        let result = remove_in(&mut session, source, origin).await;
        let _ = session.logout().await;
        result
    })
}

/// UIDs per command, at most: a long set stays well under the line servers take.
const SET: usize = 200;

/// The same act on several messages of one account, in one connection: a
/// UID set per folder (RFC 9051 §6.4.9). `files` are kept here; `remote` are
/// seen on the server only (a search's), by their folder's server name. For
/// acts that say nothing of spam (reading, flags, moves, archiving, the
/// trash); the others go one at a time through `act`, for the spam filter's
/// logs. The local copies follow as with `act`. A folder that fails is said
/// (the first problem), the others are still done.
pub fn act_many(account: &Account, password: &str, files: &[PathBuf], remote: &[(String, ImapOrigin)], action: &Action) -> Result<(), SyncError> {
    if said(action).is_some() || matches!(action, Action::Filtered(_)) {
        let mut first = None;
        for file in files {
            if let Err(e) = act(account, password, file, action) {
                first.get_or_insert(e);
            }
        }
        if !remote.is_empty() {
            first.get_or_insert(SyncError::Said(said::OPEN_FIRST, String::new()));
        }
        return first.map_or(Ok(()), Err);
    }
    let known = folders(&account.id);
    // By folder, then UIDVALIDITY: the UIDs, and the files that follow.
    let mut groups: BTreeMap<String, (Folder, BTreeMap<u32, (BTreeSet<u32>, Vec<PathBuf>)>)> = BTreeMap::new();
    let mut add = |folder: Folder, origin: ImapOrigin, file: Option<&PathBuf>| {
        let entry = groups.entry(folder.name.clone()).or_insert_with(|| (folder, BTreeMap::new()));
        let (uids, files) = entry.1.entry(origin.validity).or_default();
        uids.insert(origin.uid);
        files.extend(file.cloned());
    };
    let mut first: Option<SyncError> = None;
    for file in files {
        match (maildir::origin_of(file), folder_of(account, file)) {
            (Some(origin), Some(folder)) => add(folder, origin, Some(file)),
            _ => {
                first.get_or_insert(SyncError::Said(said::NOT_FETCHED, String::new()));
            }
        }
    }
    for (name, origin) in remote {
        let folder = known.iter().find(|f| f.name == *name).cloned().unwrap_or_else(|| folders::folder(name, None, None));
        add(folder, *origin, None);
    }
    // Archived already: nothing to do (as `act`).
    groups.retain(|_, (folder, _)| !(*action == Action::Archive && matches!(folder.role, Role::Archive | Role::All)));
    if groups.is_empty() {
        return first.map_or(Ok(()), Err);
    }
    let server = Server::of(account)?;
    let done: Vec<(Role, Vec<PathBuf>)> = crate::fetch::block_on(async {
        let mut session = imap::open(&server, password).await?;
        let mut done = Vec::new();
        for (folder, by_validity) in groups.values() {
            for (validity, (uids, files)) in by_validity {
                let uids: Vec<u32> = uids.iter().copied().collect();
                let mut all_done = true;
                for chunk in uids.chunks(SET) {
                    let set = ranges(&chunk.iter().copied().collect::<BTreeSet<u32>>());
                    if let Err(e) = act_set(&mut session, account, folder, *validity, &set, action).await {
                        all_done = false;
                        first.get_or_insert(e);
                        break;
                    }
                }
                if all_done {
                    done.push((folder.role, files.clone()));
                }
            }
        }
        let _ = session.logout().await;
        Ok(done)
    })?;
    // Done on the server: the copies here follow.
    for (role, files) in done {
        for file in files.iter().filter_map(|f| maildir::locate(f)) {
            match kept_with(action, &maildir::flags_of(&file), role) {
                Some(flags) => {
                    let _ = maildir::set_flags(&file, &flags);
                }
                None => {
                    let _ = std::fs::remove_file(&file);
                }
            }
        }
    }
    first.map_or(Ok(()), Err)
}

/// Takes a message off its folder for good: marked deleted, then expunged.
async fn remove_in(session: &mut Imap, folder: &Folder, origin: ImapOrigin) -> Result<(), SyncError> {
    let selected = imap::within(COMMAND, session.select(&folder.name)).await?.map_err(imap::server)?;
    if selected.uid_validity.unwrap_or(0) != origin.validity {
        return Err(SyncError::Said(said::RENUMBERED, String::new()));
    }
    let uid = origin.uid.to_string();
    let capabilities = imap::within(COMMAND, session.capabilities()).await?.map_err(imap::server)?;
    store(session, &uid, "+FLAGS.SILENT (\\Deleted)").await?;
    expunge(session, &uid, capabilities.has_str("UIDPLUS")).await
}

async fn act_in(session: &mut Imap, account: &Account, folder: &Folder, origin: ImapOrigin, action: &Action) -> Result<(), SyncError> {
    act_set(session, account, folder, origin.validity, &origin.uid.to_string(), action).await
}

/// `action` on the messages of `uid`, a UID or a set of them ("4,7:9"), in
/// `folder`, whose UIDVALIDITY must still be `validity`.
async fn act_set(session: &mut Imap, account: &Account, folder: &Folder, validity: u32, uid: &str, action: &Action) -> Result<(), SyncError> {
    let selected = imap::within(COMMAND, session.select(&folder.name)).await?.map_err(imap::server)?;
    if selected.uid_validity.unwrap_or(0) != validity {
        return Err(SyncError::Said(said::RENUMBERED, String::new()));
    }
    let capabilities = imap::within(COMMAND, session.capabilities()).await?.map_err(imap::server)?;
    let (can_move, uidplus) = (capabilities.has_str("MOVE"), capabilities.has_str("UIDPLUS"));
    match action {
        Action::Read(read) => store(session, uid, if *read { "+FLAGS.SILENT (\\Seen)" } else { "-FLAGS.SILENT (\\Seen)" }).await,
        Action::Flag(flag) => store(session, uid, if *flag { "+FLAGS.SILENT (\\Flagged)" } else { "-FLAGS.SILENT (\\Flagged)" }).await,
        Action::Move(target) => move_to(session, uid, target, can_move, uidplus).await,
        Action::Trash if folder.role == Role::Trash => {
            store(session, uid, "+FLAGS.SILENT (\\Deleted)").await?;
            expunge(session, uid, uidplus).await
        }
        Action::Trash => {
            let target = role_folder(session, account, Role::Trash, "Trash").await?;
            move_to(session, uid, &target, can_move, uidplus).await
        }
        Action::Junk => {
            // Keywords are optional: a server without them still takes the move.
            let _ = store(session, uid, "-FLAGS.SILENT ($NotJunk)").await;
            let _ = store(session, uid, "+FLAGS.SILENT ($Junk)").await;
            // Said spam in a Junk folder already (the review queue's "Spam" on what your filter moved): it stays.
            if folder.role == Role::Junk {
                return Ok(());
            }
            let target = role_folder(session, account, Role::Junk, "Junk").await?;
            move_to(session, uid, &target, can_move, uidplus).await
        }
        // Your own filter's move: no keyword, as nobody said anything yet.
        Action::Filtered(_) => {
            let target = role_folder(session, account, Role::Junk, "Junk").await?;
            move_to(session, uid, &target, can_move, uidplus).await
        }
        Action::Archive => {
            let known = folders(&account.id);
            let target = match folders::preferred(&known, Role::Archive).or(folders::preferred(&known, Role::All)) {
                Some(f) => f.name.clone(),
                None => role_folder(session, account, Role::Archive, "Archive").await?,
            };
            move_to(session, uid, &target, can_move, uidplus).await
        }
        Action::NotJunk => {
            let _ = store(session, uid, "-FLAGS.SILENT ($Junk)").await;
            let _ = store(session, uid, "+FLAGS.SILENT ($NotJunk)").await;
            move_to(session, uid, "INBOX", can_move, uidplus).await
        }
        // A server without keywords keeps nothing: the label log then says it, on this device.
        Action::NotSpam => {
            let _ = store(session, uid, "-FLAGS.SILENT ($Junk)").await;
            let _ = store(session, uid, "+FLAGS.SILENT ($NotJunk)").await;
            Ok(())
        }
    }
}

pub(crate) async fn store(session: &mut Imap, uid: &str, query: &str) -> Result<(), SyncError> {
    let mut answers = imap::within(COMMAND, session.uid_store(uid, query)).await?.map_err(imap::server)?;
    while let Some(answer) = answers.next().await {
        answer.map_err(imap::server)?;
    }
    Ok(())
}

pub(crate) async fn move_to(session: &mut Imap, uid: &str, target: &str, can_move: bool, uidplus: bool) -> Result<(), SyncError> {
    if can_move {
        return imap::within(COMMAND, session.uid_mv(uid, target)).await?.map_err(imap::server);
    }
    imap::within(COMMAND, session.uid_copy(uid, target)).await?.map_err(imap::server)?;
    store(session, uid, "+FLAGS.SILENT (\\Deleted)").await?;
    expunge(session, uid, uidplus).await
}

/// Removes a message marked deleted. Without UIDPLUS, a plain EXPUNGE could also
/// remove other messages marked deleted by another client: the mark is left,
/// and most clients hide such messages.
async fn expunge(session: &mut Imap, uid: &str, uidplus: bool) -> Result<(), SyncError> {
    if !uidplus {
        return Ok(());
    }
    let gone = imap::within(COMMAND, session.uid_expunge(uid)).await?.map_err(imap::server)?;
    let mut gone = std::pin::pin!(gone);
    while let Some(answer) = gone.next().await {
        answer.map_err(imap::server)?;
    }
    Ok(())
}

/// The server name of the folder for `role`; made, with `name`, when the server has none.
pub(crate) async fn role_folder(session: &mut Imap, account: &Account, role: Role, name: &str) -> Result<String, SyncError> {
    if let Some(folder) = folders::preferred(&folders(&account.id), role) {
        return Ok(folder.name.clone());
    }
    let listed = list(session).await?;
    if let Some(folder) = folders::preferred(&listed, role) {
        let name = folder.name.clone();
        save(&account.id, &listed)?;
        return Ok(name);
    }
    // Under the inbox where the server keeps its folders there ("INBOX.Trash").
    let under_inbox = listed.iter().any(|f| f.name.to_ascii_uppercase().starts_with("INBOX."));
    let name = if under_inbox { format!("INBOX.{name}") } else { name.to_string() };
    imap::within(COMMAND, session.create(&name)).await?.map_err(imap::server)?;
    let listed = list(session).await?;
    save(&account.id, &listed)?;
    Ok(name)
}

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

    #[test]
    fn what_an_act_leaves_here_and_says() {
        // Said not spam: it stays, its `$Junk` letter traded for `$NotJunk`'s.
        assert_eq!(kept_with(&Action::NotSpam, &format!("S{}", maildir::JUNK), Role::Inbox), Some(format!("S{}", maildir::NOT_JUNK)));
        assert_eq!(kept_with(&Action::NotSpam, "", Role::Inbox), Some(maildir::NOT_JUNK.to_string()));
        // Read, flagged: the keywords stay beside the flags.
        assert_eq!(kept_with(&Action::Read(false), &format!("S{}", maildir::NOT_JUNK), Role::Inbox), Some(maildir::NOT_JUNK.to_string()));
        // Moved: it leaves this folder; your filter's move too.
        assert_eq!(kept_with(&Action::Junk, "S", Role::Inbox), None);
        assert_eq!(kept_with(&Action::NotJunk, "S", Role::Junk), None);
        assert_eq!(kept_with(&Action::Filtered(sioul_core::spam::Class::Spam), "", Role::Inbox), None);
        // Said spam where your filter moved it: it stays, `$Junk` now.
        assert_eq!(kept_with(&Action::Junk, &format!("S{}", maildir::NOT_JUNK), Role::Junk), Some(format!("S{}", maildir::JUNK)));
        // What goes into the label log, and what does not: your filter's move is never a label.
        assert_eq!([&Action::Junk, &Action::NotJunk, &Action::NotSpam].map(said), [Some(labels::Source::Junk), Some(labels::Source::NotJunk), Some(labels::Source::NotSpam)]);
        assert_eq!([&Action::Read(true), &Action::Trash, &Action::Archive, &Action::Filtered(sioul_core::spam::Class::Spam)].map(said), [None, None, None, None]);
    }

    #[test]
    fn uid_sets_are_short() {
        let uids: BTreeSet<u32> = [1, 2, 3, 4, 5, 7, 9, 10, 11, 12].into_iter().collect();
        assert_eq!(ranges(&uids), "1:5,7,9:12");
        assert_eq!(ranges(&[42].into_iter().collect()), "42");
    }
}