diskforge_core/rules/

app_uninstall.rs

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

use crate::sizing;
use crate::types::{Category, CleanableItem, Risk};

/// Information about an installed macOS application
#[derive(Debug, Clone)]
pub struct AppInfo {
    /// Display name (e.g., "Docker")
    pub name: String,
    /// CFBundleIdentifier (e.g., "com.docker.docker")
    pub bundle_id: String,
    /// Path to the .app bundle (e.g., "/Applications/Docker.app")
    pub app_path: PathBuf,
}

/// List all installed applications from /Applications by reading their Info.plist files.
/// Returns apps sorted by name.
pub fn list_apps() -> Vec<AppInfo> {
    list_apps_in("/Applications")
}

/// List apps in a given directory (useful for testing).
pub fn list_apps_in(applications_dir: &str) -> Vec<AppInfo> {
    let dir = Path::new(applications_dir);
    let Ok(entries) = std::fs::read_dir(dir) else {
        return Vec::new();
    };

    let mut apps: Vec<AppInfo> = entries
        .flatten()
        .filter(|e| e.path().extension().is_some_and(|ext| ext == "app"))
        .filter_map(|e| read_app_info(&e.path()))
        .collect();

    apps.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
    apps
}

/// Read Info.plist from an .app bundle and extract name + bundle ID.
fn read_app_info(app_path: &Path) -> Option<AppInfo> {
    let plist_path = app_path.join("Contents/Info.plist");
    let value = plist::Value::from_file(&plist_path).ok()?;
    let dict = value.as_dictionary()?;

    let bundle_id = dict.get("CFBundleIdentifier")?.as_string()?.to_string();

    // Prefer CFBundleName, fall back to CFBundleDisplayName, then filename
    let name = dict
        .get("CFBundleName")
        .and_then(|v| v.as_string())
        .or_else(|| dict.get("CFBundleDisplayName").and_then(|v| v.as_string()))
        .map(|s| s.to_string())
        .unwrap_or_else(|| {
            app_path
                .file_stem()
                .map(|s| s.to_string_lossy().to_string())
                .unwrap_or_default()
        });

    Some(AppInfo {
        name,
        bundle_id,
        app_path: app_path.to_path_buf(),
    })
}

/// Find an app by query string. Matches case-insensitively against:
/// - Display name (substring match)
/// - Bundle identifier (substring match)
///
/// Returns all matching apps.
pub fn find_app(query: &str, apps: &[AppInfo]) -> Vec<AppInfo> {
    let query_lower = query.to_lowercase();
    apps.iter()
        .filter(|app| {
            app.name.to_lowercase().contains(&query_lower)
                || app.bundle_id.to_lowercase().contains(&query_lower)
        })
        .cloned()
        .collect()
}

/// All ~/Library subdirectory patterns where apps leave traces.
/// Each entry is (subdirectory relative to ~/Library, is_file_pattern).
const TRACE_DIRS: &[(&str, TraceKind)] = &[
    ("Application Support", TraceKind::DirMatchNameOrId),
    ("Caches", TraceKind::DirMatchNameOrId),
    ("Containers", TraceKind::DirMatchId),
    ("Group Containers", TraceKind::DirMatchIdSuffix),
    ("Preferences", TraceKind::PlistMatchId),
    ("Preferences/ByHost", TraceKind::PlistGlobId),
    ("Saved Application State", TraceKind::DirMatchIdSuffix),
    ("HTTPStorages", TraceKind::DirMatchNameOrId),
    ("WebKit", TraceKind::DirMatchNameOrId),
    ("Application Scripts", TraceKind::DirMatchId),
    ("Logs", TraceKind::DirMatchNameOrId),
    ("LaunchAgents", TraceKind::PlistGlobId),
    ("Cookies", TraceKind::FileGlobId),
    ("SyncedPreferences", TraceKind::PlistMatchId),
];

#[derive(Debug, Clone, Copy)]
enum TraceKind {
    /// Match directory entries by app name or bundle ID
    DirMatchNameOrId,
    /// Match directory entries by bundle ID only
    DirMatchId,
    /// Match directory entries whose name ends with the bundle ID
    DirMatchIdSuffix,
    /// Match a single .plist file by bundle ID (e.g., com.docker.docker.plist)
    PlistMatchId,
    /// Glob for .plist files containing the bundle ID (e.g., com.docker.docker.*.plist)
    PlistGlobId,
    /// Glob for non-plist files containing the bundle ID (e.g., com.docker.docker.binarycookies)
    FileGlobId,
}

/// Find all traces of an app across ~/Library subdirectories.
/// Returns CleanableItems sorted by size (largest first).
pub fn find_app_traces(app: &AppInfo, home: &str) -> Vec<CleanableItem> {
    let library = PathBuf::from(format!("{home}/Library"));
    let mut items = Vec::new();

    for &(subdir, kind) in TRACE_DIRS {
        let dir = library.join(subdir);
        if !dir.exists() {
            continue;
        }
        match kind {
            TraceKind::DirMatchNameOrId => {
                find_dir_traces(&dir, app, true, &mut items);
            }
            TraceKind::DirMatchId => {
                find_dir_traces(&dir, app, false, &mut items);
            }
            TraceKind::DirMatchIdSuffix => {
                find_dir_suffix_traces(&dir, app, &mut items);
            }
            TraceKind::PlistMatchId => {
                find_plist_trace(&dir, app, &mut items);
            }
            TraceKind::PlistGlobId => {
                find_plist_glob_traces(&dir, app, &mut items);
            }
            TraceKind::FileGlobId => {
                find_file_glob_traces(&dir, app, &mut items);
            }
        }
    }

    // Also check the .app bundle itself
    if app.app_path.exists() {
        let stats = sizing::dir_stats(&app.app_path);
        items.push(CleanableItem {
            category: Category::AppCache(app.name.clone()),
            path: app.app_path.clone(),
            size: stats.size,
            risk: Risk::Medium,
            regenerates: false,
            regeneration_hint: Some("Re-download from developer or App Store".into()),
            last_modified: stats.last_modified,
            description: format!("{}.app bundle", app.name),
            cleanup_command: None,
        });
    }

    items.sort_by(|a, b| b.size.cmp(&a.size));
    items
}

/// Find directory entries matching app name or bundle ID.
fn find_dir_traces(parent: &Path, app: &AppInfo, match_name: bool, items: &mut Vec<CleanableItem>) {
    let Ok(entries) = std::fs::read_dir(parent) else {
        return;
    };
    let id_lower = app.bundle_id.to_lowercase();
    let name_lower = app.name.to_lowercase();

    for entry in entries.flatten() {
        let entry_name = entry.file_name().to_string_lossy().to_string();
        let entry_lower = entry_name.to_lowercase();

        let matched = entry_lower == id_lower || (match_name && entry_lower == name_lower);

        if matched {
            let path = entry.path();
            add_trace_item(&path, app, items);
        }
    }
}

/// Find directory entries whose name ends with the bundle ID (Group Containers, savedState).
fn find_dir_suffix_traces(parent: &Path, app: &AppInfo, items: &mut Vec<CleanableItem>) {
    let Ok(entries) = std::fs::read_dir(parent) else {
        return;
    };
    let id_lower = app.bundle_id.to_lowercase();

    for entry in entries.flatten() {
        let entry_name = entry.file_name().to_string_lossy().to_string();
        let entry_lower = entry_name.to_lowercase();

        // Match "group.com.docker.docker" or "com.docker.docker.savedState"
        if entry_lower.contains(&id_lower) {
            let path = entry.path();
            add_trace_item(&path, app, items);
        }
    }
}

/// Find a specific .plist file matching the bundle ID.
fn find_plist_trace(parent: &Path, app: &AppInfo, items: &mut Vec<CleanableItem>) {
    let plist_path = parent.join(format!("{}.plist", app.bundle_id));
    if plist_path.exists() {
        add_trace_item(&plist_path, app, items);
    }
}

/// Glob for .plist files containing the bundle ID (e.g., ByHost/com.docker.docker.*.plist).
fn find_plist_glob_traces(parent: &Path, app: &AppInfo, items: &mut Vec<CleanableItem>) {
    let Ok(entries) = std::fs::read_dir(parent) else {
        return;
    };
    let id_lower = app.bundle_id.to_lowercase();

    for entry in entries.flatten() {
        let name = entry.file_name().to_string_lossy().to_string();
        let name_lower = name.to_lowercase();
        if name_lower.contains(&id_lower) && name_lower.ends_with(".plist") {
            add_trace_item(&entry.path(), app, items);
        }
    }
}

/// Glob for non-plist files containing the bundle ID (e.g., .binarycookies).
fn find_file_glob_traces(parent: &Path, app: &AppInfo, items: &mut Vec<CleanableItem>) {
    let Ok(entries) = std::fs::read_dir(parent) else {
        return;
    };
    let id_lower = app.bundle_id.to_lowercase();

    for entry in entries.flatten() {
        let name = entry.file_name().to_string_lossy().to_string();
        if name.to_lowercase().contains(&id_lower) {
            add_trace_item(&entry.path(), app, items);
        }
    }
}

/// Create a CleanableItem from a trace path and add it to the list.
fn add_trace_item(path: &Path, app: &AppInfo, items: &mut Vec<CleanableItem>) {
    let (size, last_modified) = if path.is_dir() {
        let stats = sizing::dir_stats(path);
        (stats.size, stats.last_modified)
    } else if let Ok(meta) = path.metadata() {
        (meta.len(), meta.modified().ok())
    } else {
        return;
    };

    // Determine risk by trace type:
    // - plist/preferences: None (easily regenerated by the app on next launch)
    // - everything else (caches, containers, app support dirs): Low
    // Note: .app bundle itself is handled separately in find_app_traces() as Medium
    let risk = if path
        .extension()
        .is_some_and(|e| e == "plist" || e == "binarycookies")
    {
        Risk::None
    } else {
        Risk::Low
    };

    let description = format!(
        "{}: {}",
        app.name,
        path.file_name()
            .map(|n| n.to_string_lossy().to_string())
            .unwrap_or_else(|| path.to_string_lossy().to_string()),
    );

    items.push(CleanableItem {
        category: Category::AppCache(app.name.clone()),
        path: path.to_path_buf(),
        size,
        risk,
        regenerates: false,
        regeneration_hint: None,
        last_modified,
        description,
        cleanup_command: None,
    });
}

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

    fn make_app_info() -> AppInfo {
        AppInfo {
            name: "Docker".into(),
            bundle_id: "com.docker.docker".into(),
            app_path: PathBuf::from("/Applications/Docker.app"),
        }
    }

    #[test]
    fn find_app_by_name() {
        let apps = vec![
            make_app_info(),
            AppInfo {
                name: "Safari".into(),
                bundle_id: "com.apple.Safari".into(),
                app_path: PathBuf::from("/Applications/Safari.app"),
            },
        ];

        let results = find_app("docker", &apps);
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].name, "Docker");
    }

    #[test]
    fn find_app_by_bundle_id() {
        let apps = vec![make_app_info()];
        let results = find_app("com.docker", &apps);
        assert_eq!(results.len(), 1);
    }

    #[test]
    fn find_app_case_insensitive() {
        let apps = vec![make_app_info()];
        let results = find_app("DOCKER", &apps);
        assert_eq!(results.len(), 1);
    }

    #[test]
    fn find_app_no_match() {
        let apps = vec![make_app_info()];
        let results = find_app("nonexistent", &apps);
        assert!(results.is_empty());
    }

    #[test]
    fn trace_paths_generated() {
        // Create a temp structure mimicking ~/Library
        let tmp = std::env::temp_dir().join("diskforge_test_uninstall");
        let _ = fs::remove_dir_all(&tmp);

        // Create trace directories
        let caches = tmp.join("Library/Caches/com.docker.docker");
        fs::create_dir_all(&caches).unwrap();
        fs::write(caches.join("data.bin"), vec![0u8; 1024]).unwrap();

        let app_support = tmp.join("Library/Application Support/Docker");
        fs::create_dir_all(&app_support).unwrap();
        fs::write(app_support.join("config.json"), "{}").unwrap();

        let prefs = tmp.join("Library/Preferences");
        fs::create_dir_all(&prefs).unwrap();
        fs::write(prefs.join("com.docker.docker.plist"), "fake").unwrap();

        let group = tmp.join("Library/Group Containers/group.com.docker.docker");
        fs::create_dir_all(&group).unwrap();
        fs::write(group.join("state"), "x").unwrap();

        let saved_state = tmp.join("Library/Saved Application State/com.docker.docker.savedState");
        fs::create_dir_all(&saved_state).unwrap();
        fs::write(saved_state.join("window.data"), "w").unwrap();

        let app = AppInfo {
            name: "Docker".into(),
            bundle_id: "com.docker.docker".into(),
            app_path: PathBuf::from("/nonexistent/Docker.app"), // skip .app bundle check
        };

        let traces = find_app_traces(&app, &tmp.to_string_lossy());

        // Should find: Caches dir, Application Support dir, Preferences plist,
        // Group Containers dir, Saved Application State dir
        assert!(
            traces.len() >= 5,
            "Expected at least 5 traces, got {}: {:?}",
            traces.len(),
            traces
                .iter()
                .map(|t| t.path.display().to_string())
                .collect::<Vec<_>>()
        );

        // Verify Caches trace exists
        assert!(traces.iter().any(|t| {
            t.path
                .to_string_lossy()
                .contains("Caches/com.docker.docker")
        }));
        // Verify Preferences plist exists
        assert!(
            traces
                .iter()
                .any(|t| t.path.to_string_lossy().contains("com.docker.docker.plist"))
        );
        // Verify Group Containers exists
        assert!(
            traces
                .iter()
                .any(|t| t.path.to_string_lossy().contains("group.com.docker.docker"))
        );

        fs::remove_dir_all(&tmp).ok();
    }
}