//! Strict, secret-free configuration shared by every frontend.

use std::{
    collections::BTreeSet,
    env,
    error::Error,
    fmt, fs,
    fs::OpenOptions,
    io::Write,
    path::{Component, Path, PathBuf},
    time::Duration,
};

use cap_std::{ambient_authority, fs::Dir};
use cap_tempfile::TempFile;
use serde::Deserialize;
use url::Url;

use crate::{
    authentication::{AuthenticationTimeout, DEFAULT_AUTHENTICATION_TIMEOUT},
    git::GitIdentity,
    mobile::MobileTab,
    presentation::{ClipboardTimeout, DEFAULT_CLIPBOARD_TIMEOUT},
    repository::EntryPath,
};

const APPLICATION_DIRECTORY: &str = "ironstorage";
const CONFIG_FILE: &str = "config.toml";
const MAX_CONFIG_BYTES: u64 = 1024 * 1024;

/// Validated application configuration.
#[derive(Clone, Debug, PartialEq)]
pub struct Config {
    source: PathBuf,
    document: toml::Value,
    vault: PathBuf,
    default_key: KeyIdentity,
    key_material: PathBuf,
    editor: Option<EditorCommand>,
    clipboard_timeout: ClipboardTimeout,
    authentication_timeout: AuthenticationTimeout,
    biometric_unlock_enabled: bool,
    mobile_appearance: MobileAppearance,
    mobile_tab: MobileTab,
    mobile_home_refreshed_at: Option<i64>,
    watch_shared_totp_entries: BTreeSet<EntryPath>,
    git_identity: GitIdentity,
    git_remotes: Vec<GitRemote>,
}

// Accepted fields contain no floating-point TOML values, so validated documents
// preserve the equivalence relation required by `Eq`.
impl Eq for Config {}

/// Editable, secret-free values shared by every frontend.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ConfigSettings {
    vault: PathBuf,
    default_key: String,
    editor: Option<Vec<String>>,
    authentication_timeout: Duration,
}

#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub enum MobileAppearance {
    #[default]
    System,
    Light,
    Dark,
}

impl MobileAppearance {
    fn from_config(value: &str) -> Result<Self, ConfigError> {
        match value {
            "system" => Ok(Self::System),
            "light" => Ok(Self::Light),
            "dark" => Ok(Self::Dark),
            _ => Err(ConfigError::InvalidField {
                field: "ui.mobile_appearance",
            }),
        }
    }

    const fn config_value(self) -> &'static str {
        match self {
            Self::System => "system",
            Self::Light => "light",
            Self::Dark => "dark",
        }
    }
}

impl ConfigSettings {
    pub fn vault(&self) -> &Path {
        &self.vault
    }

    pub fn set_vault(&mut self, vault: PathBuf) {
        self.vault = vault;
    }

    pub fn default_key(&self) -> &str {
        &self.default_key
    }

    pub fn set_default_key(&mut self, default_key: String) {
        self.default_key = default_key;
    }

    pub fn editor(&self) -> Option<&[String]> {
        self.editor.as_deref()
    }

    pub fn set_editor(&mut self, editor: Option<Vec<String>>) {
        self.editor = editor;
    }

    pub fn authentication_timeout(&self) -> Duration {
        self.authentication_timeout
    }

    pub fn set_authentication_timeout(&mut self, timeout: Duration) {
        self.authentication_timeout = timeout;
    }
}

impl Config {
    /// Load an explicit configuration file, or the native per-user default.
    pub fn load(explicit: Option<&Path>) -> Result<Self, ConfigError> {
        ConfigLoader::system()?.load(explicit)
    }

    pub fn source(&self) -> &Path {
        &self.source
    }

    pub fn vault(&self) -> &Path {
        &self.vault
    }

    pub fn default_key(&self) -> &KeyIdentity {
        &self.default_key
    }

    pub fn key_material(&self) -> &Path {
        &self.key_material
    }

    pub fn configured_editor(&self) -> Option<&EditorCommand> {
        self.editor.as_ref()
    }

    pub fn clipboard_timeout(&self) -> ClipboardTimeout {
        self.clipboard_timeout
    }

    /// Shared inactivity lease used by every interactive frontend.
    pub fn authentication_timeout(&self) -> AuthenticationTimeout {
        self.authentication_timeout
    }

    pub fn biometric_unlock_enabled(&self) -> bool {
        self.biometric_unlock_enabled
    }

    pub fn mobile_appearance(&self) -> MobileAppearance {
        self.mobile_appearance
    }

    pub fn mobile_tab(&self) -> MobileTab {
        self.mobile_tab
    }

    pub fn mobile_home_refreshed_at(&self) -> Option<i64> {
        self.mobile_home_refreshed_at
    }

    pub fn watch_shared_totp_entries(&self) -> &BTreeSet<EntryPath> {
        &self.watch_shared_totp_entries
    }

    pub fn git_remotes(&self) -> &[GitRemote] {
        &self.git_remotes
    }

    pub fn git_identity(&self) -> &GitIdentity {
        &self.git_identity
    }

    pub fn settings(&self) -> ConfigSettings {
        let editor = self.editor.as_ref().map(|editor| {
            std::iter::once(editor.program.clone())
                .chain(editor.arguments.iter().cloned())
                .collect()
        });
        ConfigSettings {
            vault: self.vault.clone(),
            default_key: self.default_key.0.clone(),
            editor,
            authentication_timeout: self.authentication_timeout.duration(),
        }
    }

    pub fn update_mobile_tab(&self, tab: MobileTab) -> Result<(), ConfigError> {
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let ui = root
            .entry("ui")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "ui" })?;
        ui.insert(
            "selected_mobile_tab".to_owned(),
            toml::Value::String(tab.config_value().to_owned()),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    pub fn update_watch_shared_totp_entries(
        &self,
        entries: &BTreeSet<EntryPath>,
    ) -> Result<(), ConfigError> {
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let ui = root
            .entry("ui")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "ui" })?;
        ui.insert(
            "watch_shared_totp_entries".to_owned(),
            toml::Value::Array(
                entries
                    .iter()
                    .map(|entry| toml::Value::String(entry.to_string()))
                    .collect(),
            ),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    pub(crate) fn update_mobile_home_refresh(&self, unix_seconds: i64) -> Result<(), ConfigError> {
        if unix_seconds <= 0 {
            return Err(ConfigError::InvalidField {
                field: "ui.home_remote_refreshed_at_unix_seconds",
            });
        }
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let ui = root
            .entry("ui")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "ui" })?;
        ui.insert(
            "home_remote_refreshed_at_unix_seconds".to_owned(),
            toml::Value::Integer(unix_seconds),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    pub fn update_biometric_unlock(&self, enabled: bool) -> Result<(), ConfigError> {
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let security = root
            .entry("security")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "security" })?;
        security.insert(
            "biometric_unlock_enabled".to_owned(),
            toml::Value::Boolean(enabled),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    pub fn update_authentication_timeout(
        &self,
        timeout: AuthenticationTimeout,
    ) -> Result<(), ConfigError> {
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let security = root
            .entry("security")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "security" })?;
        let seconds =
            i64::try_from(timeout.duration().as_secs()).map_err(|_| ConfigError::InvalidField {
                field: "security.inactivity_timeout_seconds",
            })?;
        security.insert(
            "inactivity_timeout_seconds".to_owned(),
            toml::Value::Integer(seconds),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    pub fn update_mobile_appearance(
        &self,
        appearance: MobileAppearance,
    ) -> Result<(), ConfigError> {
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let ui = root
            .entry("ui")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "ui" })?;
        ui.insert(
            "mobile_appearance".to_owned(),
            toml::Value::String(appearance.config_value().to_owned()),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    pub fn update_git_identity(&self, identity: &GitIdentity) -> Result<(), ConfigError> {
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let git = root
            .entry("git")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "git" })?;
        git.insert(
            "user_name".to_owned(),
            toml::Value::String(identity.name().to_owned()),
        );
        git.insert(
            "user_email".to_owned(),
            toml::Value::String(identity.email().to_owned()),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    pub(crate) fn update_mobile_remote(
        &self,
        remote: Option<&GitRemote>,
    ) -> Result<(), ConfigError> {
        let mut document = self.current_document()?;
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        let git = root
            .entry("git")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "git" })?;
        match remote {
            Some(remote) => {
                let mut configured = toml::Table::new();
                configured.insert(
                    "name".to_owned(),
                    toml::Value::String(remote.name().as_str().to_owned()),
                );
                configured.insert(
                    "url".to_owned(),
                    toml::Value::String(remote.url().to_string()),
                );
                configured.insert(
                    "server_id".to_owned(),
                    toml::Value::String(remote.server_id().as_str().to_owned()),
                );
                configured.insert(
                    "application_id".to_owned(),
                    toml::Value::String(remote.application_id().as_str().to_owned()),
                );
                git.insert(
                    "remotes".to_owned(),
                    toml::Value::Array(vec![toml::Value::Table(configured)]),
                );
            }
            None => {
                git.remove("remotes");
            }
        }
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)?.persist()
    }

    fn current_document(&self) -> Result<toml::Value, ConfigError> {
        Self::load(Some(&self.source)).map(|config| config.document)
    }

    pub(crate) fn create_mobile_clone(
        source: PathBuf,
        vault: &Path,
        key_material: &Path,
        default_key: &str,
        remote: &GitRemote,
    ) -> Result<Self, ConfigError> {
        Self::create_mobile(source, vault, key_material, default_key, Some(remote))
    }

    pub(crate) fn create_mobile_local(
        source: PathBuf,
        vault: &Path,
        key_material: &Path,
        default_key: &str,
    ) -> Result<Self, ConfigError> {
        Self::create_mobile(source, vault, key_material, default_key, None)
    }

    fn create_mobile(
        source: PathBuf,
        vault: &Path,
        key_material: &Path,
        default_key: &str,
        remote: Option<&GitRemote>,
    ) -> Result<Self, ConfigError> {
        let base = source
            .parent()
            .ok_or(ConfigError::InvalidField { field: "source" })?;
        let vault = vault
            .strip_prefix(base)
            .map_err(|_| ConfigError::InvalidField { field: "vault" })?;
        let key_material =
            key_material
                .strip_prefix(base)
                .map_err(|_| ConfigError::InvalidField {
                    field: "key_material",
                })?;
        let mut root = toml::Table::new();
        root.insert(
            "vault".to_owned(),
            toml::Value::String(path_text(vault, "vault")?),
        );
        root.insert(
            "default_key".to_owned(),
            toml::Value::String(default_key.to_owned()),
        );
        root.insert(
            "key_material".to_owned(),
            toml::Value::String(path_text(key_material, "key_material")?),
        );
        if let Some(remote) = remote {
            let mut configured = toml::Table::new();
            configured.insert(
                "name".to_owned(),
                toml::Value::String(remote.name().as_str().to_owned()),
            );
            configured.insert(
                "url".to_owned(),
                toml::Value::String(remote.url().to_string()),
            );
            configured.insert(
                "server_id".to_owned(),
                toml::Value::String(remote.server_id().as_str().to_owned()),
            );
            configured.insert(
                "application_id".to_owned(),
                toml::Value::String(remote.application_id().as_str().to_owned()),
            );
            let mut git = toml::Table::new();
            git.insert(
                "remotes".to_owned(),
                toml::Value::Array(vec![toml::Value::Table(configured)]),
            );
            root.insert("git".to_owned(), toml::Value::Table(git));
        }
        let document = toml::Value::Table(root);
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: source.clone(),
            })?;
        let config = validate_config(source, document, raw)?;
        config.persist_new()?;
        Ok(config)
    }

    /// Select a configured remote by name, or the configured default (first
    /// remote) when no name was requested.
    pub fn git_remote(&self, requested: Option<&str>) -> Option<&GitRemote> {
        match requested {
            Some(name) => self
                .git_remotes
                .iter()
                .find(|remote| remote.name().as_str() == name),
            None => self.git_remotes.first(),
        }
    }

    /// Resolve the configured editor, then `$VISUAL`, `$EDITOR`, and finally `vim`.
    pub fn resolve_editor(&self) -> Result<ResolvedEditor, EditorError> {
        self.resolve_editor_from(
            env::var_os("VISUAL").as_deref(),
            env::var_os("EDITOR").as_deref(),
        )
    }

    /// Deterministic editor resolution used by adapters and tests.
    pub fn resolve_editor_from(
        &self,
        visual: Option<&std::ffi::OsStr>,
        editor: Option<&std::ffi::OsStr>,
    ) -> Result<ResolvedEditor, EditorError> {
        if let Some(command) = &self.editor {
            return Ok(ResolvedEditor {
                command: command.clone(),
                source: EditorSource::Configuration,
            });
        }
        if let Some(command) = parse_environment_editor("VISUAL", visual)? {
            return Ok(ResolvedEditor {
                command,
                source: EditorSource::VisualEnvironment,
            });
        }
        if let Some(command) = parse_environment_editor("EDITOR", editor)? {
            return Ok(ResolvedEditor {
                command,
                source: EditorSource::EditorEnvironment,
            });
        }
        Ok(ResolvedEditor {
            command: EditorCommand {
                program: "vim".to_owned(),
                arguments: Vec::new(),
            },
            source: EditorSource::Fallback,
        })
    }

    pub(crate) fn with_settings(&self, settings: ConfigSettings) -> Result<Self, ConfigError> {
        let vault =
            fs::canonicalize(&settings.vault).map_err(|_| ConfigError::VaultUnavailable {
                path: settings.vault.clone(),
            })?;
        if !vault.is_dir() {
            return Err(ConfigError::VaultIsNotDirectory { path: vault });
        }
        let mut document = self.document.clone();
        let root = document
            .as_table_mut()
            .ok_or_else(|| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        if vault != self.vault {
            let base = self
                .source
                .parent()
                .ok_or(ConfigError::InvalidField { field: "source" })?;
            let stored = vault.strip_prefix(base).unwrap_or(&vault);
            root.insert(
                "vault".to_owned(),
                toml::Value::String(path_text(stored, "vault")?),
            );
        }
        root.insert(
            "default_key".to_owned(),
            toml::Value::String(settings.default_key),
        );
        match settings.editor {
            Some(editor) => {
                root.insert(
                    "editor".to_owned(),
                    toml::Value::Array(editor.into_iter().map(toml::Value::String).collect()),
                );
            }
            None => {
                root.remove("editor");
            }
        }
        if settings.authentication_timeout.subsec_nanos() != 0 {
            return Err(ConfigError::InvalidField {
                field: "security.inactivity_timeout_seconds",
            });
        }
        let authentication_timeout = i64::try_from(settings.authentication_timeout.as_secs())
            .map_err(|_| ConfigError::InvalidField {
                field: "security.inactivity_timeout_seconds",
            })?;
        let security = root
            .entry("security")
            .or_insert_with(|| toml::Value::Table(toml::Table::new()))
            .as_table_mut()
            .ok_or(ConfigError::InvalidField { field: "security" })?;
        security.insert(
            "inactivity_timeout_seconds".to_owned(),
            toml::Value::Integer(authentication_timeout),
        );
        let raw = document
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: self.source.clone(),
            })?;
        validate_config(self.source.clone(), document, raw)
    }

    pub(crate) fn persist(&self) -> Result<(), ConfigError> {
        let parent = self.source.parent().ok_or_else(|| ConfigError::Write {
            path: self.source.clone(),
        })?;
        let name = self.source.file_name().ok_or_else(|| ConfigError::Write {
            path: self.source.clone(),
        })?;
        let directory =
            Dir::open_ambient_dir(parent, ambient_authority()).map_err(|_| ConfigError::Write {
                path: self.source.clone(),
            })?;
        let permissions = directory
            .metadata(name)
            .map_err(|_| ConfigError::Write {
                path: self.source.clone(),
            })?
            .permissions();
        let contents = toml::to_string_pretty(&self.document).map_err(|_| ConfigError::Write {
            path: self.source.clone(),
        })?;
        let mut temporary = TempFile::new(&directory).map_err(|_| ConfigError::Write {
            path: self.source.clone(),
        })?;
        temporary
            .as_file()
            .set_permissions(permissions)
            .and_then(|()| temporary.write_all(contents.as_bytes()))
            .and_then(|()| temporary.as_file().sync_all())
            .and_then(|()| temporary.replace(name))
            .map_err(|_| ConfigError::Write {
                path: self.source.clone(),
            })
    }

    fn persist_new(&self) -> Result<(), ConfigError> {
        let parent = self.source.parent().ok_or_else(|| ConfigError::Write {
            path: self.source.clone(),
        })?;
        let name = self.source.file_name().ok_or_else(|| ConfigError::Write {
            path: self.source.clone(),
        })?;
        if self.source.exists() {
            return Err(ConfigError::AlreadyConfigured {
                path: self.source.clone(),
            });
        }
        fs::create_dir_all(parent).map_err(|_| ConfigError::Write {
            path: self.source.clone(),
        })?;
        set_private_directory(parent).map_err(|_| ConfigError::Write {
            path: self.source.clone(),
        })?;
        let contents = toml::to_string_pretty(&self.document).map_err(|_| ConfigError::Write {
            path: self.source.clone(),
        })?;
        let temporary = (0..128_u8)
            .find_map(|attempt| {
                let path = parent.join(format!(
                    ".ironstorage-config-{}-{attempt}",
                    rand::random::<u64>()
                ));
                let mut options = OpenOptions::new();
                options.write(true).create_new(true);
                #[cfg(unix)]
                {
                    use std::os::unix::fs::OpenOptionsExt as _;
                    options.mode(0o600);
                }
                match options.open(&path) {
                    Ok(file) => Some(Ok((path, file))),
                    Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => None,
                    Err(_) => Some(Err(ConfigError::Write {
                        path: self.source.clone(),
                    })),
                }
            })
            .transpose()?
            .ok_or_else(|| ConfigError::Write {
                path: self.source.clone(),
            })?;
        let (temporary_path, mut temporary_file) = temporary;
        let installed = temporary_file
            .write_all(contents.as_bytes())
            .and_then(|()| temporary_file.sync_all())
            .and_then(|()| fs::hard_link(&temporary_path, parent.join(name)));
        drop(temporary_file);
        let _ = fs::remove_file(&temporary_path);
        match installed {
            Ok(()) => Ok(()),
            Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {
                Err(ConfigError::AlreadyConfigured {
                    path: self.source.clone(),
                })
            }
            Err(_) => Err(ConfigError::Write {
                path: self.source.clone(),
            }),
        }
    }
}

/// Deterministic path context for configuration loading.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ConfigLoader {
    current_directory: PathBuf,
    native_config_directory: PathBuf,
}

impl ConfigLoader {
    pub fn system() -> Result<Self, ConfigError> {
        let current_directory = env::current_dir().map_err(|_| ConfigError::CurrentDirectory)?;
        let native_config_directory =
            native_config_directory().ok_or(ConfigError::NativeConfigDirectory)?;
        Ok(Self::new(current_directory, native_config_directory))
    }

    pub fn new(current_directory: PathBuf, native_config_directory: PathBuf) -> Self {
        Self {
            current_directory: normalize_absolute(current_directory),
            native_config_directory: normalize_absolute(native_config_directory),
        }
    }

    pub fn default_path(&self) -> PathBuf {
        self.native_config_directory
            .join(APPLICATION_DIRECTORY)
            .join(CONFIG_FILE)
    }

    pub fn load(&self, explicit: Option<&Path>) -> Result<Config, ConfigError> {
        let requested = explicit
            .map(|path| resolve_path(&self.current_directory, path))
            .unwrap_or_else(|| self.default_path());
        let metadata = fs::metadata(&requested).map_err(|error| {
            if error.kind() == std::io::ErrorKind::NotFound {
                ConfigError::NotFound {
                    path: requested.clone(),
                }
            } else {
                ConfigError::Read {
                    path: requested.clone(),
                }
            }
        })?;
        if !metadata.is_file() || metadata.len() > MAX_CONFIG_BYTES {
            return Err(ConfigError::InvalidFile {
                path: requested.clone(),
            });
        }
        let source = fs::canonicalize(&requested).map_err(|_| ConfigError::Read {
            path: requested.clone(),
        })?;
        let contents = fs::read_to_string(&source).map_err(|_| ConfigError::Read {
            path: source.clone(),
        })?;
        let value =
            toml::from_str::<toml::Value>(&contents).map_err(|_| ConfigError::Malformed {
                path: source.clone(),
            })?;
        reject_insecure_fields(&value, "")?;
        validate_known_fields(&value, &source)?;
        let raw = value
            .clone()
            .try_into::<RawConfig>()
            .map_err(|_| ConfigError::Malformed {
                path: source.clone(),
            })?;
        validate_config(source, value, raw)
    }
}

#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
pub struct KeyIdentity(String);

impl KeyIdentity {
    pub fn as_str(&self) -> &str {
        &self.0
    }
}

impl fmt::Display for KeyIdentity {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter.write_str(&self.0)
    }
}

macro_rules! identifier_type {
    ($name:ident) => {
        #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
        pub struct $name(String);

        impl $name {
            pub fn as_str(&self) -> &str {
                &self.0
            }
        }

        impl fmt::Display for $name {
            fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
                formatter.write_str(&self.0)
            }
        }
    };
}

identifier_type!(RemoteName);
identifier_type!(ServerId);
identifier_type!(ApplicationId);

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct GitRemote {
    name: RemoteName,
    url: Url,
    server_id: ServerId,
    application_id: ApplicationId,
}

impl GitRemote {
    pub fn https(
        name: impl Into<String>,
        url: impl Into<String>,
        server_id: impl Into<String>,
        application_id: impl Into<String>,
    ) -> Result<Self, ConfigError> {
        let mut remotes = validate_remotes(vec![RawGitRemote {
            name: name.into(),
            url: url.into(),
            server_id: server_id.into(),
            application_id: application_id.into(),
        }])?;
        Ok(remotes.remove(0))
    }

    pub fn name(&self) -> &RemoteName {
        &self.name
    }

    pub fn url(&self) -> &Url {
        &self.url
    }

    pub fn server_id(&self) -> &ServerId {
        &self.server_id
    }

    pub fn application_id(&self) -> &ApplicationId {
        &self.application_id
    }
}

/// An executable and arguments. It is never interpreted by a shell.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct EditorCommand {
    program: String,
    arguments: Vec<String>,
}

impl EditorCommand {
    pub fn program(&self) -> &str {
        &self.program
    }

    pub fn arguments(&self) -> &[String] {
        &self.arguments
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum EditorSource {
    Configuration,
    VisualEnvironment,
    EditorEnvironment,
    Fallback,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ResolvedEditor {
    command: EditorCommand,
    source: EditorSource,
}

impl ResolvedEditor {
    pub fn command(&self) -> &EditorCommand {
        &self.command
    }

    pub fn source(&self) -> EditorSource {
        self.source
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ConfigError {
    CurrentDirectory,
    NativeConfigDirectory,
    NotFound { path: PathBuf },
    Read { path: PathBuf },
    InvalidFile { path: PathBuf },
    Malformed { path: PathBuf },
    UnknownField { field: String },
    InsecureField { field: String },
    MissingField { field: &'static str },
    InvalidField { field: &'static str },
    VaultUnavailable { path: PathBuf },
    VaultIsNotDirectory { path: PathBuf },
    Write { path: PathBuf },
    AlreadyConfigured { path: PathBuf },
    KeyMaterialNotFound { path: PathBuf },
    InvalidKeyMaterial { path: PathBuf },
    DuplicateRemote { name: String },
    DuplicateCredentialReference,
    InvalidRemoteUrl { name: String },
}

impl fmt::Display for ConfigError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::CurrentDirectory => formatter.write_str("cannot determine the current directory"),
            Self::NativeConfigDirectory => {
                formatter.write_str("cannot determine the native user configuration directory")
            }
            Self::NotFound { path } => {
                write!(
                    formatter,
                    "configuration file not found: {}",
                    path.display()
                )
            }
            Self::Read { path } => {
                write!(
                    formatter,
                    "cannot read configuration file: {}",
                    path.display()
                )
            }
            Self::InvalidFile { path } => write!(
                formatter,
                "configuration path is not a small regular file: {}",
                path.display()
            ),
            Self::Malformed { path } => write!(
                formatter,
                "configuration is malformed; its contents were redacted: {}",
                path.display()
            ),
            Self::UnknownField { field } => {
                write!(formatter, "unknown configuration field: {field}")
            }
            Self::InsecureField { field } => write!(
                formatter,
                "secret values are forbidden in configuration field: {field}"
            ),
            Self::MissingField { field } => {
                write!(formatter, "missing required configuration field: {field}")
            }
            Self::InvalidField { field } => {
                write!(formatter, "invalid configuration field: {field}")
            }
            Self::VaultUnavailable { path } => write!(
                formatter,
                "vault folder is missing or inaccessible: {}",
                path.display()
            ),
            Self::VaultIsNotDirectory { path } => {
                write!(
                    formatter,
                    "vault path is not a directory: {}",
                    path.display()
                )
            }
            Self::Write { path } => {
                write!(
                    formatter,
                    "cannot update configuration file: {}",
                    path.display()
                )
            }
            Self::AlreadyConfigured { path } => write!(
                formatter,
                "configuration already exists and was not replaced: {}",
                path.display()
            ),
            Self::KeyMaterialNotFound { path } => write!(
                formatter,
                "exported key material does not exist: {}",
                path.display()
            ),
            Self::InvalidKeyMaterial { path } => write!(
                formatter,
                "exported key material is not a file or directory: {}",
                path.display()
            ),
            Self::DuplicateRemote { name } => {
                write!(formatter, "duplicate Git remote name: {name}")
            }
            Self::DuplicateCredentialReference => {
                formatter.write_str("duplicate Git server/application credential reference")
            }
            Self::InvalidRemoteUrl { name } => write!(
                formatter,
                "Git remote {name} must be an HTTPS URL without embedded credentials, query, or fragment"
            ),
        }
    }
}

impl Error for ConfigError {}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum EditorError {
    NonUnicode { variable: &'static str },
    InvalidCommand { source: &'static str },
}

impl fmt::Display for EditorError {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::NonUnicode { variable } => {
                write!(formatter, "{variable} is not valid Unicode")
            }
            Self::InvalidCommand { source } => {
                write!(
                    formatter,
                    "{source} does not contain a valid editor command"
                )
            }
        }
    }
}

impl Error for EditorError {}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RawConfig {
    vault: Option<PathBuf>,
    default_key: Option<String>,
    key_material: Option<PathBuf>,
    editor: Option<RawEditor>,
    clipboard_timeout_seconds: Option<u64>,
    #[serde(default)]
    security: RawSecurity,
    #[serde(default)]
    ui: RawUi,
    #[serde(default)]
    git: RawGit,
}

#[derive(Default, Deserialize)]
#[serde(deny_unknown_fields)]
struct RawSecurity {
    inactivity_timeout_seconds: Option<u64>,
    biometric_unlock_enabled: Option<bool>,
}

#[derive(Default, Deserialize)]
#[serde(deny_unknown_fields)]
struct RawUi {
    selected_mobile_tab: Option<String>,
    mobile_appearance: Option<String>,
    home_remote_refreshed_at_unix_seconds: Option<i64>,
    #[serde(default)]
    watch_shared_totp_entries: Vec<String>,
}

#[derive(Deserialize)]
#[serde(untagged)]
enum RawEditor {
    CommandLine(String),
    Arguments(Vec<String>),
}

#[derive(Default, Deserialize)]
#[serde(deny_unknown_fields)]
struct RawGit {
    user_name: Option<String>,
    user_email: Option<String>,
    #[serde(default)]
    remotes: Vec<RawGitRemote>,
}

#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct RawGitRemote {
    name: String,
    url: String,
    server_id: String,
    application_id: String,
}

fn validate_config(
    source: PathBuf,
    mut document: toml::Value,
    raw: RawConfig,
) -> Result<Config, ConfigError> {
    let base = source
        .parent()
        .ok_or(ConfigError::InvalidField { field: "source" })?;
    let vault = resolve_required_path(base, raw.vault, "vault")?;
    if vault.exists() && !vault.is_dir() {
        return Err(ConfigError::VaultIsNotDirectory { path: vault });
    }
    make_local_path_relative(&mut document, base, &vault, "vault")?;

    let key_material = resolve_required_path(base, raw.key_material, "key_material")?;
    if !key_material.exists() {
        return Err(ConfigError::KeyMaterialNotFound { path: key_material });
    }
    let key_metadata =
        fs::metadata(&key_material).map_err(|_| ConfigError::KeyMaterialNotFound {
            path: key_material.clone(),
        })?;
    if !key_metadata.is_file() && !key_metadata.is_dir() {
        return Err(ConfigError::InvalidKeyMaterial { path: key_material });
    }
    let key_material = fs::canonicalize(&key_material)
        .map_err(|_| ConfigError::InvalidKeyMaterial { path: key_material })?;
    make_local_path_relative(&mut document, base, &key_material, "key_material")?;

    let default_key = raw
        .default_key
        .ok_or(ConfigError::MissingField {
            field: "default_key",
        })
        .and_then(validate_key_identity)?;
    let editor = raw.editor.map(validate_editor).transpose()?;
    let clipboard_timeout = ClipboardTimeout::new(Duration::from_secs(
        raw.clipboard_timeout_seconds
            .unwrap_or(DEFAULT_CLIPBOARD_TIMEOUT.as_secs()),
    ))
    .map_err(|_| ConfigError::InvalidField {
        field: "clipboard_timeout_seconds",
    })?;
    let authentication_timeout = AuthenticationTimeout::new(Duration::from_secs(
        raw.security
            .inactivity_timeout_seconds
            .unwrap_or(DEFAULT_AUTHENTICATION_TIMEOUT.as_secs()),
    ))
    .map_err(|_| ConfigError::InvalidField {
        field: "security.inactivity_timeout_seconds",
    })?;
    let biometric_unlock_enabled = raw.security.biometric_unlock_enabled.unwrap_or(false);
    let mobile_appearance = raw
        .ui
        .mobile_appearance
        .as_deref()
        .map(MobileAppearance::from_config)
        .transpose()?
        .unwrap_or_default();
    let mobile_tab = raw
        .ui
        .selected_mobile_tab
        .as_deref()
        .map(MobileTab::from_config)
        .transpose()?
        .unwrap_or_default();
    let mobile_home_refreshed_at = match raw.ui.home_remote_refreshed_at_unix_seconds {
        Some(value) if value > 0 => Some(value),
        Some(_) => {
            return Err(ConfigError::InvalidField {
                field: "ui.home_remote_refreshed_at_unix_seconds",
            });
        }
        None => None,
    };
    let watch_shared_totp_entries = raw
        .ui
        .watch_shared_totp_entries
        .into_iter()
        .map(|entry| {
            EntryPath::parse(&entry).map_err(|_| ConfigError::InvalidField {
                field: "ui.watch_shared_totp_entries",
            })
        })
        .collect::<Result<BTreeSet<_>, _>>()?;
    let git_identity = match (raw.git.user_name, raw.git.user_email) {
        (None, None) => GitIdentity::ironstorage(),
        (Some(name), Some(email)) => {
            GitIdentity::new(name, email).map_err(|_| ConfigError::InvalidField {
                field: "git.user_identity",
            })?
        }
        _ => {
            return Err(ConfigError::InvalidField {
                field: "git.user_identity",
            });
        }
    };
    let git_remotes = validate_remotes(raw.git.remotes)?;

    Ok(Config {
        source,
        document,
        vault,
        default_key,
        key_material,
        editor,
        clipboard_timeout,
        authentication_timeout,
        biometric_unlock_enabled,
        mobile_appearance,
        mobile_tab,
        mobile_home_refreshed_at,
        watch_shared_totp_entries,
        git_identity,
        git_remotes,
    })
}

fn resolve_required_path(
    base: &Path,
    value: Option<PathBuf>,
    field: &'static str,
) -> Result<PathBuf, ConfigError> {
    let value = value.ok_or(ConfigError::MissingField { field })?;
    if value.as_os_str().is_empty() {
        return Err(ConfigError::InvalidField { field });
    }
    let resolved = resolve_path(base, &value);
    if resolved.exists() || !value.is_absolute() {
        return Ok(resolved);
    }
    Ok(relocated_mobile_path(base, &resolved, field).unwrap_or(resolved))
}

fn relocated_mobile_path(base: &Path, path: &Path, field: &'static str) -> Option<PathBuf> {
    let leaf = match field {
        "vault" => "vault",
        "key_material" => "keys",
        _ => return None,
    };
    let suffix = Path::new("Library/Application Support/ironstorage").join(leaf);
    let is_stale_mobile_path = [
        Path::new("/private/var/mobile/Containers/Data/Application"),
        Path::new("/var/mobile/Containers/Data/Application"),
    ]
    .iter()
    .any(|prefix| {
        path.strip_prefix(prefix).is_ok_and(|relative| {
            let mut components = relative.components();
            components.next().is_some() && components.as_path() == suffix
        })
    });
    let relocated = base.join(leaf);
    (is_stale_mobile_path && relocated.exists()).then_some(relocated)
}

fn make_local_path_relative(
    document: &mut toml::Value,
    base: &Path,
    path: &Path,
    field: &'static str,
) -> Result<(), ConfigError> {
    let Ok(relative) = path.strip_prefix(base) else {
        return Ok(());
    };
    let root = document
        .as_table_mut()
        .ok_or_else(|| ConfigError::Malformed {
            path: base.join(CONFIG_FILE),
        })?;
    root.insert(
        field.to_owned(),
        toml::Value::String(path_text(relative, field)?),
    );
    Ok(())
}

fn path_text(path: &Path, field: &'static str) -> Result<String, ConfigError> {
    path.to_str()
        .map(str::to_owned)
        .ok_or(ConfigError::InvalidField { field })
}

fn set_private_directory(path: &Path) -> std::io::Result<()> {
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt as _;
        fs::set_permissions(path, fs::Permissions::from_mode(0o700))?;
    }
    #[cfg(not(unix))]
    let _ = path;
    Ok(())
}

fn validate_key_identity(value: String) -> Result<KeyIdentity, ConfigError> {
    let trimmed = value.trim();
    if trimmed.is_empty()
        || trimmed.len() > 512
        || trimmed.chars().any(char::is_control)
        || trimmed != value
    {
        return Err(ConfigError::InvalidField {
            field: "default_key",
        });
    }
    Ok(KeyIdentity(value))
}

fn validate_editor(raw: RawEditor) -> Result<EditorCommand, ConfigError> {
    let words = match raw {
        RawEditor::CommandLine(command) => {
            shlex::split(&command).ok_or(ConfigError::InvalidField { field: "editor" })?
        }
        RawEditor::Arguments(arguments) => arguments,
    };
    editor_from_words(words).map_err(|_| ConfigError::InvalidField { field: "editor" })
}

fn editor_from_words(mut words: Vec<String>) -> Result<EditorCommand, ()> {
    if words.is_empty() || words.iter().any(|word| word.contains('\0')) {
        return Err(());
    }
    let program = words.remove(0);
    if program.is_empty() {
        return Err(());
    }
    Ok(EditorCommand {
        program,
        arguments: words,
    })
}

fn parse_environment_editor(
    variable: &'static str,
    value: Option<&std::ffi::OsStr>,
) -> Result<Option<EditorCommand>, EditorError> {
    let Some(value) = value else {
        return Ok(None);
    };
    if value.is_empty() {
        return Ok(None);
    }
    let value = value.to_str().ok_or(EditorError::NonUnicode { variable })?;
    let words = shlex::split(value).ok_or(EditorError::InvalidCommand { source: variable })?;
    editor_from_words(words)
        .map(Some)
        .map_err(|()| EditorError::InvalidCommand { source: variable })
}

fn validate_remotes(raw: Vec<RawGitRemote>) -> Result<Vec<GitRemote>, ConfigError> {
    let mut names = BTreeSet::new();
    let mut references = BTreeSet::new();
    let mut remotes = Vec::with_capacity(raw.len());
    for remote in raw {
        let name = RemoteName(validate_identifier("git.remotes.name", remote.name)?);
        let server_id = ServerId(validate_identifier(
            "git.remotes.server_id",
            remote.server_id,
        )?);
        let application_id = ApplicationId(validate_identifier(
            "git.remotes.application_id",
            remote.application_id,
        )?);
        if !names.insert(name.clone()) {
            return Err(ConfigError::DuplicateRemote {
                name: name.0.clone(),
            });
        }
        if !references.insert((server_id.clone(), application_id.clone())) {
            return Err(ConfigError::DuplicateCredentialReference);
        }
        let url = Url::parse(&remote.url).map_err(|_| ConfigError::InvalidRemoteUrl {
            name: name.0.clone(),
        })?;
        if url.scheme() != "https"
            || url.host_str().is_none()
            || !url.username().is_empty()
            || url.password().is_some()
            || url.query().is_some()
            || url.fragment().is_some()
        {
            return Err(ConfigError::InvalidRemoteUrl {
                name: name.0.clone(),
            });
        }
        remotes.push(GitRemote {
            name,
            url,
            server_id,
            application_id,
        });
    }
    Ok(remotes)
}

fn validate_identifier(field: &'static str, value: String) -> Result<String, ConfigError> {
    if value.is_empty()
        || value.len() > 128
        || !value
            .bytes()
            .all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'.' | b'_' | b'-'))
    {
        return Err(ConfigError::InvalidField { field });
    }
    Ok(value)
}

fn validate_known_fields(value: &toml::Value, source: &Path) -> Result<(), ConfigError> {
    let root = value.as_table().ok_or_else(|| ConfigError::UnknownField {
        field: "<root>".to_owned(),
    })?;
    validate_table(
        root,
        "",
        &[
            "vault",
            "default_key",
            "key_material",
            "editor",
            "clipboard_timeout_seconds",
            "security",
            "ui",
            "git",
        ],
    )?;
    if let Some(security) = root.get("security") {
        let security = security.as_table().ok_or_else(|| ConfigError::Malformed {
            path: source.to_owned(),
        })?;
        validate_table(
            security,
            "security",
            &["inactivity_timeout_seconds", "biometric_unlock_enabled"],
        )?;
    }
    if let Some(ui) = root.get("ui") {
        let ui = ui.as_table().ok_or_else(|| ConfigError::Malformed {
            path: source.to_owned(),
        })?;
        validate_table(
            ui,
            "ui",
            &[
                "selected_mobile_tab",
                "mobile_appearance",
                "home_remote_refreshed_at_unix_seconds",
                "watch_shared_totp_entries",
            ],
        )?;
    }
    let Some(git) = root.get("git") else {
        return Ok(());
    };
    let git = git.as_table().ok_or_else(|| ConfigError::Malformed {
        path: source.to_owned(),
    })?;
    validate_table(git, "git", &["user_name", "user_email", "remotes"])?;
    if let Some(remotes) = git.get("remotes") {
        let remotes = remotes.as_array().ok_or_else(|| ConfigError::Malformed {
            path: source.to_owned(),
        })?;
        for (index, remote) in remotes.iter().enumerate() {
            let remote = remote.as_table().ok_or_else(|| ConfigError::Malformed {
                path: source.to_owned(),
            })?;
            validate_table(
                remote,
                &format!("git.remotes[{index}]"),
                &["name", "url", "server_id", "application_id"],
            )?;
        }
    }
    Ok(())
}

fn validate_table(table: &toml::Table, prefix: &str, allowed: &[&str]) -> Result<(), ConfigError> {
    for key in table.keys() {
        if !allowed.contains(&key.as_str()) {
            let field = if prefix.is_empty() {
                key.clone()
            } else {
                format!("{prefix}.{key}")
            };
            return Err(ConfigError::UnknownField { field });
        }
    }
    Ok(())
}

fn reject_insecure_fields(value: &toml::Value, prefix: &str) -> Result<(), ConfigError> {
    match value {
        toml::Value::Table(table) => {
            for (key, nested) in table {
                let path = if prefix.is_empty() {
                    key.clone()
                } else {
                    format!("{prefix}.{key}")
                };
                let normalized = key.to_ascii_lowercase().replace('-', "_");
                if [
                    "password",
                    "passphrase",
                    "token",
                    "secret",
                    "credential",
                    "credentials",
                    "private_key",
                ]
                .contains(&normalized.as_str())
                {
                    return Err(ConfigError::InsecureField { field: path });
                }
                reject_insecure_fields(nested, &path)?;
            }
        }
        toml::Value::Array(values) => {
            for (index, nested) in values.iter().enumerate() {
                reject_insecure_fields(nested, &format!("{prefix}[{index}]"))?;
            }
        }
        _ => {}
    }
    Ok(())
}

fn resolve_path(base: &Path, path: &Path) -> PathBuf {
    if path.is_absolute() {
        normalize_absolute(path.to_owned())
    } else {
        normalize_absolute(base.join(path))
    }
}

fn normalize_absolute(path: PathBuf) -> PathBuf {
    let mut normalized = PathBuf::new();
    for component in path.components() {
        match component {
            Component::CurDir => {}
            Component::ParentDir => {
                if !normalized.pop() {
                    normalized.push(component.as_os_str());
                }
            }
            _ => normalized.push(component.as_os_str()),
        }
    }
    normalized
}

#[cfg(target_os = "windows")]
fn native_config_directory() -> Option<PathBuf> {
    env::var_os("APPDATA").map(PathBuf::from)
}

#[cfg(target_os = "macos")]
fn native_config_directory() -> Option<PathBuf> {
    env::var_os("HOME")
        .map(PathBuf::from)
        .map(|home| home.join("Library/Application Support"))
}

#[cfg(target_os = "ios")]
fn native_config_directory() -> Option<PathBuf> {
    env::var_os("HOME")
        .map(PathBuf::from)
        .map(|home| home.join("Library/Application Support"))
}

#[cfg(all(unix, not(any(target_os = "ios", target_os = "macos"))))]
fn native_config_directory() -> Option<PathBuf> {
    match env::var_os("XDG_CONFIG_HOME") {
        Some(path) if !path.is_empty() && Path::new(&path).is_absolute() => {
            Some(PathBuf::from(path))
        }
        _ => env::var_os("HOME")
            .filter(|home| !home.is_empty())
            .map(PathBuf::from)
            .map(|home| home.join(".config")),
    }
}

#[cfg(not(any(unix, target_os = "windows")))]
fn native_config_directory() -> Option<PathBuf> {
    None
}

#[cfg(test)]
mod tests {
    use std::fs;

    use crate::mobile::MobileTab;

    use super::{Config, ConfigError, GitRemote};

    #[test]
    fn mobile_clone_configuration_is_secret_free_and_never_replaced() {
        let temporary = tempfile::tempdir().expect("temporary directory");
        let original = temporary.path().join("original");
        let relocated = temporary.path().join("relocated");
        let vault = original.join("vault");
        let keys = original.join("keys");
        let source = original.join("config.toml");
        fs::create_dir_all(&vault).expect("vault");
        fs::create_dir(&keys).expect("keys");
        let remote = GitRemote::https(
            "origin",
            "https://example.test/team/passwords.git",
            "server-example",
            "repository-example",
        )
        .expect("remote");
        let config = Config::create_mobile_clone(source.clone(), &vault, &keys, "ALICE", &remote)
            .expect("create config");
        assert_eq!(config.mobile_home_refreshed_at(), None);
        config
            .update_mobile_home_refresh(1_789_000_000)
            .expect("persist refresh time");
        Config::load(Some(&source))
            .expect("reload timestamped config")
            .update_mobile_tab(MobileTab::Preferences)
            .expect("persist tab after refresh time");
        let contents = fs::read_to_string(&source).expect("read config");
        assert!(!contents.contains("token ="));
        assert!(!contents.contains("password ="));
        assert!(!contents.contains(&original.to_string_lossy().into_owned()));
        assert!(contents.contains("vault = \"vault\""));
        assert!(contents.contains("key_material = \"keys\""));
        assert!(contents.contains("https://example.test/team/passwords.git"));
        assert_eq!(
            Config::create_mobile_clone(source.clone(), &vault, &keys, "BOB", &remote)
                .expect_err("must not replace existing config"),
            ConfigError::AlreadyConfigured {
                path: source.clone()
            }
        );
        fs::rename(&original, &relocated).expect("relocate app container");
        let relocated_config =
            Config::load(Some(&relocated.join("config.toml"))).expect("reload config");
        assert_eq!(
            (
                relocated_config.default_key().as_str(),
                relocated_config.mobile_home_refreshed_at(),
                relocated_config.mobile_tab(),
            ),
            ("ALICE", Some(1_789_000_000), MobileTab::Preferences)
        );
    }

    #[test]
    fn stale_ios_container_path_follows_the_current_container() {
        let temporary = tempfile::tempdir().expect("temporary directory");
        let vault = temporary.path().join("vault");
        let keys = temporary.path().join("keys");
        let source = temporary.path().join("config.toml");
        fs::create_dir(&vault).expect("vault");
        fs::create_dir(&keys).expect("keys");
        fs::write(
            &source,
            r#"vault = "/private/var/mobile/Containers/Data/Application/OLD-CONTAINER/Library/Application Support/ironstorage/vault"
default_key = "ALICE"
key_material = "keys"
"#,
        )
        .expect("config");

        let config = Config::load(Some(&source)).expect("recover moved container");
        assert_eq!(config.vault(), fs::canonicalize(vault).expect("vault path"));
        config
            .update_mobile_tab(MobileTab::Preferences)
            .expect("persist recovered config");
        let contents = fs::read_to_string(source).expect("read config");
        assert!(contents.contains("vault = \"vault\""));
        assert!(!contents.contains("OLD-CONTAINER"));
    }
}