use crate::ipc::{
    AppFontSize, CalendarPreference, FontFamily, ListRowDensity, MediaCookieSource,
    PersistedSettings, PostQueueAction, ProxyMode, SchedulerSettings, SettingsTab, Theme,
    WindowControlStyle,
};
use serde_json::{Map, Value};
use std::collections::HashMap;
use tauri::{AppHandle, Manager};

pub fn load_settings<R: tauri::Runtime>(
    app_handle: &AppHandle<R>,
) -> Result<PersistedSettings, String> {
    let database = app_handle.state::<crate::db::DbState>();
    let connection = database.lock()?;
    let stored = crate::db::load_settings(&connection)?
        .ok_or_else(|| "settings are not persisted yet".to_string())?;
    decode_stored_settings(&Value::String(stored))
}

pub fn decode_stored_settings(stored: &Value) -> Result<PersistedSettings, String> {
    let document = decode_document(stored)?;
    let mut state = settings_state(&document)?.clone();
    migrate_location_settings(&mut state)?;
    sanitize_persisted_setting_values(&mut state);
    let mut merged = serde_json::to_value(default_settings())
        .map_err(|error| format!("failed to serialize settings defaults: {error}"))?;
    merge_json(&mut merged, &state);

    let mut settings: PersistedSettings = serde_json::from_value(merged)
        .map_err(|error| format!("invalid persisted settings: {error}"))?;
    validate_settings(&mut settings);
    Ok(settings)
}

pub fn update_settings_state(
    app_handle: &AppHandle,
    update: impl FnOnce(&mut Map<String, Value>),
) -> Result<(), String> {
    let database = app_handle.state::<crate::db::DbState>();
    let connection = database.lock()?;
    let stored = crate::db::load_settings(&connection)?
        .ok_or_else(|| "settings are not persisted yet".to_string())?;
    let mut document = decode_document(&Value::String(stored))?;
    update(settings_state_mut(&mut document)?);
    let stored = serde_json::to_string(&document)
        .map_err(|error| format!("failed to encode settings: {error}"))?;
    crate::db::save_settings(&connection, &stored)
}

pub fn preserve_scheduler_runtime_keys(
    existing: Option<&str>,
    incoming: &str,
) -> Result<String, String> {
    let Some(existing) = existing else {
        return Ok(incoming.to_string());
    };
    let existing_document = match decode_document(&Value::String(existing.to_string())) {
        Ok(doc) => doc,
        Err(e) => {
            log::warn!(
                "Failed to decode existing settings, dropping runtime keys: {}",
                e
            );
            return Ok(incoming.to_string());
        }
    };
    let existing_state = match settings_state(&existing_document) {
        Ok(state) => state,
        Err(_) => return Ok(incoming.to_string()),
    };
    let mut incoming_document = decode_document(&Value::String(incoming.to_string()))?;
    let incoming_state = settings_state_mut(&mut incoming_document)?;
    for key in ["schedulerLastStartKey", "schedulerLastStopKey"] {
        if let Some(value) = existing_state.get(key) {
            incoming_state.insert(key.to_string(), value.clone());
        }
    }
    serde_json::to_string(&incoming_document)
        .map_err(|error| format!("failed to encode persisted settings: {error}"))
}

pub fn preserve_portable_pairing_token(
    existing: Option<&str>,
    incoming: &str,
) -> Result<String, String> {
    let Some(existing) = existing else {
        return Ok(incoming.to_string());
    };

    let existing_document = decode_document(&Value::String(existing.to_string()))?;
    let existing_state = settings_state(&existing_document)?;
    let Some(token) = existing_state
        .get("extensionPairingToken")
        .and_then(Value::as_str)
        .filter(|value| !value.trim().is_empty())
    else {
        return Ok(incoming.to_string());
    };

    let mut incoming_document = decode_document(&Value::String(incoming.to_string()))?;
    let incoming_state = settings_state_mut(&mut incoming_document)?;
    let incoming_token_present = incoming_state
        .get("extensionPairingToken")
        .and_then(Value::as_str)
        .is_some_and(|value| !value.trim().is_empty());
    if !incoming_token_present {
        incoming_state.insert(
            "extensionPairingToken".to_string(),
            Value::String(token.to_string()),
        );
    }

    serde_json::to_string(&incoming_document)
        .map_err(|error| format!("failed to encode portable settings: {error}"))
}

fn decode_document(stored: &Value) -> Result<Value, String> {
    match stored {
        Value::String(text) => serde_json::from_str(text)
            .map_err(|error| format!("failed to parse persisted settings: {error}")),
        Value::Object(_) => Ok(stored.clone()),
        _ => Err("persisted settings must be a JSON string or object".to_string()),
    }
}

fn settings_state(document: &Value) -> Result<&Value, String> {
    if let Some(state) = document.get("state") {
        if !state.is_object() {
            return Err("persisted settings state must be an object".to_string());
        }
        Ok(state)
    } else if document.is_object() {
        Ok(document)
    } else {
        Err("persisted settings must be an object".to_string())
    }
}

fn settings_state_mut(document: &mut Value) -> Result<&mut Map<String, Value>, String> {
    let has_envelope = document.get("state").is_some();
    let state = if has_envelope {
        document
            .get_mut("state")
            .ok_or_else(|| "persisted settings state is missing".to_string())?
    } else {
        document
    };
    state
        .as_object_mut()
        .ok_or_else(|| "persisted settings state must be an object".to_string())
}

fn merge_json(target: &mut Value, source: &Value) {
    match (target, source) {
        (Value::Object(target), Value::Object(source)) => {
            for (key, value) in source {
                if let Some(target_value) = target.get_mut(key) {
                    if json_value_types_match(target_value, value) {
                        merge_json(target_value, value);
                    }
                } else {
                    target.insert(key.clone(), value.clone());
                }
            }
        }
        (target, source) if json_value_types_match(target, source) => *target = source.clone(),
        _ => {}
    }
}

fn json_value_types_match(left: &Value, right: &Value) -> bool {
    matches!(
        (left, right),
        (Value::Null, Value::Null)
            | (Value::Bool(_), Value::Bool(_))
            | (Value::Number(_), Value::Number(_))
            | (Value::String(_), Value::String(_))
            | (Value::Array(_), Value::Array(_))
            | (Value::Object(_), Value::Object(_))
    )
}

fn sanitize_persisted_setting_values(state: &mut Value) {
    let Some(state) = state.as_object_mut() else {
        return;
    };

    sanitize_integer_setting(state, "maxConcurrentDownloads", |value| value.as_u64().is_some());
    sanitize_integer_setting(state, "perServerConnections", |value| value.as_i64().is_some());
    sanitize_integer_setting(state, "maxAutomaticRetries", |value| value.as_i64().is_some());
    sanitize_allowed_string(
        state,
        "theme",
        &["system", "light", "dark", "dracula", "nord"],
    );
    sanitize_allowed_string(
        state,
        "fontFamily",
        &[
            "system",
            "inter",
            "outfit",
            "vazirmatn",
            "noto-sans-hebrew",
            "noto-sans-sc",
            "roboto",
            "serif",
            "monospace",
        ],
    );
    sanitize_allowed_string(
        state,
        "windowControlStyle",
        &["auto", "macos", "windows", "gnome", "minimal"],
    );
    sanitize_allowed_string(
        state,
        "language",
        &["system", "en", "zh-CN", "he", "fa", "uk", "ru"],
    );
    sanitize_allowed_string(state, "calendarPreference", &["gregorian", "persian", "hebrew"]);
    sanitize_allowed_string(state, "sidebarPosition", &["auto", "left", "right"]);
    sanitize_allowed_string(state, "appFontSize", &["small", "standard", "large"]);
    sanitize_allowed_string(state, "listRowDensity", &["compact", "standard", "relaxed"]);
    sanitize_allowed_string(state, "activeSettingsTab", &[
        "downloads",
        "lookandfeel",
        "network",
        "locations",
        "sitelogins",
        "power",
        "engine",
        "integrations",
        "about",
    ]);
    sanitize_allowed_string(state, "proxyMode", &["none", "system", "custom"]);
    sanitize_allowed_string(
        state,
        "mediaCookieSource",
        &[
            "none", "safari", "chrome", "chromium", "firefox", "edge", "brave", "opera",
            "vivaldi", "whale",
        ],
    );

    if let Some(scheduler) = state.get_mut("scheduler").and_then(Value::as_object_mut) {
        sanitize_allowed_string(
            scheduler,
            "postQueueAction",
            &["none", "sleep", "restart", "shutdown"],
        );
    }

    if let Some(logins) = state.get_mut("siteLogins").and_then(Value::as_array_mut) {
        logins.retain(|login| {
            let Some(login) = login.as_object() else {
                return false;
            };
            ["id", "urlPattern", "username"]
                .into_iter()
                .all(|key| login.get(key).and_then(Value::as_str).is_some())
        });
    }
}

fn sanitize_integer_setting(
    state: &mut serde_json::Map<String, Value>,
    key: &str,
    is_valid: impl Fn(&Value) -> bool,
) {
    if state.get(key).is_some_and(|value| !is_valid(value)) {
        state.remove(key);
    }
}

fn sanitize_allowed_string(
    state: &mut serde_json::Map<String, Value>,
    key: &str,
    allowed: &[&str],
) {
    let valid = state
        .get(key)
        .and_then(Value::as_str)
        .is_some_and(|value| allowed.contains(&value));
    if state.contains_key(key) && !valid {
        state.remove(key);
    }
}

fn validate_settings(settings: &mut PersistedSettings) {
    if settings.max_concurrent_downloads == 0 {
        settings.max_concurrent_downloads = default_settings().max_concurrent_downloads;
    }
    settings.max_concurrent_downloads = settings.max_concurrent_downloads.min(12);
    settings.per_server_connections = settings.per_server_connections.clamp(1, 16);
    settings.max_automatic_retries = settings.max_automatic_retries.clamp(0, 10);
    if !matches!(
        settings.last_custom_speed_limit_unit.as_str(),
        "KB/s" | "MB/s"
    ) {
        settings.last_custom_speed_limit_unit = default_settings().last_custom_speed_limit_unit;
    }
}

fn default_category_subfolders() -> HashMap<String, String> {
    [
        ("Musics", "Musics"),
        ("Movies", "Movies"),
        ("Compressed", "Compressed"),
        ("Documents", "Documents"),
        ("Pictures", "Pictures"),
        ("Applications", "Applications"),
        ("Other", "Other"),
    ]
    .into_iter()
    .map(|(category, folder)| (category.to_string(), folder.to_string()))
    .collect()
}

fn normalize_category_subfolder(value: &str, fallback: &str) -> String {
    if value.trim().is_empty() {
        return String::new();
    }

    let parts = value
        .split(['/', '\\'])
        .filter(|part| !part.is_empty() && *part != "." && *part != ".." && !part.ends_with(':'))
        .collect::<Vec<_>>();
    if parts.is_empty() {
        fallback.to_string()
    } else {
        parts.join("/")
    }
}

fn migrate_location_settings(state: &mut Value) -> Result<(), String> {
    let state = state
        .as_object_mut()
        .ok_or_else(|| "persisted settings state must be an object".to_string())?;
    let base = state
        .get("baseDownloadFolder")
        .and_then(Value::as_str)
        .filter(|value| !value.trim().is_empty())
        .or_else(|| {
            state
                .get("defaultDownloadPath")
                .and_then(Value::as_str)
                .filter(|value| !value.trim().is_empty())
        })
        .unwrap_or("~/Downloads")
        .to_string();

    let mut subfolders = default_category_subfolders();
    if let Some(persisted) = state.get("categorySubfolders").and_then(Value::as_object) {
        for (category, value) in persisted {
            if let Some(folder) = value.as_str() {
                let fallback = subfolders
                    .get(category)
                    .cloned()
                    .unwrap_or_else(|| category.clone());
                subfolders.insert(
                    category.clone(),
                    normalize_category_subfolder(folder, &fallback),
                );
            }
        }
    }

    let mut overrides = state
        .get("categoryDirectoryOverrides")
        .and_then(Value::as_object)
        .cloned()
        .unwrap_or_default();
    if let Some(legacy) = state.get("downloadDirectories").and_then(Value::as_object) {
        let aliases = [
            ("Musics", "Audio"),
            ("Movies", "Video"),
            ("Compressed", "Archives"),
            ("Documents", "Documents"),
            ("Pictures", "Images"),
            ("Applications", "Apps"),
            ("Other", "Other"),
        ];
        for (category, alias) in aliases {
            if overrides.contains_key(category) {
                continue;
            }
            let Some(path) = legacy
                .get(category)
                .or_else(|| legacy.get(alias))
                .and_then(Value::as_str)
                .filter(|path| !path.trim().is_empty())
            else {
                continue;
            };
            let subfolder = subfolders
                .get(category)
                .map(String::as_str)
                .unwrap_or(category);
            if normalize_location_path(path) != derived_location_path(&base, subfolder) {
                overrides.insert(category.to_string(), Value::String(path.to_string()));
            }
        }
    }

    state.insert("baseDownloadFolder".to_string(), Value::String(base));
    state
        .entry("categorySubfoldersEnabled".to_string())
        .or_insert(Value::Bool(true));
    state.insert(
        "categorySubfolders".to_string(),
        serde_json::to_value(subfolders)
            .map_err(|error| format!("failed to migrate category subfolders: {error}"))?,
    );
    state.insert(
        "categoryDirectoryOverrides".to_string(),
        Value::Object(overrides),
    );
    state.remove("defaultDownloadPath");
    state.remove("downloadDirectories");
    Ok(())
}

fn normalize_location_path(path: &str) -> String {
    path.replace('\\', "/").trim_end_matches('/').to_string()
}

fn derived_location_path(base: &str, subfolder: &str) -> String {
    let base = normalize_location_path(base);
    let subfolder = subfolder.trim_matches(|character| character == '/' || character == '\\');
    if subfolder.is_empty() {
        base
    } else {
        format!("{base}/{subfolder}")
    }
}

fn default_settings() -> PersistedSettings {
    PersistedSettings {
        theme: Theme::System,
        font_family: FontFamily::System,
        window_control_style: WindowControlStyle::Auto,
        calendar_preference: CalendarPreference::Gregorian,
        language: "system".to_string(),
        base_download_folder: "~/Downloads".to_string(),
        category_subfolders_enabled: true,
        category_subfolders: default_category_subfolders(),
        category_directory_overrides: HashMap::new(),
        approved_download_roots: Vec::new(),
        max_concurrent_downloads: 3,
        global_speed_limit: String::new(),
        speed_limit_preset_values: vec![1.0, 5.0, 10.0],
        logs_enabled: false,
        is_sidebar_visible: true,
        sidebar_position: "auto".to_string(),
        active_settings_tab: SettingsTab::Downloads,
        scheduler: SchedulerSettings {
            enabled: false,
            start_time: "00:00".to_string(),
            stop_time_enabled: false,
            stop_time: "08:00".to_string(),
            everyday: true,
            selected_days: vec![0, 1, 2, 3, 4, 5, 6],
            selected_queue_ids: vec!["00000000-0000-0000-0000-000000000001".to_string()],
            post_queue_action: PostQueueAction::None,
        },
        scheduler_running: false,
        scheduler_active_download_ids: Vec::new(),
        scheduler_last_start_key: String::new(),
        scheduler_last_stop_key: String::new(),
        last_custom_speed_limit_ki_b: 1024,
        last_custom_speed_limit_unit: "MB/s".to_string(),
        per_server_connections: 16,
        max_automatic_retries: 3,
        show_notifications: true,
        play_completion_sound: false,
        auto_add_clipboard_links: false,
        app_font_size: AppFontSize::Standard,
        list_row_density: ListRowDensity::Standard,
        show_dock_badge: true,
        show_menu_bar_icon: true,
        proxy_mode: ProxyMode::None,
        proxy_host: String::new(),
        proxy_port: 8080,
        custom_user_agent: String::new(),
        ask_where_to_save_each_file: false,
        remember_last_used_download_directory: false,
        prevents_sleep_while_downloading: true,
        prevents_display_sleep_while_downloading: false,
        media_cookie_source: MediaCookieSource::default(),
        site_logins: Vec::new(),
        auto_check_updates: true,
        keychain_access_granted: false,
    }
}

#[cfg(test)]
mod tests {
    use crate::ipc::{FontFamily, WindowControlStyle};
    use super::{
        decode_stored_settings, default_settings, preserve_portable_pairing_token,
        preserve_scheduler_runtime_keys,
    };
    use serde_json::{json, Value};

    #[test]
    fn frontend_settings_save_preserves_backend_scheduler_keys() {
        let existing = json!({
            "state": {
                "schedulerLastStartKey": "2026-06-22-start",
                "schedulerLastStopKey": "2026-06-22-stop"
            },
            "version": 3
        })
        .to_string();
        let incoming = json!({
            "state": {
                "schedulerLastStartKey": "",
                "schedulerLastStopKey": "",
                "theme": "system"
            },
            "version": 3
        })
        .to_string();

        let merged = preserve_scheduler_runtime_keys(Some(&existing), &incoming).unwrap();
        let merged: Value = serde_json::from_str(&merged).unwrap();
        assert_eq!(merged["state"]["schedulerLastStartKey"], "2026-06-22-start");
        assert_eq!(merged["state"]["schedulerLastStopKey"], "2026-06-22-stop");
    }

    #[test]
    fn decodes_zustand_envelope_and_preserves_non_default_startup_settings() {
        let stored = json!({
            "state": {
                "maxConcurrentDownloads": 7,
                "globalSpeedLimit": "2M",
                "sidebarPosition": "right",
                "scheduler": {
                    "enabled": true,
                    "startTime": "06:30",
                    "stopTimeEnabled": true,
                    "stopTime": "23:15",
                    "everyday": false,
                    "selectedDays": [1, 3, 5],
                    "postQueueAction": "sleep"
                }
            },
            "version": 0
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.max_concurrent_downloads, 7);
        assert_eq!(settings.global_speed_limit, "2M");
        assert_eq!(settings.sidebar_position, "right");
        assert_eq!(settings.speed_limit_preset_values, vec![1.0, 5.0, 10.0]);
        assert!(!settings.logs_enabled);
        assert!(settings.scheduler.enabled);
        assert_eq!(settings.scheduler.start_time, "06:30");
        assert_eq!(settings.scheduler.selected_days, vec![1, 3, 5]);
        assert_eq!(
            settings.scheduler.selected_queue_ids,
            vec!["00000000-0000-0000-0000-000000000001"]
        );
        assert_eq!(settings.base_download_folder, "~/Downloads");
        assert!(settings.category_subfolders_enabled);
    }

    #[test]
    fn decodes_legacy_top_level_settings() {
        let stored = json!({
            "maxConcurrentDownloads": 5,
            "globalSpeedLimit": "512K"
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.max_concurrent_downloads, 5);
        assert_eq!(settings.global_speed_limit, "512K");
        assert_eq!(settings.last_custom_speed_limit_unit, "MB/s");
        assert_eq!(settings.speed_limit_preset_values, vec![1.0, 5.0, 10.0]);
        assert!(!settings.logs_enabled);
        assert!(!settings.scheduler.enabled);
    }

    #[test]
    fn decodes_persisted_log_opt_in() {
        let stored = json!({
            "state": {
                "speedLimitPresetValues": [1, 2.5, 8],
                "logsEnabled": true
            },
            "version": 3
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.speed_limit_preset_values, vec![1.0, 2.5, 8.0]);
        assert!(settings.logs_enabled);
        assert!(!settings.scheduler.enabled);
        assert!(settings.global_speed_limit.is_empty());
    }

    #[test]
    fn migrates_legacy_location_settings_and_preserves_custom_overrides() {
        let stored = json!({
            "state": {
                "defaultDownloadPath": "/Users/test/Downloads",
                "downloadDirectories": {
                    "Movies": "/Users/test/Downloads/Movies",
                    "Documents": "/Volumes/Archive/Documents"
                }
            },
            "version": 1
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.base_download_folder, "/Users/test/Downloads");
        assert_eq!(settings.category_subfolders["Movies"], "Movies");
        assert!(!settings.category_directory_overrides.contains_key("Movies"));
        assert_eq!(
            settings.category_directory_overrides["Documents"],
            "/Volumes/Archive/Documents"
        );
    }

    #[test]
    fn normalizes_category_subfolders_as_relative_paths() {
        let stored = json!({
            "state": {
                "baseDownloadFolder": "/Users/test/Downloads",
                "categorySubfolders": {
                    "Movies": "../Media/./Movies",
                    "Documents": "../../"
                }
            },
            "version": 2
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.category_subfolders["Movies"], "Media/Movies");
        assert_eq!(settings.category_subfolders["Documents"], "Documents");
    }

    #[test]
    fn preserves_empty_category_subfolder_as_base_folder() {
        let stored = json!({
            "state": {
                "baseDownloadFolder": "/Users/test/Downloads",
                "categorySubfolders": {
                    "Movies": ""
                }
            },
            "version": 3
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.category_subfolders["Movies"], "");
        assert_eq!(settings.category_subfolders["Documents"], "Documents");
    }

    #[test]
    fn decodes_disabled_category_subfolders() {
        let stored = json!({
            "state": {
                "baseDownloadFolder": "/Users/test/Downloads",
                "categorySubfoldersEnabled": false,
                "categorySubfolders": {
                    "Movies": "Movies"
                }
            },
            "version": 3
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert!(!settings.category_subfolders_enabled);
        assert_eq!(settings.category_subfolders["Movies"], "Movies");
    }

    #[test]
    fn replaces_zero_concurrency_with_the_safe_default() {
        let stored = json!({"state": {"maxConcurrentDownloads": 0}, "version": 0});

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.max_concurrent_downloads, 3);
    }

    #[test]
    fn invalid_sidebar_position_uses_automatic_layout() {
        let stored = json!({
            "state": {"sidebarPosition": "diagonal"},
            "version": 5
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.sidebar_position, "auto");
    }

    #[test]
    fn invalid_font_family_uses_system_font() {
        let stored = json!({
            "state": {"fontFamily": "comic-sans"},
            "version": 5
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert!(matches!(settings.font_family, FontFamily::System));
    }

    #[test]
    fn curated_font_families_are_preserved() {
        for value in ["vazirmatn", "noto-sans-hebrew", "noto-sans-sc", "roboto"] {
            let stored = json!({
                "state": {"fontFamily": value},
                "version": 5
            });

            let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

            assert_eq!(serde_json::to_value(settings.font_family).unwrap(), json!(value));
        }
    }

    #[test]
    fn invalid_window_control_style_uses_automatic_layout() {
        let stored = json!({
            "state": {"windowControlStyle": "neon"},
            "version": 5
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert!(matches!(
            settings.window_control_style,
            WindowControlStyle::Auto
        ));
    }

    #[test]
    fn clamps_out_of_range_download_settings() {
        let stored = json!({
            "state": {
                "maxConcurrentDownloads": 99,
                "perServerConnections": -4,
                "maxAutomaticRetries": 99
            },
            "version": 3
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.max_concurrent_downloads, 12);
        assert_eq!(settings.per_server_connections, 1);
        assert_eq!(settings.max_automatic_retries, 10);
    }

    #[test]
    fn ignores_malformed_setting_types_without_dropping_valid_values() {
        let stored = json!({
            "state": {
                "baseDownloadFolder": "/Users/test/Downloads",
                "maxConcurrentDownloads": "not-a-number",
                "perServerConnections": 5,
                "showNotifications": "yes",
                "theme": "not-a-theme",
                "calendarPreference": "lunar",
                "siteLogins": [{"id": "valid", "urlPattern": "example.com", "username": "user"}, {"id": 3}]
            },
            "version": 3
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.base_download_folder, "/Users/test/Downloads");
        assert_eq!(settings.max_concurrent_downloads, 3);
        assert_eq!(settings.per_server_connections, 5);
        assert!(settings.show_notifications);
        assert!(matches!(settings.theme, crate::ipc::Theme::System));
        assert!(matches!(
            settings.calendar_preference,
            crate::ipc::CalendarPreference::Gregorian
        ));
        assert_eq!(settings.site_logins.len(), 1);
        assert_eq!(settings.site_logins[0].id, "valid");
    }

    #[test]
    fn opt_in_defaults_match_the_frontend_defaults() {
        assert!(!default_settings().play_completion_sound);
        assert!(!default_settings().auto_add_clipboard_links);
    }

    #[test]
    fn does_not_remember_last_used_download_directory_by_default() {
        assert!(!default_settings().remember_last_used_download_directory);
    }

    #[test]
    fn decodes_disabled_last_used_download_directory_setting() {
        let stored = json!({
            "state": {
                "rememberLastUsedDownloadDirectory": false
            },
            "version": 3
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert!(!settings.remember_last_used_download_directory);
    }

    #[test]
    fn ignores_legacy_extension_pairing_token_field() {
        // Older standard installs persisted `extensionPairingToken` as
        // plaintext inside the settings document. It now lives in the OS
        // keychain and is no longer part of PersistedSettings; portable mode
        // deliberately keeps its token in the portable settings document.
        // serde ignores the unknown field so existing installs decode without
        // error; standard-mode migration drops the plaintext value.
        let stored = json!({
            "state": {
                "extensionPairingToken": "plaintext-leaked-secret",
                "maxConcurrentDownloads": 5
            },
            "version": 0
        });

        let settings = decode_stored_settings(&Value::String(stored.to_string())).unwrap();

        assert_eq!(settings.max_concurrent_downloads, 5);
    }

    #[test]
    fn preserves_portable_pairing_token_when_startup_save_races() {
        let existing = json!({
            "state": {
                "extensionPairingToken": "portable-token",
                "maxConcurrentDownloads": 3
            },
            "version": 3
        })
        .to_string();
        let incoming = json!({
            "state": {
                "extensionPairingToken": "",
                "maxConcurrentDownloads": 5
            },
            "version": 3
        })
        .to_string();

        let merged = preserve_portable_pairing_token(Some(&existing), &incoming).unwrap();
        let document: Value = serde_json::from_str(&merged).unwrap();
        assert_eq!(
            document["state"]["extensionPairingToken"],
            "portable-token"
        );
        assert_eq!(document["state"]["maxConcurrentDownloads"], 5);
    }
}