//! The files of the engine and the files of the file system.
//!
//! A file of the engine can be linked to a file on the disk (it was opened from it, or saved to
//! it). The engine does not know about it: the links are kept here, with what the two looked like
//! when they last were the same, which tells
//!
//! - whether the file was edited since it was saved (`dirty`), as its structure is not the one it
//!   had then (the structure changes with every edit, and an undo brings it back);
//! - whether the file on the disk changed since (its bytes are not the ones that were read or
//!   written then), which is the case when something else wrote it.
//!
//! At most one folder is open. It is watched, and the files that are saved without a place are put
//! in it. When a folder is open it is watched: the files that appear, change or disappear on the disk are
//! brought into the engine (see `reconcile`), unless the engine holds edits of that file, which
//! are not overwritten (the file is then flagged as `conflict`).

use std::collections::BTreeMap;
use std::fs;
use std::path::{Path, PathBuf};

use crate::Engine;
use gpx_engine::{ExportOptions, FileId, api};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

use crate::store::write_atomically;

/// The hash of some bytes (FNV-1a), which is the same in every session.
pub fn hash(bytes: &[u8]) -> u64 {
    bytes.iter().fold(0xcbf29ce484222325, |hash, byte| {
        (hash ^ u64::from(*byte)).wrapping_mul(0x100000001b3)
    })
}

/// What a file of the engine looks like: its structure holds the identity of everything that was
/// edited in it. The identities of the contents change when the engine starts again, which is why
/// `Workspace::verify` checks the content of the files that are linked then.
pub fn export_hash(engine: &Engine, id: Uuid) -> Option<u64> {
    Some(hash(&engine.export(&FileId(id), ExportOptions::ALL)?))
}

pub fn signature(engine: &Engine, id: Uuid) -> Option<u64> {
    let structure = api::file_structure(engine, id)?;
    Some(hash(&serde_json::to_vec(&structure).ok()?))
}

/// What to do with the files of a folder that have unsaved edits when the folder is closed.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum Unsaved {
    /// Write them to their file first.
    Save,
    /// Close them, the edits are lost.
    Discard,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Link {
    pub path: PathBuf,
    /// The signature of the file of the engine when it was last the one on the disk.
    pub signature: u64,
    /// The hash of the bytes of the file on the disk when it was last read or written here.
    pub disk_hash: u64,
    /// The hash of what the engine writes for the file (`export`) then, which does not depend on
    /// the identities in the engine: it tells whether a file is still the same after a restart.
    /// Zero when it is not known.
    #[serde(default)]
    pub export_hash: u64,
    /// The file on the disk changed while the engine held edits of it.
    #[serde(default)]
    pub conflict: bool,
}

#[derive(Debug, Default, Serialize, Deserialize)]
pub struct Workspace {
    /// The folder that is open (and watched).
    pub folder: Option<PathBuf>,
    pub links: BTreeMap<Uuid, Link>,
}

/// What the frontend shows of a file.
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct FileStatus {
    /// Where the file is on the disk, absent for a file that only is in the engine.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub path: Option<String>,
    /// The file has edits that are not in the file on the disk (or has no file on the disk).
    pub dirty: bool,
    /// The file on the disk was changed by something else while this one had edits.
    pub conflict: bool,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct WorkspaceState {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    pub files: BTreeMap<String, FileStatus>,
}

fn is_gpx(path: &Path) -> bool {
    path.extension()
        .and_then(|extension| extension.to_str())
        .is_some_and(|extension| extension.eq_ignore_ascii_case("gpx"))
}

fn canonical(path: &Path) -> PathBuf {
    fs::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
}

/// What the engine writes for a file that was read from the disk and not edited, for a link that
/// does not know it: `None` if the file on the disk is not the one that was read anymore.
fn saved_export_hash(link: &Link) -> Option<u64> {
    let bytes = fs::read(&link.path).ok()?;
    if hash(&bytes) != link.disk_hash {
        return None;
    }
    let id = Uuid::new_v4();
    let mut scratch = Engine::default();
    api::sync_files(&mut scratch, &[(id, &bytes, &stem(&link.path))], &[]);
    export_hash(&scratch, id)
}

/// A name that can be the one of a file, on every system.
fn file_name(name: &str) -> String {
    let name: String = name
        .chars()
        .map(|c| match c {
            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
            c if c.is_control() => '_',
            c => c,
        })
        .collect();
    let name = name.trim().trim_matches('.').trim();
    let name: String = name.chars().take(100).collect();
    if name.is_empty() {
        "track".to_owned()
    } else {
        name
    }
}

fn stem(path: &Path) -> String {
    path.file_stem()
        .map(|stem| stem.to_string_lossy().into_owned())
        .unwrap_or_default()
}

/// The GPX files of a folder and of the folders in it.
pub fn scan(folder: &Path) -> Vec<PathBuf> {
    const MAX_DEPTH: usize = 8;
    const MAX_FILES: usize = 5000;
    let mut found = vec![];
    let mut pending = vec![(folder.to_path_buf(), 0)];
    while let Some((directory, depth)) = pending.pop() {
        let Ok(entries) = fs::read_dir(&directory) else {
            continue;
        };
        for entry in entries.flatten() {
            let path = entry.path();
            let Ok(kind) = entry.file_type() else {
                continue;
            };
            let hidden = entry.file_name().to_string_lossy().starts_with('.');
            if hidden {
                continue;
            }
            if kind.is_dir() && depth < MAX_DEPTH {
                pending.push((path, depth + 1));
            } else if kind.is_file() && is_gpx(&path) && found.len() < MAX_FILES {
                found.push(path);
            }
        }
    }
    found.sort();
    found
}

impl Workspace {
    pub fn path() -> &'static str {
        "workspace.json"
    }

    pub fn load(root: &Path) -> Self {
        fs::read(root.join(Self::path()))
            .ok()
            .and_then(|bytes| serde_json::from_slice(&bytes).ok())
            .unwrap_or_default()
    }

    pub fn write(&self, root: &Path) {
        if let Ok(json) = serde_json::to_vec(self)
            && let Err(error) = write_atomically(&root.join(Self::path()), &json)
        {
            eprintln!("the workspace could not be kept: {error}");
        }
    }

    fn id_of(&self, path: &Path) -> Option<Uuid> {
        self.links
            .iter()
            .find_map(|(id, link)| (link.path == path).then_some(*id))
    }

    /// Whether the file has edits that the file on the disk does not have.
    pub fn is_dirty(&self, engine: &Engine, id: Uuid) -> bool {
        match self.links.get(&id) {
            Some(link) => signature(engine, id) != Some(link.signature),
            None => true,
        }
    }

    /// The status of each file of the engine.
    pub fn state(&self, engine: &Engine) -> WorkspaceState {
        WorkspaceState {
            folder: self
                .folder
                .as_ref()
                .map(|folder| folder.to_string_lossy().into_owned()),
            files: engine
                .order()
                .iter()
                .map(|FileId(id)| {
                    let link = self.links.get(id);
                    (
                        id.to_string(),
                        FileStatus {
                            path: link.map(|link| link.path.to_string_lossy().into_owned()),
                            dirty: self.is_dirty(engine, *id),
                            conflict: link.is_some_and(|link| link.conflict),
                        },
                    )
                })
                .collect(),
        }
    }

    /// Checks the links when the engine has started again: it gives new identities to what it holds
    /// (see `signature`), so a file that is the one that was saved looks edited. A file is the same
    /// if what the engine writes for it is what it wrote then; its signature is then the current
    /// one, and the file is not unsaved. A file that has really been edited stays so.
    ///
    /// A link made before the content was kept has the file on the disk to tell what was saved,
    /// if it is still the one that was read.
    pub fn verify(&mut self, engine: &Engine) {
        for (id, link) in self.links.iter_mut() {
            let (Some(current), Some(exported)) =
                (signature(engine, *id), export_hash(engine, *id))
            else {
                continue;
            };
            if link.export_hash == 0 {
                link.export_hash = saved_export_hash(link).unwrap_or_default();
            }
            if current != link.signature && exported == link.export_hash {
                link.signature = current;
            }
        }
    }

    /// Forgets the links of the files that are not in the engine anymore.
    pub fn prune(&mut self, engine: &Engine) {
        self.links
            .retain(|id, _| engine.file_structure(&FileId(*id)).is_some());
    }

    /// Opens files from the disk: the ones that are not open yet are added, and `select` selects
    /// the first of the files that were given (open or not). Says what changed, and which
    /// files could not be read.
    pub fn open_files(
        &mut self,
        engine: &mut Engine,
        paths: &[PathBuf],
        select: bool,
    ) -> api::Outcome {
        let mut new = vec![];
        let mut known = vec![];
        let mut unreadable = vec![];
        for path in paths {
            let path = canonical(path);
            if let Some(id) = self.id_of(&path) {
                known.push(id);
                continue;
            }
            match fs::read(&path) {
                Ok(bytes) => new.push((Uuid::new_v4(), bytes, stem(&path), path)),
                Err(error) => unreadable.push(format!("{}: {error}", path.display())),
            }
        }
        let mut outcome = api::Outcome::failed_none();
        if !new.is_empty() {
            let files: Vec<(Uuid, &[u8], &str)> = new
                .iter()
                .map(|(id, bytes, name, _)| (*id, bytes.as_slice(), name.as_str()))
                .collect();
            outcome = api::sync_files(engine, &files, &[]);
            for (id, bytes, _, path) in &new {
                if let Some(signature) = signature(engine, *id) {
                    self.links.insert(
                        *id,
                        Link {
                            path: path.clone(),
                            signature,
                            disk_hash: hash(bytes),
                            export_hash: export_hash(engine, *id).unwrap_or_default(),
                            conflict: false,
                        },
                    );
                    known.push(*id);
                }
            }
        }
        if select && let Some(first) = known.first() {
            outcome = outcome.merge(api::select(
                engine,
                &[*first],
                gpx_engine::SelectMode::Replace,
            ));
        }
        if !outcome.has_error() && !unreadable.is_empty() {
            outcome = outcome.merge(api::Outcome::failed(unreadable.join("; ")));
        }
        outcome
    }

    /// Opens a folder: the GPX files in it are opened, and kept in line with it from then on (see
    /// `reconcile`). The folder that was open is closed (see `close_folder`, which `unsaved` is
    /// for), and nothing changes if that fails.
    pub fn open_folder(
        &mut self,
        engine: &mut Engine,
        folder: &Path,
        unsaved: Option<Unsaved>,
    ) -> Result<api::Outcome, String> {
        let folder = canonical(folder);
        let closed = if self.folder.as_ref().is_some_and(|open| *open != folder) {
            self.close_folder(engine, unsaved)?
        } else {
            api::Outcome::failed_none()
        };
        self.folder = Some(folder.clone());
        Ok(closed.merge(self.open_files(engine, &scan(&folder), false)))
    }

    /// The files that belong to the open folder: the ones in it, and the new ones, which are
    /// saved in it.
    fn belonging_to_folder(&self, engine: &Engine) -> Vec<Uuid> {
        let Some(folder) = &self.folder else {
            return vec![];
        };
        engine
            .order()
            .iter()
            .map(|FileId(id)| *id)
            .filter(|id| match self.links.get(id) {
                Some(link) => link.path.starts_with(folder),
                None => true,
            })
            .collect()
    }

    /// The files of the open folder that have unsaved edits, the new files included.
    pub fn unsaved_in_folder(&self, engine: &Engine) -> Vec<Uuid> {
        self.belonging_to_folder(engine)
            .into_iter()
            .filter(|id| self.is_dirty(engine, *id))
            .collect()
    }

    /// Closes the open folder: its files are closed. The ones that have unsaved edits, and the new
    /// files that were not saved (they are saved in the folder), are saved first or discarded, as
    /// `unsaved` says; without it they stay open.
    ///
    /// Nothing is closed if saving fails.
    pub fn close_folder(
        &mut self,
        engine: &mut Engine,
        unsaved: Option<Unsaved>,
    ) -> Result<api::Outcome, String> {
        if self.folder.is_none() {
            return Ok(api::Outcome::failed_none());
        }
        let unsaved_ids = self.unsaved_in_folder(engine);
        if unsaved == Some(Unsaved::Save) {
            self.save(engine, &unsaved_ids, &BTreeMap::new())?;
        }
        let closing: Vec<Uuid> = self
            .belonging_to_folder(engine)
            .into_iter()
            .filter(|id| unsaved.is_some() || !unsaved_ids.contains(id))
            .collect();
        self.folder = None;
        for id in &closing {
            self.links.remove(id);
        }
        if closing.is_empty() {
            return Ok(api::Outcome::failed_none());
        }
        Ok(api::sync_files(engine, &[], &closing))
    }

    /// Where to put a file that is not on the disk, in the open folder: named like the file, and
    /// not the name of a file that is there.
    fn free_path(&self, folder: &Path, name: &str) -> PathBuf {
        let name = file_name(name);
        let taken =
            |path: &Path| path.exists() || self.links.values().any(|link| link.path == path);
        let mut path = folder.join(format!("{name}.gpx"));
        let mut number = 2;
        while taken(&path) {
            path = folder.join(format!("{name} ({number}).gpx"));
            number += 1;
        }
        path
    }

    /// Brings what changed on the disk into the engine: for the given paths (or everything that is
    /// in the folder, and everything that is linked, when there are none).
    ///
    /// - A file that is not open is added.
    /// - A file that changed is read again, unless it has edits that the file on the disk does not
    ///   have: it is flagged as a conflict, and what is in the engine stays.
    /// - A file that is gone is deleted, unless it has edits: it becomes a file that only is in
    ///   the engine.
    ///
    /// Gives what that changed in the engine, `None` when nothing.
    pub fn reconcile(
        &mut self,
        engine: &mut Engine,
        changed: Option<&[PathBuf]>,
    ) -> Option<api::Outcome> {
        let folder = self.folder.clone();
        let candidates: Vec<PathBuf> = match changed {
            None => {
                let mut paths = folder.as_deref().map(scan).unwrap_or_default();
                paths.extend(self.links.values().map(|link| link.path.clone()));
                paths
            }
            Some(changed) => {
                let mut paths: Vec<PathBuf> = changed
                    .iter()
                    .filter(|path| {
                        folder
                            .as_ref()
                            .is_some_and(|folder| path.starts_with(folder))
                    })
                    .cloned()
                    .collect();
                // a folder that was removed or moved takes its files with it
                paths.extend(
                    self.links
                        .values()
                        .map(|link| link.path.clone())
                        .filter(|path| changed.iter().any(|other| path.starts_with(other))),
                );
                paths
            }
        };
        let mut candidates: Vec<PathBuf> = candidates
            .into_iter()
            .filter(|path| is_gpx(path) || self.id_of(path).is_some())
            .collect();
        candidates.sort();
        candidates.dedup();

        // the files to bring in, with what to record once they are
        let mut files: Vec<(Uuid, Vec<u8>, String, PathBuf)> = vec![];
        let mut remove = vec![];
        let mut flagged = false;
        for path in candidates {
            let id = self.id_of(&path);
            match fs::read(&path) {
                Ok(bytes) => {
                    let disk_hash = hash(&bytes);
                    match id {
                        Some(id) => {
                            let dirty = self.is_dirty(engine, id);
                            let link = self.links.get_mut(&id).expect("the link exists");
                            if disk_hash == link.disk_hash {
                                continue;
                            }
                            if dirty {
                                link.disk_hash = disk_hash;
                                link.conflict = true;
                                flagged = true;
                            } else {
                                files.push((id, bytes, stem(&path), path));
                            }
                        }
                        None => files.push((Uuid::new_v4(), bytes, stem(&path), path)),
                    }
                }
                Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
                    if let Some(id) = id {
                        if !self.is_dirty(engine, id) {
                            remove.push(id);
                        }
                        self.links.remove(&id);
                        flagged = true;
                    }
                }
                // a folder, or a file that cannot be read now: it is looked at again when it changes
                Err(_) => {}
            }
        }

        let outcome = if files.is_empty() && remove.is_empty() {
            None
        } else {
            let borrowed: Vec<(Uuid, &[u8], &str)> = files
                .iter()
                .map(|(id, bytes, name, _)| (*id, bytes.as_slice(), name.as_str()))
                .collect();
            let outcome = api::sync_files(engine, &borrowed, &remove);
            for (id, bytes, _, path) in &files {
                match signature(engine, *id) {
                    Some(signature) => {
                        self.links.insert(
                            *id,
                            Link {
                                path: path.clone(),
                                signature,
                                disk_hash: hash(bytes),
                                export_hash: export_hash(engine, *id).unwrap_or_default(),
                                conflict: false,
                            },
                        );
                    }
                    // it could not be read: it is tried again when it changes
                    None => {
                        self.links.remove(id);
                    }
                }
            }
            for id in &remove {
                self.links.remove(id);
            }
            Some(outcome)
        };
        if outcome.is_some() || flagged {
            self.prune(engine);
        }
        outcome.or_else(|| flagged.then(api::Outcome::failed_none))
    }

    /// The files among `ids` that are not on the disk, with the name to propose for them.
    pub fn unlinked(&self, engine: &Engine, ids: &[Uuid]) -> Vec<(Uuid, String)> {
        ids.iter()
            .filter(|id| !self.links.contains_key(id))
            .filter_map(|id| Some((*id, engine.file_structure(&FileId(*id))?.name.clone())))
            .collect()
    }

    /// Writes files to the disk, replacing what is there: they are the same as their file from
    /// then on. `paths` is where to write the ones that are not on the disk yet. Stops at the
    /// first error, the files that were written stay written.
    pub fn save(
        &mut self,
        engine: &Engine,
        ids: &[Uuid],
        paths: &BTreeMap<Uuid, PathBuf>,
    ) -> Result<(), String> {
        let mut result = Ok(());
        for id in ids {
            let path = match self.links.get(id) {
                Some(link) => link.path.clone(),
                None => match (paths.get(id), &self.folder) {
                    (Some(path), _) => canonical(path),
                    // a new file goes in the folder that is open
                    (None, Some(folder)) => {
                        let Some(structure) = engine.file_structure(&FileId(*id)) else {
                            continue;
                        };
                        self.free_path(folder, &structure.name)
                    }
                    (None, None) => continue,
                },
            };
            let Some(bytes) = api::export_file(engine, *id, ExportOptions::ALL) else {
                continue;
            };
            if let Err(error) = write_atomically(&path, &bytes) {
                result = Err(format!("{}: {error}", path.display()));
                break;
            }
            let Some(signature) = signature(engine, *id) else {
                continue;
            };
            // the folder, if there is one, may watch what was just written: the hash tells it is known
            self.links.insert(
                *id,
                Link {
                    path: canonical(&path),
                    signature,
                    disk_hash: hash(&bytes),
                    export_hash: hash(&bytes),
                    conflict: false,
                },
            );
        }
        result
    }
}

#[cfg(test)]
mod tests {
    use gpx_engine::SelectMode;

    use super::*;

    fn gpx(name: &str) -> String {
        format!(
            r#"<?xml version="1.0"?><gpx version="1.1" creator="test" xmlns="http://www.topografix.com/GPX/1/1"><metadata><name>{name}</name></metadata><trk><trkseg><trkpt lat="50.0" lon="4.0"><ele>10</ele></trkpt><trkpt lat="50.1" lon="4.1"><ele>20</ele></trkpt></trkseg></trk></gpx>"#
        )
    }

    struct Fixture {
        folder: PathBuf,
        engine: Engine,
        workspace: Workspace,
    }

    impl Fixture {
        fn new() -> Self {
            let folder =
                canonical(&std::env::temp_dir()).join(format!("gpx-ws-{}", Uuid::new_v4()));
            fs::create_dir_all(&folder).unwrap();
            Self {
                folder,
                engine: Engine::default(),
                workspace: Workspace::default(),
            }
        }

        fn write(&self, name: &str, title: &str) -> PathBuf {
            let path = self.folder.join(name);
            fs::write(&path, gpx(title)).unwrap();
            path
        }

        fn ids(&self) -> Vec<Uuid> {
            self.engine.order().iter().map(|id| id.0).collect()
        }

        fn name(&self, id: Uuid) -> String {
            self.engine
                .file_structure(&FileId(id))
                .unwrap()
                .name
                .clone()
        }

        fn rename(&mut self, id: Uuid, name: &str) {
            api::select(&mut self.engine, &[id], SelectMode::Replace);
            assert!(!api::metadata(&mut self.engine, name, "").has_error());
        }
    }

    impl Drop for Fixture {
        fn drop(&mut self) {
            let _ = fs::remove_dir_all(&self.folder);
        }
    }

    #[test]
    fn an_opened_file_is_clean_until_it_is_edited_and_clean_again_once_saved() {
        let mut fx = Fixture::new();
        let path = fx.write("a.gpx", "a");
        fx.workspace
            .open_files(&mut fx.engine, std::slice::from_ref(&path), true);
        let id = fx.ids()[0];
        assert!(!fx.workspace.is_dirty(&fx.engine, id));
        assert_eq!(
            fx.workspace.state(&fx.engine).files[&id.to_string()]
                .path
                .as_deref(),
            path.to_str()
        );

        fx.rename(id, "renamed");
        assert!(fx.workspace.is_dirty(&fx.engine, id));
        // nothing is written before it is saved
        assert!(fs::read_to_string(&path).unwrap().contains(">a<"));

        fx.workspace
            .save(&fx.engine, &[id], &BTreeMap::new())
            .unwrap();
        assert!(!fx.workspace.is_dirty(&fx.engine, id));
        assert!(fs::read_to_string(&path).unwrap().contains(">renamed<"));

        // going back before the save is an edit again
        api::undo(&mut fx.engine);
        assert!(fx.workspace.is_dirty(&fx.engine, id));
        api::redo(&mut fx.engine);
        assert!(!fx.workspace.is_dirty(&fx.engine, id));
    }

    #[test]
    fn a_file_that_is_not_on_the_disk_is_unsaved_until_it_is_given_a_place() {
        let mut fx = Fixture::new();
        api::new_file(&mut fx.engine, "fresh", None, None, None);
        let id = fx.ids()[0];
        assert!(fx.workspace.is_dirty(&fx.engine, id));
        assert_eq!(
            fx.workspace.unlinked(&fx.engine, &[id]),
            [(id, "fresh".to_string())]
        );

        let path = fx.folder.join("fresh.gpx");
        let paths = BTreeMap::from([(id, path.clone())]);
        fx.workspace.save(&fx.engine, &[id], &paths).unwrap();
        assert!(path.exists());
        assert!(!fx.workspace.is_dirty(&fx.engine, id));
        assert!(fx.workspace.unlinked(&fx.engine, &[id]).is_empty());
    }

    #[test]
    fn what_this_app_writes_is_not_a_change_of_the_disk() {
        let mut fx = Fixture::new();
        let path = fx.write("a.gpx", "a");
        fx.workspace
            .open_folder(&mut fx.engine, &fx.folder.clone(), None)
            .unwrap();
        let id = fx.ids()[0];
        fx.rename(id, "renamed");
        fx.workspace
            .save(&fx.engine, &[id], &BTreeMap::new())
            .unwrap();
        assert!(
            fx.workspace
                .reconcile(&mut fx.engine, Some(&[path]))
                .is_none()
        );
        assert_eq!(fx.name(id), "renamed");
    }

    #[test]
    fn opening_a_folder_opens_its_files_and_follows_what_happens_to_them() {
        let mut fx = Fixture::new();
        let a = fx.write("a.gpx", "a");
        fx.write("notes.txt", "not a track");
        fs::create_dir(fx.folder.join("sub")).unwrap();
        fx.write("sub/b.gpx", "b");
        fx.workspace
            .open_folder(&mut fx.engine, &fx.folder.clone(), None)
            .unwrap();
        assert_eq!(fx.ids().len(), 2);
        let ids = fx.ids();
        let a_id = ids.iter().copied().find(|id| fx.name(*id) == "a").unwrap();

        // a new file
        let c = fx.write("c.gpx", "c");
        let outcome = fx
            .workspace
            .reconcile(&mut fx.engine, Some(std::slice::from_ref(&c)))
            .unwrap();
        assert!(outcome.changed);
        assert_eq!(fx.ids().len(), 3);

        // the same file again: nothing
        assert!(fx.workspace.reconcile(&mut fx.engine, Some(&[c])).is_none());

        // a file that changed is read again, and stays the same file
        fx.write("a.gpx", "a, edited elsewhere");
        fx.workspace
            .reconcile(&mut fx.engine, Some(std::slice::from_ref(&a)))
            .unwrap();
        assert_eq!(fx.name(a_id), "a, edited elsewhere");
        assert!(!fx.workspace.is_dirty(&fx.engine, a_id));
        assert_eq!(fx.ids().len(), 3);

        // a file that is gone
        fs::remove_file(&a).unwrap();
        fx.workspace.reconcile(&mut fx.engine, Some(&[a])).unwrap();
        assert_eq!(fx.ids().len(), 2);
        assert!(!fx.ids().contains(&a_id));
    }

    #[test]
    fn the_edits_of_a_file_are_not_overwritten_by_the_disk() {
        let mut fx = Fixture::new();
        let a = fx.write("a.gpx", "a");
        fx.workspace
            .open_folder(&mut fx.engine, &fx.folder.clone(), None)
            .unwrap();
        let id = fx.ids()[0];
        fx.rename(id, "mine");

        fx.write("a.gpx", "theirs");
        let outcome = fx
            .workspace
            .reconcile(&mut fx.engine, Some(std::slice::from_ref(&a)));
        assert!(!outcome.is_some_and(|outcome| outcome.changed));
        assert_eq!(fx.name(id), "mine");
        assert!(fx.workspace.state(&fx.engine).files[&id.to_string()].conflict);

        // gone from the disk: it stays, as a file that is only here
        fs::remove_file(&a).unwrap();
        fx.workspace.reconcile(&mut fx.engine, Some(&[a]));
        assert_eq!(fx.ids(), [id]);
        let status = &fx.workspace.state(&fx.engine).files[&id.to_string()];
        assert!(status.path.is_none() && status.dirty);

        // saving it again puts it back
        let paths = BTreeMap::from([(id, fx.folder.join("a.gpx"))]);
        fx.workspace.save(&fx.engine, &[id], &paths).unwrap();
        assert!(!fx.workspace.state(&fx.engine).files[&id.to_string()].conflict);
    }

    #[test]
    fn what_changed_while_the_app_was_closed_is_found_when_it_starts() {
        let mut fx = Fixture::new();
        let a = fx.write("a.gpx", "a");
        fx.workspace
            .open_folder(&mut fx.engine, &fx.folder.clone(), None)
            .unwrap();
        let id = fx.ids()[0];
        fx.write("a.gpx", "changed");
        fx.write("new.gpx", "new");
        fx.workspace.reconcile(&mut fx.engine, None).unwrap();
        assert_eq!(fx.name(id), "changed");
        assert_eq!(fx.ids().len(), 2);
        fs::remove_file(a).unwrap();
        fx.workspace.reconcile(&mut fx.engine, None).unwrap();
        assert_eq!(fx.ids().len(), 1);
    }

    #[test]
    fn a_new_file_is_saved_in_the_open_folder_without_a_place() {
        let mut fx = Fixture::new();
        fx.write("fresh.gpx", "already there");
        fx.workspace
            .open_folder(&mut fx.engine, &fx.folder.clone(), None)
            .unwrap();
        api::new_file(&mut fx.engine, "fresh", None, None, None);
        api::new_file(&mut fx.engine, "a/b: c", None, None, None);
        let new: Vec<Uuid> = fx
            .ids()
            .into_iter()
            .filter(|id| fx.workspace.is_dirty(&fx.engine, *id))
            .collect();
        assert_eq!(new.len(), 2);

        fx.workspace
            .save(&fx.engine, &new, &BTreeMap::new())
            .unwrap();
        // named like the file, not over what is there, and with a name that is valid
        assert!(fx.folder.join("fresh (2).gpx").exists());
        assert!(fx.folder.join("a_b_ c.gpx").exists());
        assert_eq!(
            fx.workspace
                .state(&fx.engine)
                .files
                .values()
                .filter(|f| f.dirty)
                .count(),
            0
        );
    }

    #[test]
    fn opening_another_folder_closes_the_first() {
        let mut fx = Fixture::new();
        fx.write("one.gpx", "one");
        let other = fx.folder.join("other");
        fs::create_dir(&other).unwrap();
        fs::write(other.join("two.gpx"), gpx("two")).unwrap();
        // the first folder is not the parent of the second
        let first = fx.folder.join("first");
        fs::create_dir(&first).unwrap();
        fs::write(first.join("one.gpx"), gpx("one")).unwrap();
        fx.workspace
            .open_folder(&mut fx.engine, &first, None)
            .unwrap();
        let one = fx.ids()[0];
        fx.workspace
            .open_folder(&mut fx.engine, &other, None)
            .unwrap();
        assert_eq!(fx.ids().len(), 1);
        assert!(!fx.ids().contains(&one));
        assert_eq!(fx.name(fx.ids()[0]), "two");
        assert_eq!(
            fx.workspace.folder.as_deref(),
            Some(canonical(&other).as_path())
        );

        // what has edits stays when the folder is closed, and can still be saved where it is
        let two = fx.ids()[0];
        fx.rename(two, "edited");
        let outcome = fx.workspace.close_folder(&mut fx.engine, None).unwrap();
        assert!(!outcome.changed);
        assert_eq!(fx.ids(), [two]);
        assert!(fx.workspace.folder.is_none());
        fx.workspace
            .save(&fx.engine, &[two], &BTreeMap::new())
            .unwrap();
        assert!(
            fs::read_to_string(other.join("two.gpx"))
                .unwrap()
                .contains("edited")
        );
        let clean = fx.workspace.close_folder(&mut fx.engine, None).unwrap();
        assert!(!clean.changed);
    }

    fn folder_with_an_edited_file() -> (Fixture, Uuid) {
        let mut fx = Fixture::new();
        fx.write("a.gpx", "a");
        fx.write("b.gpx", "b");
        fx.workspace
            .open_folder(&mut fx.engine, &fx.folder.clone(), None)
            .unwrap();
        let id = fx.ids().into_iter().find(|id| fx.name(*id) == "a").unwrap();
        fx.rename(id, "edited");
        (fx, id)
    }

    #[test]
    fn the_unsaved_files_of_a_folder_are_known() {
        let (fx, id) = folder_with_an_edited_file();
        assert_eq!(fx.workspace.unsaved_in_folder(&fx.engine), [id]);
    }

    #[test]
    fn closing_a_folder_can_save_the_unsaved_files_first() {
        let (mut fx, _) = folder_with_an_edited_file();
        let outcome = fx
            .workspace
            .close_folder(&mut fx.engine, Some(Unsaved::Save))
            .unwrap();
        assert!(outcome.changed);
        assert!(fx.ids().is_empty());
        assert!(
            fs::read_to_string(fx.folder.join("a.gpx"))
                .unwrap()
                .contains("edited")
        );
        assert!(fx.workspace.folder.is_none() && fx.workspace.links.is_empty());
    }

    #[test]
    fn closing_a_folder_can_discard_the_unsaved_files() {
        let (mut fx, _) = folder_with_an_edited_file();
        fx.workspace
            .close_folder(&mut fx.engine, Some(Unsaved::Discard))
            .unwrap();
        assert!(fx.ids().is_empty());
        assert!(
            fs::read_to_string(fx.folder.join("a.gpx"))
                .unwrap()
                .contains(">a<")
        );
    }

    #[test]
    fn nothing_is_closed_when_the_unsaved_files_cannot_be_saved() {
        let (mut fx, id) = folder_with_an_edited_file();
        // the file cannot be written: its place is taken by a folder
        fs::remove_file(fx.folder.join("a.gpx")).unwrap();
        fs::create_dir(fx.folder.join("a.gpx")).unwrap();
        let result = fx
            .workspace
            .close_folder(&mut fx.engine, Some(Unsaved::Save));
        assert!(result.is_err());
        assert!(fx.workspace.folder.is_some());
        assert!(fx.ids().contains(&id));
    }

    #[test]
    fn opening_another_folder_applies_the_choice_to_the_first() {
        let (mut fx, _) = folder_with_an_edited_file();
        let other = fx.folder.join("other");
        fs::create_dir(&other).unwrap();
        fs::write(other.join("c.gpx"), gpx("c")).unwrap();
        // the folder that is open contains the other one: use two separate ones instead
        let elsewhere = canonical(&std::env::temp_dir()).join(format!("gpx-ws-{}", Uuid::new_v4()));
        fs::create_dir_all(&elsewhere).unwrap();
        fs::write(elsewhere.join("d.gpx"), gpx("d")).unwrap();
        fx.workspace
            .open_folder(&mut fx.engine, &elsewhere, Some(Unsaved::Discard))
            .unwrap();
        assert_eq!(fx.ids().len(), 1);
        assert_eq!(fx.name(fx.ids()[0]), "d");
        assert!(
            fs::read_to_string(fx.folder.join("a.gpx"))
                .unwrap()
                .contains(">a<")
        );
        fs::remove_dir_all(elsewhere).unwrap();
    }

    #[test]
    fn new_files_belong_to_the_open_folder_and_follow_its_unsaved_choice() {
        let (mut fx, edited) = folder_with_an_edited_file();
        api::new_file(&mut fx.engine, "fresh", None, None, None);
        let fresh = *fx
            .ids()
            .iter()
            .find(|id| **id != edited && fx.name(**id) == "fresh")
            .unwrap();
        let unsaved = fx.workspace.unsaved_in_folder(&fx.engine);
        assert!(unsaved.contains(&edited) && unsaved.contains(&fresh));

        // saved in the folder when it is closed
        fx.workspace
            .close_folder(&mut fx.engine, Some(Unsaved::Save))
            .unwrap();
        assert!(fx.ids().is_empty());
        assert!(fx.folder.join("fresh.gpx").exists());
        assert!(
            fs::read_to_string(fx.folder.join("a.gpx"))
                .unwrap()
                .contains("edited")
        );
    }

    #[test]
    fn new_files_are_discarded_with_the_folder_or_stay_without_a_choice() {
        let (mut fx, edited) = folder_with_an_edited_file();
        api::new_file(&mut fx.engine, "fresh", None, None, None);
        // without a choice the unsaved files stay, the new one as well
        fx.workspace.close_folder(&mut fx.engine, None).unwrap();
        assert!(fx.ids().contains(&edited));
        assert!(fx.ids().iter().any(|id| fx.name(*id) == "fresh"));
        assert!(fx.workspace.folder.is_none());

        let (mut fx, _) = folder_with_an_edited_file();
        api::new_file(&mut fx.engine, "fresh", None, None, None);
        fx.workspace
            .close_folder(&mut fx.engine, Some(Unsaved::Discard))
            .unwrap();
        assert!(fx.ids().is_empty());
        assert!(!fx.folder.join("fresh.gpx").exists());
    }
}

#[cfg(test)]
mod restart_tests {
    use gpx_engine::Persister;

    use super::*;
    use crate::store::FileStorage;

    /// What the app does when it starts again: the engine and the links are read from what was
    /// kept.
    fn restart(engine: &Engine, workspace: &Workspace, root: &Path) -> (Engine, Workspace) {
        let storage = FileStorage::open(root).unwrap();
        pollster::block_on(Persister::default().save(&storage, engine.snapshot())).unwrap();
        let mut restarted = Engine::default();
        let restored = pollster::block_on(Persister::default().restore(&storage)).unwrap();
        restarted.restore(restored);
        let links = serde_json::to_string(workspace).unwrap();
        (restarted, serde_json::from_str(&links).unwrap())
    }

    fn setup() -> (PathBuf, Engine, Workspace, Vec<Uuid>) {
        let root = std::env::temp_dir().join(format!("gpx-restart-{}", Uuid::new_v4()));
        let folder = root.join("tracks");
        fs::create_dir_all(&folder).unwrap();
        for name in ["with_tracks", "with_time", "with_waypoint"] {
            let _ = fs::copy(
                format!("../gpx-rs/data/{name}.gpx"),
                folder.join(format!("{name}.gpx")),
            );
        }
        let mut engine = Engine::default();
        let mut workspace = Workspace::default();
        workspace.open_folder(&mut engine, &folder, None).unwrap();
        let ids = engine.order().iter().map(|id| id.0).collect();
        (root, engine, workspace, ids)
    }

    #[test]
    fn files_that_were_not_edited_are_not_unsaved_after_a_restart() {
        let (root, engine, workspace, ids) = setup();
        assert!(ids.len() >= 2);
        let (restarted, mut workspace) = restart(&engine, &workspace, &root.join("store"));
        // the files are the same, but the engine knows their contents by new identities
        assert!(ids.iter().any(|id| workspace.is_dirty(&restarted, *id)));
        workspace.verify(&restarted);
        assert!(ids.iter().all(|id| !workspace.is_dirty(&restarted, *id)));
        fs::remove_dir_all(root).unwrap();
    }

    #[test]
    fn files_that_were_edited_are_still_unsaved_after_a_restart() {
        let (root, mut engine, workspace, ids) = setup();
        api::select(&mut engine, &[ids[0]], gpx_engine::SelectMode::Replace);
        api::metadata(&mut engine, "edited", "");
        assert!(workspace.is_dirty(&engine, ids[0]));
        let (restarted, mut workspace) = restart(&engine, &workspace, &root.join("store"));
        workspace.verify(&restarted);
        assert!(workspace.is_dirty(&restarted, ids[0]));
        assert!(
            ids[1..]
                .iter()
                .all(|id| !workspace.is_dirty(&restarted, *id))
        );
        fs::remove_dir_all(root).unwrap();
    }

    #[test]
    fn links_made_before_the_content_was_kept_are_checked_against_the_disk() {
        let (root, mut engine, mut workspace, ids) = setup();
        api::select(&mut engine, &[ids[0]], gpx_engine::SelectMode::Replace);
        api::metadata(&mut engine, "edited", "");
        for link in workspace.links.values_mut() {
            link.export_hash = 0;
        }
        let (restarted, mut workspace) = restart(&engine, &workspace, &root.join("store"));
        workspace.verify(&restarted);
        assert!(workspace.is_dirty(&restarted, ids[0]));
        assert!(
            ids[1..]
                .iter()
                .all(|id| !workspace.is_dirty(&restarted, *id))
        );
        fs::remove_dir_all(root).unwrap();
    }
}