GitCorner

Code

ossartcrafttexturecraft🌐
d84914ef1e5a
//! The UI state kept between runs as JSON: `ui.json` beside eframe's settings on the desktop, a key of eframe's storage on the web

use std::path::{Path, PathBuf};
use std::sync::OnceLock;

use crate::UiState;

/// eframe storage key of the UI state as JSON, where there is no file
const STORAGE_KEY: &str = "ui.json";

/// Name of the UI state in eframe's storage, before the extension, for the copies of unreadable states kept there
const STORAGE_STEM: &str = "ui";

/// eframe storage key under which earlier builds kept the UI state, as RON
const RON_STORAGE_KEY: &str = "ui";
/// Textures moved from index 8 to index 6 when procedurals joined that type
const LEGACY_TEXTURES_TAB: usize = 8;
const TEXTURES_TAB: usize = 6;

/// Maximum encoded UI state size for both reads and writes; typical states are a few kilobytes
const MAX_FILE_BYTES: u64 = 16 * 1024 * 1024;

/// Copies of unreadable saved states kept before saving stops
const MAX_UNREADABLE_COPIES: u32 = 10;

/// The desktop's `ui.json`, set by the app before its window opens; unset, the state stays in eframe's storage
pub static FILE: OnceLock<PathBuf> = OnceLock::new();

/// Where the UI state is saved, holding a saved state this build could not fully read until it is kept beside it
#[derive(Default)]
pub struct UiStateStore {
    file: Option<PathBuf>,
    /// A saved state this build could not fully read and its file extension, kept by the next save
    unreadable: Option<(Vec<u8>, &'static str)>,
    /// A saved state could not be read or kept, so it is left as it is
    frozen: bool,
    warning: Option<String>,
    last_warning: Option<String>,
}

impl UiStateStore {
    /// The store at `file`, or in eframe's storage without one
    pub fn new(file: Option<PathBuf>) -> Self {
        UiStateStore { file, ..Self::default() }
    }

    /// The saved UI state, else the one an earlier build saved; a state not fully read is kept for the next save
    pub fn load(&mut self, storage: Option<&dyn eframe::Storage>) -> Option<UiState> {
        let saved = match &self.file {
            Some(file) => match read_bytes(file) {
                Ok(bytes) => Some(bytes),
                Err(error) if error.kind() == std::io::ErrorKind::NotFound => None,
                Err(error) => {
                    self.frozen = true;
                    self.warn(&format!(
                        "Settings could not be read: {error}. Saving is disabled for this session. Back up the settings, check access and restart."
                    ));
                    return None;
                }
            },
            None => storage.and_then(|storage| storage.get_string(STORAGE_KEY)).map(String::into_bytes),
        };
        let Some(bytes) = saved else { return self.load_ron(storage?) };

        if bytes.len() as u64 > MAX_FILE_BYTES {
            self.frozen = true;
            self.warn("Settings exceed the 16 MiB limit. Saving is disabled for this session. Back up the settings and reduce their size before restarting.");
            return None;
        }

        let ui = decode_json_ui(&bytes);
        if !ui.as_ref().is_some_and(fully_read) {
            self.unreadable = Some((bytes, "json"));
        }
        ui
    }

    /// Preserve the original RON when decoding loses either dock, even if other settings load
    fn load_ron(&mut self, storage: &dyn eframe::Storage) -> Option<UiState> {
        let text = storage.get_string(RON_STORAGE_KEY)?;
        let mut ui = eframe::get_value::<UiState>(storage, RON_STORAGE_KEY);
        if let Some(ui) = &mut ui {
            migrate_shelf_tab(ui, ron_has_shelf_path(&text));
        }
        if !ui.as_ref().is_some_and(fully_read) {
            self.unreadable = Some((text.into_bytes(), "ron"));
        }
        ui
    }

    /// Save `ui` as JSON once an unreadable saved state is kept, and drop the RON copy of earlier builds
    pub fn save(&mut self, ui: &UiState, storage: &mut dyn eframe::Storage) {
        if self.frozen {
            return;
        }

        let json = match serde_json::to_string_pretty(ui) {
            Ok(json) => json,
            Err(error) => {
                self.warn(&format!("Settings could not be encoded: {error}. The previous settings have been kept."));
                return;
            }
        };
        if json.len() as u64 > MAX_FILE_BYTES {
            self.warn("Settings were not saved because they exceed the 16 MiB limit. Reduce their size and try again. The previous settings have been kept.");
            return;
        }

        // JSON turns non-finite numbers into null; a dock can also silently fall back during decoding
        if !serde_json::from_str::<UiState>(&json).as_ref().is_ok_and(fully_read) {
            self.warn(
                "Settings were not saved because they would not read back. Reset invalid view settings and try again. The previous settings have been kept.",
            );
            return;
        }

        if let Some((bytes, extension)) = self.unreadable.take()
            && !self.keep_unreadable(&bytes, extension, storage)
        {
            self.frozen = true;
            self.warn("The previous settings could not be backed up. Saving is disabled for this session. Check free space and access, move existing unreadable backups to a safe place, then restart.");
            return;
        }

        let saved = match &self.file {
            Some(file) => write_file(file, json.as_bytes()),
            None => write_storage(storage, STORAGE_KEY, json),
        };
        if saved {
            storage.remove_string(RON_STORAGE_KEY);
            self.warning = None;
            self.last_warning = None;
        } else {
            self.warn("Settings could not be saved. Check free space and write access, or browser storage permissions and quota. The previous settings have been kept; saving will be retried.");
        }
    }

    /// A new storage warning for the app to show once, until saving succeeds again
    pub fn take_warning(&mut self) -> Option<String> {
        self.warning.take()
    }

    fn warn(&mut self, detail: &str) {
        let location = self.file.as_ref().map_or_else(|| "browser/app storage".to_owned(), |file| file.display().to_string());
        let warning = format!("UI settings ({location}): {detail}");
        if self.last_warning.as_ref() != Some(&warning) {
            log::warn!("{warning}");
            self.warning = Some(warning.clone());
            self.last_warning = Some(warning);
        }
    }

    /// Keep a saved state this build could not fully read under the first free copy name, beside the file or in storage
    fn keep_unreadable(&self, bytes: &[u8], extension: &str, storage: &mut dyn eframe::Storage) -> bool {
        match &self.file {
            Some(file) => keep_file_copy(file, bytes, extension),
            None => {
                let free = (1..=MAX_UNREADABLE_COPIES).map(|n| unreadable_name(STORAGE_STEM, n, extension)).find(|key| storage.get_string(key).is_none());
                let Some(key) = free else { return false };

                write_storage(storage, &key, String::from_utf8_lossy(bytes).into_owned())
            }
        }
    }
}

/// Old saved states have no shelf path, so their former Textures index needs remapping
fn migrate_shelf_tab(ui: &mut UiState, has_shelf_path: bool) {
    if ui.shelf_tab == LEGACY_TEXTURES_TAB && !has_shelf_path {
        ui.shelf_tab = TEXTURES_TAB;
    }
}

/// Decode JSON settings and map the old Textures index only when its new fields are absent
fn decode_json_ui(bytes: &[u8]) -> Option<UiState> {
    let mut ui = serde_json::from_slice::<UiState>(bytes).ok()?;
    if ui.shelf_tab == LEGACY_TEXTURES_TAB {
        let has_shelf_path = serde_json::from_slice::<serde_json::Value>(bytes)
            .ok()
            .and_then(|state| state.as_object().map(|fields| fields.contains_key("shelf_path")))
            .unwrap_or(true);
        migrate_shelf_tab(&mut ui, has_shelf_path);
    }
    Some(ui)
}

/// Ignore user text while looking for the field in legacy RON settings
fn ron_has_shelf_path(text: &str) -> bool {
    let bytes = text.as_bytes();
    let mut quoted = false;
    let mut escaped = false;
    for (index, byte) in bytes.iter().enumerate() {
        if quoted {
            if escaped {
                escaped = false;
            } else if *byte == b'\\' {
                escaped = true;
            } else if *byte == b'"' {
                quoted = false;
            }
        } else if *byte == b'"' {
            quoted = true;
        } else if bytes[index..].starts_with(b"shelf_path:") && (index == 0 || matches!(bytes[index - 1], b',' | b'(' | b' ' | b'\n')) {
            return true;
        }
    }
    false
}

/// The UI state saved in `file`, if it reads
pub fn read(file: &Path) -> Option<UiState> {
    decode_json_ui(&read_bytes(file).ok()?)
}

/// eframe's browser storage reports write failures only through logging, so verify before discarding old settings
fn write_storage(storage: &mut dyn eframe::Storage, key: &str, text: String) -> bool {
    storage.set_string(key, text.clone());
    storage.get_string(key).as_deref() == Some(text.as_str())
}

#[cfg(not(target_arch = "wasm32"))]
fn read_bytes(file: &Path) -> std::io::Result<Vec<u8>> {
    use std::io::Read as _;

    let input = std::fs::File::open(file)?;
    let too_large = || std::io::Error::new(std::io::ErrorKind::InvalidData, "UI settings exceed the 16 MiB limit");
    if input.metadata()?.len() > MAX_FILE_BYTES {
        return Err(too_large());
    }

    // Bound the read itself in case the file grows after its metadata was checked
    let mut bytes = Vec::new();
    input.take(MAX_FILE_BYTES + 1).read_to_end(&mut bytes)?;
    if bytes.len() as u64 > MAX_FILE_BYTES {
        return Err(too_large());
    }

    Ok(bytes)
}

#[cfg(target_arch = "wasm32")]
fn read_bytes(_file: &Path) -> std::io::Result<Vec<u8>> {
    Err(std::io::Error::new(std::io::ErrorKind::Unsupported, "UI settings use browser storage"))
}

/// Whether every dock, the two in use and those of the named layouts, was read rather than replaced by a default
fn fully_read(ui: &UiState) -> bool {
    !ui.dock.replaced_unreadable()
        && !ui.inactive_mode_dock.replaced_unreadable()
        && ui.named_layouts.iter().all(|layout| !layout.painting.replaced_unreadable() && !layout.baking.replaced_unreadable())
}

/// The `n`th copy name of an unreadable state: `<stem>.unreadable.<extension>`, then `<stem>.unreadable-N.<extension>`
fn unreadable_name(stem: &str, n: u32, extension: &str) -> String {
    if n == 1 { format!("{stem}.unreadable.{extension}") } else { format!("{stem}.unreadable-{n}.{extension}") }
}

#[cfg(not(target_arch = "wasm32"))]
fn write_file(file: &Path, bytes: &[u8]) -> bool {
    if let Some(folder) = file.parent() {
        let _ = std::fs::create_dir_all(folder);
    }

    texturecraft_engine::formats::write_atomic(file, bytes).is_ok()
}

#[cfg(target_arch = "wasm32")]
fn write_file(_file: &Path, _bytes: &[u8]) -> bool {
    false
}

/// Copy `bytes` beside `file` under the first free copy name
#[cfg(not(target_arch = "wasm32"))]
fn keep_file_copy(file: &Path, bytes: &[u8], extension: &str) -> bool {
    use std::io::Write as _;

    let stem = file.file_stem().map(|stem| stem.to_string_lossy().into_owned()).unwrap_or_default();
    for n in 1..=MAX_UNREADABLE_COPIES {
        let copy_file = file.with_file_name(unreadable_name(&stem, n, extension));
        match std::fs::OpenOptions::new().write(true).create_new(true).open(copy_file) {
            Ok(mut copy) => return copy.write_all(bytes).is_ok(),
            Err(error) if error.kind() == std::io::ErrorKind::AlreadyExists => {}
            Err(_) => return false,
        }
    }
    false
}

#[cfg(target_arch = "wasm32")]
fn keep_file_copy(_file: &Path, _bytes: &[u8], _extension: &str) -> bool {
    false
}

#[cfg(test)]
mod memory_storage;

#[cfg(test)]
pub(crate) mod tests {
    use super::memory_storage::MemoryStorage;
    use super::*;
    use crate::docking::{Dock, Panel, default_workspace, permissions};
    use craft_ui::docking::{Action, Placement};

    /// Save `ui` and load it back, as closing and reopening the app does
    pub(crate) fn restart(ui: &UiState) -> UiState {
        let mut storage = MemoryStorage::default();
        UiStateStore::default().save(ui, &mut storage);
        UiStateStore::default().load(Some(&storage)).unwrap_or_else(|| panic!("the saved state loads: {:?}", storage.values))
    }

    /// An empty folder of its own for one test
    fn test_folder(name: &str) -> PathBuf {
        let folder = std::env::temp_dir().join(format!("texturecraft-ui-store-{name}-{}", std::process::id()));
        let _ = std::fs::remove_dir_all(&folder);
        std::fs::create_dir_all(&folder).unwrap();
        folder
    }

    /// The painting default with Layers moved into a tab beside Assets and Properties floating
    fn moved_panels() -> Dock {
        let mut workspace = default_workspace();
        let actions = [
            Action::Move { panel: Panel::Layers, anchor: Panel::Assets, placement: Placement::Tab { before: None } },
            Action::Float { panel: Panel::Properties, rect: [900.0, 120.0, 320.0, 400.0] },
        ];
        workspace.apply_all(actions, permissions).unwrap();

        let dock = Dock::from_value(serde_json::to_value(&workspace).unwrap());
        assert!(!dock.replaced_unreadable(), "the moved layout is valid");
        dock
    }

    #[test]
    fn panel_layouts_survive_a_restart_in_the_file_and_in_storage() {
        let folder = test_folder("layouts");
        for dock in [Dock::default(), moved_panels()] {
            let ui = UiState { dock, split_ratio: 0.3, ..UiState::default() };
            for file in [None, Some(folder.join("ui.json"))] {
                let mut storage = MemoryStorage::default();
                UiStateStore::new(file.clone()).save(&ui, &mut storage);

                let restarted = UiStateStore::new(file.clone()).load(Some(&storage)).unwrap();
                assert!(fully_read(&restarted), "{file:?}");
                assert_eq!(restarted, ui, "{file:?}");
            }
        }
        std::fs::remove_dir_all(&folder).unwrap();
    }

    #[test]
    fn the_state_an_earlier_build_saved_loads_and_its_copy_goes_on_the_next_save() {
        let mut storage = MemoryStorage::default();
        let earlier = UiState { split_ratio: 0.3, ..UiState::default() };
        eframe::set_value(&mut storage, RON_STORAGE_KEY, &earlier);

        let mut store = UiStateStore::default();
        let loaded = store.load(Some(&storage)).expect("the earlier state loads");
        assert_eq!(loaded.split_ratio, 0.3);

        store.save(&loaded, &mut storage);
        assert!(!storage.values.contains_key(RON_STORAGE_KEY));
        assert_eq!(UiStateStore::default().load(Some(&storage)).unwrap(), loaded);
    }

    #[test]
    fn legacy_ron_textures_index_migrates_to_the_combined_type() {
        let mut storage = MemoryStorage::default();
        let legacy = include_str!("../tests/fixture/ui_state_before_json.ron")
            .replace("shelf_tab:0", "shelf_tab:8")
            .replace("shelf_filter:\"\"", "shelf_filter:\"shelf_path:\"");
        assert!(legacy.contains("shelf_tab:8") && !ron_has_shelf_path(&legacy));
        storage.values.insert(RON_STORAGE_KEY.into(), legacy);

        let loaded = UiStateStore::default().load(Some(&storage)).expect("the legacy state loads");

        assert_eq!(loaded.shelf_tab, TEXTURES_TAB);
    }

    #[test]
    fn an_unreadable_layout_loads_the_default_and_is_kept_beside_the_file() {
        let folder = test_folder("unreadable");
        let file = folder.join("ui.json");
        let ui = UiState { dock: moved_panels(), split_ratio: 0.3, ..UiState::default() };
        let mut storage = MemoryStorage::default();
        UiStateStore::new(Some(file.clone())).save(&ui, &mut storage);
        let saved = std::fs::read_to_string(&file).unwrap();
        assert!(saved.contains("\"Assets\"") && saved.contains("\"version\": 2"), "{saved}");

        let unreadable = [
            // A panel this build does not know
            saved.replacen("\"Assets\"", "\"Bogus\"", 1),
            // A layout from a newer format
            saved.replacen("\"version\": 2", "\"version\": 99", 1),
            // Not a saved state
            "not json".to_owned(),
        ];
        for (n, text) in unreadable.iter().enumerate() {
            std::fs::write(&file, text).unwrap();
            let mut store = UiStateStore::new(Some(file.clone()));
            let loaded = store.load(Some(&storage));
            if let Some(loaded) = &loaded {
                assert_eq!(loaded.dock, Dock::default(), "{text}");
                assert_eq!(loaded.split_ratio, 0.3, "{text}");
            }

            store.save(&loaded.unwrap_or_default(), &mut storage);
            let copy = unreadable_name("ui", n as u32 + 1, "json");
            assert_eq!(std::fs::read_to_string(folder.join(copy)).unwrap(), *text);
            assert_ne!(std::fs::read_to_string(&file).unwrap(), *text, "the next save replaces it once kept");
        }
        std::fs::remove_dir_all(&folder).unwrap();
    }

    #[test]
    fn an_unreadable_named_layout_keeps_a_copy_of_the_state_before_the_next_save() {
        let folder = test_folder("unreadable-named");
        let file = folder.join("ui.json");
        let mut ui = UiState { dock: moved_panels(), ..UiState::default() };
        assert!(ui.save_named_layout("mine"));
        let mut storage = MemoryStorage::default();
        UiStateStore::new(Some(file.clone())).save(&ui, &mut storage);
        let saved = std::fs::read_to_string(&file).unwrap();

        // The last "Assets" belongs to the saved layout; the docks in use come first
        let at = saved.rfind("\"Assets\"").expect("the named layout holds Assets");
        let broken = format!("{}\"Bogus\"{}", &saved[..at], &saved[at + "\"Assets\"".len()..]);
        std::fs::write(&file, &broken).unwrap();

        let mut store = UiStateStore::new(Some(file.clone()));
        let loaded = store.load(Some(&storage)).expect("the state loads");
        assert_eq!(loaded.dock, ui.dock, "the docks in use were readable");
        assert!(!fully_read(&loaded), "the damaged named layout counts as unread");

        store.save(&loaded, &mut storage);
        assert_eq!(std::fs::read_to_string(folder.join(unreadable_name("ui", 1, "json"))).unwrap(), broken);
        std::fs::remove_dir_all(&folder).unwrap();
    }

    #[test]
    fn valid_named_layouts_and_none_at_all_count_as_read() {
        let mut ui = UiState::default();
        assert!(fully_read(&ui));
        ui.save_named_layout("mine");
        assert!(fully_read(&restart(&ui)));
    }

    #[test]
    fn an_unreadable_state_that_cannot_be_kept_is_not_saved_over() {
        let folder = test_folder("frozen");
        let file = folder.join("ui.json");
        for n in 1..=MAX_UNREADABLE_COPIES {
            std::fs::write(folder.join(unreadable_name("ui", n, "json")), "").unwrap();
        }
        std::fs::write(&file, "not json").unwrap();

        let mut store = UiStateStore::new(Some(file.clone()));
        let mut storage = MemoryStorage::default();
        assert!(store.load(Some(&storage)).is_none());
        store.save(&UiState::default(), &mut storage);
        store.save(&UiState::default(), &mut storage);
        assert_eq!(std::fs::read_to_string(&file).unwrap(), "not json");
        std::fs::remove_dir_all(&folder).unwrap();
    }

    #[test]
    fn a_file_too_large_to_read_is_not_saved_over() {
        let folder = test_folder("too-large");
        let file = folder.join("ui.json");
        std::fs::write(&file, vec![b' '; MAX_FILE_BYTES as usize + 1]).unwrap();

        let mut store = UiStateStore::new(Some(file.clone()));
        let mut storage = MemoryStorage::default();
        assert!(store.load(Some(&storage)).is_none());
        store.save(&UiState::default(), &mut storage);
        assert_eq!(std::fs::metadata(&file).unwrap().len(), MAX_FILE_BYTES + 1);
        std::fs::remove_dir_all(&folder).unwrap();
    }

    #[test]
    fn unreadable_layouts_in_storage_are_each_kept_under_a_key_of_their_own() {
        let mut storage = MemoryStorage::default();
        UiStateStore::default().save(&UiState { dock: moved_panels(), ..UiState::default() }, &mut storage);
        let saved = storage.values[STORAGE_KEY].clone();

        for (n, panel) in [(1, "\"Bogus\""), (2, "\"Other\"")] {
            let unreadable = saved.replacen("\"Assets\"", panel, 1);
            storage.values.insert(STORAGE_KEY.to_owned(), unreadable.clone());

            let mut store = UiStateStore::default();
            let loaded = store.load(Some(&storage)).unwrap();
            assert_eq!(loaded.dock, Dock::default());
            store.save(&loaded, &mut storage);
            assert_eq!(storage.values[&unreadable_name(STORAGE_STEM, n, "json")], unreadable);
            assert_eq!(UiStateStore::default().load(Some(&storage)).unwrap(), loaded);
        }
        assert_eq!(storage.values[&unreadable_name(STORAGE_STEM, 1, "json")], saved.replacen("\"Assets\"", "\"Bogus\"", 1), "the first copy stays");
    }

    #[test]
    fn an_earlier_state_that_does_not_parse_is_kept_before_its_entry_goes() {
        let folder = test_folder("ron");
        for file in [None, Some(folder.join("ui.json"))] {
            let mut storage = MemoryStorage::default();
            storage.values.insert(RON_STORAGE_KEY.to_owned(), "(not ron".to_owned());

            let mut store = UiStateStore::new(file.clone());
            assert!(store.load(Some(&storage)).is_none());
            store.save(&UiState::default(), &mut storage);
            let copy = match &file {
                Some(_) => std::fs::read_to_string(folder.join(unreadable_name("ui", 1, "ron"))).unwrap(),
                None => storage.values[&unreadable_name(STORAGE_STEM, 1, "ron")].clone(),
            };
            assert_eq!(copy, "(not ron", "{file:?}");
            assert!(!storage.values.contains_key(RON_STORAGE_KEY), "{file:?}");
        }
        std::fs::remove_dir_all(&folder).unwrap();
    }

    #[test]
    fn a_file_that_exists_but_cannot_be_read_is_not_saved_over() {
        let folder = test_folder("read-error");
        let file = folder.join("ui.json");
        // A folder in the file's place fails to read with an error other than not found
        std::fs::create_dir_all(&file).unwrap();
        let mut storage = MemoryStorage::default();
        eframe::set_value(&mut storage, RON_STORAGE_KEY, &UiState::default());

        let mut store = UiStateStore::new(Some(file.clone()));
        assert!(store.load(Some(&storage)).is_none(), "the earlier state is not loaded in its place");
        store.save(&UiState::default(), &mut storage);
        assert!(file.is_dir());
        assert!(storage.values.contains_key(RON_STORAGE_KEY));
        std::fs::remove_dir_all(&folder).unwrap();
    }

    #[test]
    fn a_state_that_would_not_read_back_is_not_saved() {
        let mut storage = MemoryStorage::default();
        let mut store = UiStateStore::default();
        store.save(&UiState { split_ratio: 0.3, ..UiState::default() }, &mut storage);
        let saved = storage.values[STORAGE_KEY].clone();

        store.save(&UiState { uv_pan: [f32::NAN, 0.0], ..UiState::default() }, &mut storage);
        assert_eq!(storage.values[STORAGE_KEY], saved);
    }

    #[test]
    fn an_overflowing_shelf_split_still_allows_saving_other_preferences() {
        let defaults = UiState::default();
        let mut saved = serde_json::to_value(&defaults).unwrap();
        saved["shelf_panes_split"] = serde_json::json!(1e100);
        let mut storage = MemoryStorage::default();
        storage.values.insert(STORAGE_KEY.to_owned(), saved.to_string());

        let mut store = UiStateStore::default();
        let mut ui = store.load(Some(&storage)).expect("settings load with both panes closed");
        ui.shelf_filter = "rust".to_owned();
        store.save(&ui, &mut storage);

        let restarted = UiStateStore::default().load(Some(&storage)).unwrap();
        assert_eq!(restarted.shelf_filter, "rust");
        assert_eq!(restarted.shelf_panes_split, defaults.shelf_panes_split);
    }

    #[test]
    fn rejected_storage_backup_preserves_the_unreadable_original() {
        let mut storage = MemoryStorage::default();
        storage.values.insert(STORAGE_KEY.into(), "not json".into());
        storage.rejected_key = Some("ui.unreadable.json");
        let mut store = UiStateStore::default();
        assert!(store.load(Some(&storage)).is_none());

        store.save(&UiState::default(), &mut storage);
        store.save(&UiState::default(), &mut storage);
        assert_eq!(storage.values[STORAGE_KEY], "not json");
    }

    #[test]
    fn rejected_storage_save_keeps_legacy_ron() {
        let mut storage = MemoryStorage::default();
        let ui = UiState::default();
        eframe::set_value(&mut storage, RON_STORAGE_KEY, &ui);
        let original = storage.values[RON_STORAGE_KEY].clone();
        storage.rejected_key = Some(STORAGE_KEY);
        let mut store = UiStateStore::default();
        let loaded = store.load(Some(&storage)).unwrap();

        store.save(&loaded, &mut storage);
        assert_eq!(storage.values.get(RON_STORAGE_KEY), Some(&original));
        assert!(!storage.values.contains_key(STORAGE_KEY));
    }

    #[test]
    fn parsed_legacy_ron_keeps_the_raw_custom_layout() {
        let folder = test_folder("legacy-layout");
        for file in [None, Some(folder.join("ui.json"))] {
            let mut storage = MemoryStorage::default();
            // Recorded with the legacy eframe RON writer: Assets closed, Display floating, twenty recent projects
            let original = include_str!("../tests/fixture/ui_state_before_json.ron").to_owned();
            storage.values.insert(RON_STORAGE_KEY.into(), original.clone());
            assert!(original.contains("panels:[Display]") && original.contains("960.0"));
            let mut store = UiStateStore::new(file.clone());
            let loaded = store.load(Some(&storage)).unwrap();
            assert!(loaded.dock.replaced_unreadable());
            assert_eq!(loaded.split_ratio, 0.3);

            store.save(&loaded, &mut storage);
            let backup = match &file {
                Some(_) => std::fs::read_to_string(folder.join("ui.unreadable.ron")).ok(),
                None => storage.values.get("ui.unreadable.ron").cloned(),
            };
            assert_eq!(backup, Some(original), "{file:?}");
        }
        std::fs::remove_dir_all(folder).unwrap();
    }

    #[test]
    fn a_save_larger_than_the_read_limit_preserves_the_previous_state() {
        let folder = test_folder("oversized-save");
        let file = folder.join("ui.json");
        let mut storage = MemoryStorage::default();
        let mut store = UiStateStore::new(Some(file.clone()));
        store.save(&UiState::default(), &mut storage);
        let previous = std::fs::read(&file).unwrap();
        let ui = UiState { shelf_filter: "x".repeat(MAX_FILE_BYTES as usize), ..UiState::default() };

        store.save(&ui, &mut storage);
        assert!(std::fs::read(&file).unwrap() == previous);
        std::fs::remove_dir_all(folder).unwrap();
    }

    #[test]
    fn customized_painting_and_baking_docks_survive_each_active_mode() {
        let folder = test_folder("both-modes");
        for mode in [crate::state::Mode::Painting, crate::state::Mode::Baking, crate::state::Mode::Rendering] {
            let mut ui = UiState { dock: moved_panels(), ..UiState::default() };
            ui.inactive_mode_dock.close(Panel::MeshMapBakers);
            ui.mode = mode;
            ui.sync_mode_dock();
            for file in [None, Some(folder.join("ui.json"))] {
                let mut storage = MemoryStorage::default();
                UiStateStore::new(file.clone()).save(&ui, &mut storage);
                let mut loaded = UiStateStore::new(file).load(Some(&storage)).unwrap();
                loaded.sync_mode_dock();
                assert_eq!(loaded, ui, "{mode:?}");
                loaded.mode = crate::state::Mode::Painting;
                loaded.sync_mode_dock();
                assert_eq!(loaded.dock, moved_panels());
                loaded.mode = crate::state::Mode::Baking;
                loaded.sync_mode_dock();
                assert!(!loaded.dock.is_open(Panel::MeshMapBakers));
            }
        }
        std::fs::remove_dir_all(folder).unwrap();
    }

    #[test]
    fn failed_saves_report_once_and_retry_after_access_is_restored() {
        let mut storage = MemoryStorage::default();
        storage.rejected_key = Some(STORAGE_KEY);
        let mut store = UiStateStore::default();
        store.save(&UiState::default(), &mut storage);
        assert!(store.take_warning().unwrap().contains("could not be saved"));
        store.save(&UiState::default(), &mut storage);
        assert!(store.take_warning().is_none());

        storage.rejected_key = None;
        store.save(&UiState::default(), &mut storage);
        assert!(store.load(Some(&storage)).is_some());
        storage.rejected_key = Some(STORAGE_KEY);
        store.save(&UiState { split_ratio: 0.3, ..UiState::default() }, &mut storage);
        assert!(store.take_warning().is_some(), "a new failure after recovery is reported");
    }

    #[test]
    fn failed_file_saves_keep_legacy_settings_and_report_the_path() {
        let folder = test_folder("write-error");
        let file = folder.join("ui.json");
        let mut storage = MemoryStorage::default();
        eframe::set_value(&mut storage, RON_STORAGE_KEY, &UiState::default());
        let original = storage.values[RON_STORAGE_KEY].clone();
        let mut store = UiStateStore::new(Some(file.clone()));
        let loaded = store.load(Some(&storage)).unwrap();
        std::fs::create_dir(&file).unwrap();

        store.save(&loaded, &mut storage);
        assert_eq!(storage.values[RON_STORAGE_KEY], original);
        assert!(store.take_warning().unwrap().contains(&file.display().to_string()));
        std::fs::remove_dir(&file).unwrap();
        store.save(&loaded, &mut storage);
        assert!(read(&file).is_some());
        assert!(!storage.values.contains_key(RON_STORAGE_KEY));
        std::fs::remove_dir_all(folder).unwrap();
    }

    #[test]
    fn non_finite_legacy_pan_leaves_the_original_ron_for_the_next_restart() {
        let folder = test_folder("nonfinite-ron");
        for file in [None, Some(folder.join("ui.json"))] {
            let mut storage = MemoryStorage::default();
            eframe::set_value(&mut storage, RON_STORAGE_KEY, &UiState { uv_pan: [f32::NAN, 1.0], ..UiState::default() });
            let original = storage.values[RON_STORAGE_KEY].clone();
            let mut store = UiStateStore::new(file.clone());
            let loaded = store.load(Some(&storage)).unwrap();
            assert!(loaded.uv_pan[0].is_nan());

            store.save(&loaded, &mut storage);
            assert_eq!(storage.values[RON_STORAGE_KEY], original);
            assert!(store.take_warning().is_some());
            assert!(!storage.values.contains_key(STORAGE_KEY));
            assert!(!file.as_ref().is_some_and(|file| file.exists()));
            let restarted = UiStateStore::new(file).load(Some(&storage)).unwrap();
            assert!(restarted.uv_pan[0].is_nan());
        }
        std::fs::remove_dir_all(folder).unwrap();
    }

    #[test]
    fn an_unreadable_inactive_dock_is_backed_up_before_mode_sync() {
        let mut storage = MemoryStorage::default();
        let mut saved = serde_json::to_value(UiState::default()).unwrap();
        saved["inactive_mode_dock"]["version"] = 99.into();
        let original = saved.to_string();
        storage.values.insert(STORAGE_KEY.into(), original.clone());
        let mut store = UiStateStore::default();
        let mut loaded = store.load(Some(&storage)).unwrap();
        assert!(loaded.inactive_mode_dock.replaced_unreadable());
        loaded.sync_mode_dock();
        assert!(!loaded.inactive_mode_dock.replaced_unreadable());

        store.save(&loaded, &mut storage);
        assert_eq!(storage.values["ui.unreadable.json"], original);
    }

    #[test]
    fn tool_settings_survive_a_restart() {
        let mut tool = texturecraft_engine::ToolState::default();
        tool.brush.size = 0.31;
        tool.brush.hardness = 0.9;
        tool.brush.symmetry.z = true;
        tool.smudge_strength = 0.8;
        tool.clone_from = texturecraft_engine::CloneFrom::Layer;
        tool.path.fill = true;
        let ui = UiState { tool_settings: texturecraft_engine::ToolSettings::of(&tool), ..UiState::default() };

        let restarted = restart(&ui);

        assert_eq!(restarted.tool_settings, ui.tool_settings);
        let mut next = texturecraft_engine::ToolState::default();
        restarted.tool_settings.apply(&mut next);
        assert_eq!((next.brush.size, next.brush.hardness, next.smudge_strength), (0.31, 0.9, 0.8));
        assert!(next.brush.symmetry.z && next.path.fill);
        assert_eq!(next.clone_from, texturecraft_engine::CloneFrom::Layer);
    }

    #[test]
    fn a_state_saved_before_tool_settings_existed_loads_with_the_defaults() {
        let mut saved = serde_json::to_value(UiState::default()).unwrap();
        saved.as_object_mut().unwrap().remove("tool_settings").expect("the saved state has tool settings");
        let mut storage = MemoryStorage::default();
        storage.values.insert(STORAGE_KEY.into(), saved.to_string());
        let mut store = UiStateStore::default();

        let loaded = store.load(Some(&storage)).expect("the old state loads");

        assert_eq!(loaded.tool_settings, texturecraft_engine::ToolSettings::default());

        // Nothing was unreadable, so nothing is kept beside the state on the next save
        assert!(store.unreadable.is_none());
    }

    #[test]
    fn the_app_starts_with_the_saved_tool_settings() {
        let mut tool = texturecraft_engine::ToolState::default();
        tool.brush.size = 0.31;
        let ui = UiState { tool_settings: texturecraft_engine::ToolSettings::of(&tool), ..UiState::default() };
        let mut session = texturecraft_engine::sample_session(128, 64).unwrap();

        crate::start_ui(Some(restart(&ui)), &mut session);

        assert_eq!(session.tool.brush.size, 0.31);
    }
}