//! Shared theme loading logic for TOML-based theme files.
//!
//! Used by GoingsOn, Balanced Breakfast (Tauri apps), and audiofiles (egui).
//! audiofiles embeds themes at compile time but uses `ThemeMeta`, `parse_meta`,
//! and `extract_colors` from this crate.
//!
//! Theme files are TOML with this structure:
//! ```text
//! [meta]
//! name = "Theme Name"
//! variant = "dark"  # or "light"
//!
//! [background]
//! primary = "#1e1e2e"
//!
//! [foreground]
//! primary = "#cdd6f4"
//!
//! [accent]
//! primary = "#89b4fa"
//!
//! [border]
//! primary = "#45475a"
//! ```

use serde::Serialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};

/// Theme metadata parsed from the `[meta]` section.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThemeMeta {
    pub id: String,
    pub name: String,
    pub variant: String,
    pub is_custom: bool,
}

/// A fully loaded theme: metadata plus flattened color map.
#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThemeColors {
    pub meta: ThemeMeta,
    pub colors: HashMap<String, String>,
}

/// Validate a theme ID contains only safe characters (alphanumeric, hyphens, underscores).
pub fn validate_theme_id(id: &str) -> Result<(), String> {
    if !id
        .chars()
        .all(|c| c.is_alphanumeric() || c == '-' || c == '_')
    {
        return Err(format!("Invalid theme ID: {}", id));
    }
    Ok(())
}

/// Parse the `[meta]` section from a TOML table into `ThemeMeta`.
///
/// Falls back to the file ID as the name and `"dark"` as the variant.
pub fn parse_meta(id: &str, table: &toml::Table, is_custom: bool) -> ThemeMeta {
    let meta = table.get("meta").and_then(|m| m.as_table());
    let name = meta
        .and_then(|m| m.get("name"))
        .and_then(|v| v.as_str())
        .unwrap_or(id)
        .to_string();
    let variant = meta
        .and_then(|m| m.get("variant"))
        .and_then(|v| v.as_str())
        .unwrap_or("dark")
        .to_string();

    ThemeMeta {
        id: id.to_string(),
        name,
        variant,
        is_custom,
    }
}

/// Extract color sections (background, foreground, accent, border) from a TOML
/// table into a flat `HashMap` with keys like `"background.primary"`.
pub fn extract_colors(table: &toml::Table) -> HashMap<String, String> {
    let mut colors = HashMap::new();
    for section in &["background", "foreground", "accent", "border"] {
        if let Some(sect) = table.get(*section).and_then(|s| s.as_table()) {
            for (key, val) in sect {
                if let Some(color) = val.as_str() {
                    colors.insert(format!("{}.{}", section, key), color.to_string());
                }
            }
        }
    }
    colors
}

/// Scan directories for `.toml` theme files and return metadata for each.
///
/// Directories are checked in order; later entries override earlier ones by ID.
/// Each entry in `dirs` is `(path, is_custom)`.
pub fn list_themes_from_dirs(dirs: &[(PathBuf, bool)]) -> Vec<ThemeMeta> {
    let mut seen: HashMap<String, ThemeMeta> = HashMap::new();

    for (dir, is_custom) in dirs {
        let entries = match std::fs::read_dir(dir) {
            Ok(e) => e,
            Err(_) => continue,
        };

        for entry in entries {
            let entry = match entry {
                Ok(e) => e,
                Err(_) => continue,
            };
            let path = entry.path();
            if path.extension().and_then(|e| e.to_str()) != Some("toml") {
                continue;
            }

            let id = path
                .file_stem()
                .and_then(|s| s.to_str())
                .unwrap_or_default()
                .to_string();

            let content = match std::fs::read_to_string(&path) {
                Ok(c) => c,
                Err(_) => continue,
            };
            let table: toml::Table = match content.parse() {
                Ok(t) => t,
                Err(_) => continue,
            };

            seen.insert(id.clone(), parse_meta(&id, &table, *is_custom));
        }
    }

    let mut themes: Vec<ThemeMeta> = seen.into_values().collect();
    themes.sort_by(|a, b| a.name.cmp(&b.name));
    themes
}

/// Find a theme file by ID in the given directories.
///
/// Checks directories in reverse order so the highest-priority directory wins.
/// Returns `(path, is_custom)` or `None` if not found.
pub fn find_theme_path(dirs: &[(PathBuf, bool)], id: &str) -> Option<(PathBuf, bool)> {
    let filename = format!("{}.toml", id);

    for (dir, is_custom) in dirs.iter().rev() {
        let path = dir.join(&filename);
        if path.is_file() {
            return Some((path, *is_custom));
        }
    }

    None
}

/// Load a complete theme (metadata + colors) by ID from the given directories.
pub fn load_theme(dirs: &[(PathBuf, bool)], id: &str) -> Result<ThemeColors, String> {
    validate_theme_id(id)?;

    let (path, is_custom) =
        find_theme_path(dirs, id).ok_or_else(|| format!("Theme '{}' not found", id))?;

    let content = std::fs::read_to_string(&path)
        .map_err(|e| format!("Failed to read {}: {}", path.display(), e))?;

    let table: toml::Table = content
        .parse()
        .map_err(|e| format!("Failed to parse {}: {}", path.display(), e))?;

    let meta = parse_meta(id, &table, is_custom);
    let colors = extract_colors(&table);

    Ok(ThemeColors { meta, colors })
}

/// Import a theme TOML file into the custom themes directory.
///
/// Validates that the file is parseable TOML with the expected color sections,
/// then copies it to `custom_dir/{id}.toml` where `id` is the file stem.
/// Creates `custom_dir` if it doesn't exist. Returns the theme metadata.
pub fn import_theme(source_path: &Path, custom_dir: &Path) -> Result<ThemeMeta, String> {
    let content = std::fs::read_to_string(source_path)
        .map_err(|e| format!("Failed to read {}: {}", source_path.display(), e))?;

    let table: toml::Table = content
        .parse()
        .map_err(|e| format!("Invalid TOML: {}", e))?;

    // Verify it has at least one color section
    let has_colors = ["background", "foreground", "accent", "border"]
        .iter()
        .any(|s| table.get(*s).and_then(|v| v.as_table()).is_some());
    if !has_colors {
        return Err("Theme file must have at least one color section (background, foreground, accent, or border)".to_string());
    }

    let id = source_path
        .file_stem()
        .and_then(|s| s.to_str())
        .ok_or("Invalid file name")?
        .to_string();
    validate_theme_id(&id)?;

    std::fs::create_dir_all(custom_dir)
        .map_err(|e| format!("Failed to create {}: {}", custom_dir.display(), e))?;

    let dest = custom_dir.join(format!("{}.toml", id));
    std::fs::copy(source_path, &dest)
        .map_err(|e| format!("Failed to copy theme: {}", e))?;

    Ok(parse_meta(&id, &table, true))
}

/// Delete a custom theme by ID.
///
/// Only operates on `custom_dir` — bundled themes are not deletable through
/// this entry point. Returns `Err` if the ID is invalid, the file does not
/// exist, or the underlying remove fails.
pub fn delete_theme(custom_dir: &Path, id: &str) -> Result<(), String> {
    validate_theme_id(id)?;

    let path = custom_dir.join(format!("{}.toml", id));
    if !path.is_file() {
        return Err(format!("Custom theme '{}' not found", id));
    }

    std::fs::remove_file(&path)
        .map_err(|e| format!("Failed to delete {}: {}", path.display(), e))
}

/// A four-color palette for preview chips, swatches, etc.
///
/// Smaller than `ThemeColors`: only the `primary` value from each of the four
/// canonical sections, so callers rendering a list of theme thumbnails don't
/// need to allocate a full `HashMap` per row.
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ThemePreview {
    pub meta: ThemeMeta,
    pub background: Option<String>,
    pub foreground: Option<String>,
    pub accent: Option<String>,
    pub border: Option<String>,
}

fn primary_color(table: &toml::Table, section: &str) -> Option<String> {
    table
        .get(section)
        .and_then(|s| s.as_table())
        .and_then(|s| s.get("primary"))
        .and_then(|v| v.as_str())
        .map(|s| s.to_string())
}

/// Load just the primary colors for a theme — for UI previews / thumbnails.
pub fn load_theme_preview(dirs: &[(PathBuf, bool)], id: &str) -> Result<ThemePreview, String> {
    validate_theme_id(id)?;

    let (path, is_custom) =
        find_theme_path(dirs, id).ok_or_else(|| format!("Theme '{}' not found", id))?;

    let content = std::fs::read_to_string(&path)
        .map_err(|e| format!("Failed to read {}: {}", path.display(), e))?;

    let table: toml::Table = content
        .parse()
        .map_err(|e| format!("Failed to parse {}: {}", path.display(), e))?;

    Ok(ThemePreview {
        meta: parse_meta(id, &table, is_custom),
        background: primary_color(&table, "background"),
        foreground: primary_color(&table, "foreground"),
        accent: primary_color(&table, "accent"),
        border: primary_color(&table, "border"),
    })
}

/// Export a theme to a user-chosen path.
///
/// Finds the theme by ID in the given directories and copies the TOML file
/// to `dest_path`.
pub fn export_theme(dirs: &[(PathBuf, bool)], id: &str, dest_path: &Path) -> Result<(), String> {
    validate_theme_id(id)?;

    let (source, _) =
        find_theme_path(dirs, id).ok_or_else(|| format!("Theme '{}' not found", id))?;

    std::fs::copy(&source, dest_path)
        .map_err(|e| format!("Failed to export theme: {}", e))?;

    Ok(())
}

/// Construct a dev fallback theme directory path.
///
/// Given a `CARGO_MANIFEST_DIR`, walks up `levels` parent directories and
/// appends `"themes"`. Returns the path if the directory exists.
pub fn dev_themes_dir(manifest_dir: &Path, levels: usize) -> Option<PathBuf> {
    let mut path = manifest_dir.to_path_buf();
    for _ in 0..levels {
        path = path.parent()?.to_path_buf();
    }
    let themes = path.join("MNW").join("shared").join("themes");
    if themes.is_dir() {
        Some(themes)
    } else {
        None
    }
}

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

    #[test]
    fn validate_theme_id_alphanumeric() {
        assert!(validate_theme_id("darkmode").is_ok());
        assert!(validate_theme_id("Theme123").is_ok());
    }

    #[test]
    fn validate_theme_id_hyphens_underscores() {
        assert!(validate_theme_id("dark-mode").is_ok());
        assert!(validate_theme_id("my_theme_v2").is_ok());
        assert!(validate_theme_id("a-b_c-d").is_ok());
    }

    #[test]
    fn validate_theme_id_rejects_spaces() {
        assert!(validate_theme_id("has space").is_err());
    }

    #[test]
    fn validate_theme_id_rejects_path_traversal() {
        assert!(validate_theme_id("../etc/passwd").is_err());
        assert!(validate_theme_id("foo/bar").is_err());
    }

    #[test]
    fn validate_theme_id_rejects_special_chars() {
        assert!(validate_theme_id("evil<script>").is_err());
        assert!(validate_theme_id("theme;drop").is_err());
        assert!(validate_theme_id("theme.toml").is_err());
    }

    #[test]
    fn validate_theme_id_empty_is_valid() {
        assert!(
            validate_theme_id("").is_ok(),
            "empty string has no invalid chars"
        );
    }

    #[test]
    fn parse_meta_with_name_and_variant() {
        let toml_str = r#"
[meta]
name = "Solarized Dark"
variant = "light"
"#;
        let table: toml::Table = toml_str.parse().unwrap();
        let meta = parse_meta("solarized", &table, false);
        assert_eq!(meta.id, "solarized");
        assert_eq!(meta.name, "Solarized Dark");
        assert_eq!(meta.variant, "light");
        assert!(!meta.is_custom);
    }

    #[test]
    fn parse_meta_defaults_to_id_and_dark() {
        let table: toml::Table = "".parse().unwrap();
        let meta = parse_meta("fallback", &table, true);
        assert_eq!(meta.name, "fallback");
        assert_eq!(meta.variant, "dark");
        assert!(meta.is_custom);
    }

    #[test]
    fn parse_meta_missing_variant_defaults_dark() {
        let toml_str = r#"
[meta]
name = "Minimal"
"#;
        let table: toml::Table = toml_str.parse().unwrap();
        let meta = parse_meta("minimal", &table, false);
        assert_eq!(meta.name, "Minimal");
        assert_eq!(meta.variant, "dark");
    }

    #[test]
    fn extract_colors_from_toml() {
        let toml_str = r##"
[background]
primary = "#1e1e2e"
secondary = "#313244"

[foreground]
primary = "#cdd6f4"

[accent]
primary = "#89b4fa"

[border]
primary = "#45475a"
"##;
        let table: toml::Table = toml_str.parse().unwrap();
        let colors = extract_colors(&table);
        assert_eq!(colors.get("background.primary").unwrap(), "#1e1e2e");
        assert_eq!(colors.get("background.secondary").unwrap(), "#313244");
        assert_eq!(colors.get("foreground.primary").unwrap(), "#cdd6f4");
        assert_eq!(colors.get("accent.primary").unwrap(), "#89b4fa");
        assert_eq!(colors.get("border.primary").unwrap(), "#45475a");
        assert_eq!(colors.len(), 5);
    }

    #[test]
    fn extract_colors_empty_table() {
        let table: toml::Table = "".parse().unwrap();
        let colors = extract_colors(&table);
        assert!(colors.is_empty());
    }

    #[test]
    fn list_themes_from_dirs_finds_toml_files() {
        let dir = tempfile::tempdir().unwrap();
        let theme_content = r#"
[meta]
name = "Test Theme"
variant = "dark"
"#;
        fs::write(dir.path().join("test-theme.toml"), theme_content).unwrap();
        fs::write(dir.path().join("not-a-theme.txt"), "ignored").unwrap();

        let dirs = vec![(dir.path().to_path_buf(), false)];
        let themes = list_themes_from_dirs(&dirs);
        assert_eq!(themes.len(), 1);
        assert_eq!(themes[0].id, "test-theme");
        assert_eq!(themes[0].name, "Test Theme");
    }

    #[test]
    fn list_themes_later_dir_overrides() {
        let dir1 = tempfile::tempdir().unwrap();
        let dir2 = tempfile::tempdir().unwrap();

        let theme1 = "[meta]\nname = \"Original\"\nvariant = \"dark\"\n";
        let theme2 = "[meta]\nname = \"Override\"\nvariant = \"light\"\n";

        fs::write(dir1.path().join("same-id.toml"), theme1).unwrap();
        fs::write(dir2.path().join("same-id.toml"), theme2).unwrap();

        let dirs = vec![
            (dir1.path().to_path_buf(), false),
            (dir2.path().to_path_buf(), true),
        ];
        let themes = list_themes_from_dirs(&dirs);
        assert_eq!(themes.len(), 1);
        assert_eq!(themes[0].name, "Override");
        assert!(themes[0].is_custom);
    }

    #[test]
    fn find_theme_path_checks_reverse_priority() {
        let dir1 = tempfile::tempdir().unwrap();
        let dir2 = tempfile::tempdir().unwrap();

        fs::write(dir1.path().join("shared.toml"), "[meta]\n").unwrap();
        fs::write(dir2.path().join("shared.toml"), "[meta]\n").unwrap();

        let dirs = vec![
            (dir1.path().to_path_buf(), false),
            (dir2.path().to_path_buf(), true),
        ];
        let (path, is_custom) = find_theme_path(&dirs, "shared").unwrap();
        assert!(is_custom);
        assert_eq!(path, dir2.path().join("shared.toml"));
    }

    #[test]
    fn find_theme_path_returns_none_when_missing() {
        let dir = tempfile::tempdir().unwrap();
        let dirs = vec![(dir.path().to_path_buf(), false)];
        assert!(find_theme_path(&dirs, "nonexistent").is_none());
    }

    #[test]
    fn load_theme_full_round_trip() {
        let dir = tempfile::tempdir().unwrap();
        let theme_content = r##"
[meta]
name = "Full Theme"
variant = "light"

[background]
primary = "#ffffff"

[foreground]
primary = "#000000"

[accent]
primary = "#ff0000"
"##;
        fs::write(dir.path().join("full.toml"), theme_content).unwrap();

        let dirs = vec![(dir.path().to_path_buf(), false)];
        let theme = load_theme(&dirs, "full").unwrap();
        assert_eq!(theme.meta.name, "Full Theme");
        assert_eq!(theme.meta.variant, "light");
        assert_eq!(theme.colors.get("background.primary").unwrap(), "#ffffff");
        assert_eq!(theme.colors.get("foreground.primary").unwrap(), "#000000");
        assert_eq!(theme.colors.get("accent.primary").unwrap(), "#ff0000");
    }

    #[test]
    fn load_theme_rejects_invalid_id() {
        let dirs = vec![];
        assert!(load_theme(&dirs, "../evil").is_err());
    }

    #[test]
    fn load_theme_not_found() {
        let dir = tempfile::tempdir().unwrap();
        let dirs = vec![(dir.path().to_path_buf(), false)];
        assert!(load_theme(&dirs, "missing").is_err());
    }

    #[test]
    fn dev_themes_dir_walks_parents() {
        // Use a real path that exists
        let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
        // Walking up from theme-common/ to Code/ (3 levels), MNW/shared/themes/ should exist
        let result = dev_themes_dir(&manifest, 3);
        // This test is environment-dependent, just verify it returns something valid
        if let Some(path) = result {
            assert!(path.ends_with("themes"));
        }
    }

    #[test]
    fn dev_themes_dir_returns_some_when_structure_exists() {
        // Construct a fake tree: <tmp>/leaf where <tmp>/MNW/shared/themes exists.
        // Walking up 1 level from `leaf` should locate the themes dir.
        // Catches `dev_themes_dir -> Option<PathBuf> with None` (always-None mutant).
        let root = tempfile::tempdir().unwrap();
        let leaf = root.path().join("leaf");
        std::fs::create_dir_all(&leaf).unwrap();
        let themes = root.path().join("MNW").join("shared").join("themes");
        std::fs::create_dir_all(&themes).unwrap();

        let result = dev_themes_dir(&leaf, 1);
        // Compare canonical forms — tempfile may return paths with /private prefix on macOS.
        let result_canon = result.expect("expected Some").canonicalize().unwrap();
        let themes_canon = themes.canonicalize().unwrap();
        assert_eq!(result_canon, themes_canon);
    }

    #[test]
    fn dev_themes_dir_returns_none_when_structure_missing() {
        // No MNW/shared/themes under the temp root → None.
        let root = tempfile::tempdir().unwrap();
        let leaf = root.path().join("leaf");
        std::fs::create_dir_all(&leaf).unwrap();
        // No themes dir created.
        let result = dev_themes_dir(&leaf, 1);
        assert!(result.is_none());
    }

    #[test]
    fn import_theme_valid() {
        let src_dir = tempfile::tempdir().unwrap();
        let custom_dir = tempfile::tempdir().unwrap();

        let content = r##"
[meta]
name = "Imported Theme"
variant = "dark"

[background]
primary = "#1a1b26"

[foreground]
primary = "#c0caf5"
"##;
        let src = src_dir.path().join("my-theme.toml");
        fs::write(&src, content).unwrap();

        let meta = import_theme(&src, custom_dir.path()).unwrap();
        assert_eq!(meta.id, "my-theme");
        assert_eq!(meta.name, "Imported Theme");
        assert!(meta.is_custom);

        // Verify file was copied
        assert!(custom_dir.path().join("my-theme.toml").exists());
    }

    #[test]
    fn import_theme_creates_dir() {
        let src_dir = tempfile::tempdir().unwrap();
        let base = tempfile::tempdir().unwrap();
        let custom_dir = base.path().join("nested").join("themes");

        let content = "[background]\nprimary = \"#000000\"\n";
        let src = src_dir.path().join("test.toml");
        fs::write(&src, content).unwrap();

        let meta = import_theme(&src, &custom_dir).unwrap();
        assert_eq!(meta.id, "test");
        assert!(custom_dir.join("test.toml").exists());
    }

    #[test]
    fn import_theme_rejects_no_color_sections() {
        let src_dir = tempfile::tempdir().unwrap();
        let custom_dir = tempfile::tempdir().unwrap();

        let content = "[meta]\nname = \"Empty\"\nvariant = \"dark\"\n";
        let src = src_dir.path().join("empty.toml");
        fs::write(&src, content).unwrap();

        assert!(import_theme(&src, custom_dir.path()).is_err());
    }

    #[test]
    fn import_theme_rejects_invalid_toml() {
        let src_dir = tempfile::tempdir().unwrap();
        let custom_dir = tempfile::tempdir().unwrap();

        let src = src_dir.path().join("bad.toml");
        fs::write(&src, "this is not [valid toml [[[").unwrap();

        assert!(import_theme(&src, custom_dir.path()).is_err());
    }

    #[test]
    fn import_theme_rejects_invalid_id() {
        let src_dir = tempfile::tempdir().unwrap();
        let custom_dir = tempfile::tempdir().unwrap();

        let content = "[background]\nprimary = \"#000000\"\n";
        let src = src_dir.path().join("has space.toml");
        fs::write(&src, content).unwrap();

        assert!(import_theme(&src, custom_dir.path()).is_err());
    }

    #[test]
    fn export_theme_copies_file() {
        let src_dir = tempfile::tempdir().unwrap();
        let dest_dir = tempfile::tempdir().unwrap();

        let content = "[meta]\nname = \"Export Me\"\nvariant = \"light\"\n[background]\nprimary = \"#ffffff\"\n";
        fs::write(src_dir.path().join("exportable.toml"), content).unwrap();

        let dirs = vec![(src_dir.path().to_path_buf(), false)];
        let dest = dest_dir.path().join("exported.toml");

        export_theme(&dirs, "exportable", &dest).unwrap();
        assert!(dest.exists());
        assert_eq!(fs::read_to_string(&dest).unwrap(), content);
    }

    #[test]
    fn delete_theme_removes_file() {
        let custom = tempfile::tempdir().unwrap();
        let path = custom.path().join("doomed.toml");
        fs::write(&path, "[background]\nprimary = \"#000\"\n").unwrap();
        assert!(path.exists());

        delete_theme(custom.path(), "doomed").unwrap();
        assert!(!path.exists());
    }

    #[test]
    fn delete_theme_rejects_invalid_id() {
        let custom = tempfile::tempdir().unwrap();
        assert!(delete_theme(custom.path(), "../etc/passwd").is_err());
    }

    #[test]
    fn delete_theme_not_found() {
        let custom = tempfile::tempdir().unwrap();
        assert!(delete_theme(custom.path(), "ghost").is_err());
    }

    #[test]
    fn load_theme_preview_returns_primaries() {
        let dir = tempfile::tempdir().unwrap();
        let content = r##"
[meta]
name = "Preview Me"
variant = "dark"

[background]
primary = "#111"
secondary = "#222"

[foreground]
primary = "#eee"

[accent]
primary = "#f0a"

[border]
primary = "#444"
"##;
        fs::write(dir.path().join("preview.toml"), content).unwrap();

        let dirs = vec![(dir.path().to_path_buf(), false)];
        let p = load_theme_preview(&dirs, "preview").unwrap();
        assert_eq!(p.meta.name, "Preview Me");
        assert_eq!(p.background.as_deref(), Some("#111"));
        assert_eq!(p.foreground.as_deref(), Some("#eee"));
        assert_eq!(p.accent.as_deref(), Some("#f0a"));
        assert_eq!(p.border.as_deref(), Some("#444"));
    }

    #[test]
    fn load_theme_preview_missing_sections_are_none() {
        let dir = tempfile::tempdir().unwrap();
        let content = "[background]\nprimary = \"#000\"\n";
        fs::write(dir.path().join("sparse.toml"), content).unwrap();

        let dirs = vec![(dir.path().to_path_buf(), false)];
        let p = load_theme_preview(&dirs, "sparse").unwrap();
        assert_eq!(p.background.as_deref(), Some("#000"));
        assert!(p.foreground.is_none());
        assert!(p.accent.is_none());
        assert!(p.border.is_none());
    }

    #[test]
    fn load_theme_preview_not_found() {
        let dir = tempfile::tempdir().unwrap();
        let dirs = vec![(dir.path().to_path_buf(), false)];
        assert!(load_theme_preview(&dirs, "missing").is_err());
    }

    #[test]
    fn export_theme_not_found() {
        let dir = tempfile::tempdir().unwrap();
        let dirs = vec![(dir.path().to_path_buf(), false)];
        let dest = dir.path().join("out.toml");

        assert!(export_theme(&dirs, "nonexistent", &dest).is_err());
    }
}