// file: crates/ksp-app-config-desk/tests/desktop_security.rs
// version: 1

//! Desktop security/ownership regression audits local to Config Desk.

fn app_root() -> std::path::PathBuf {
    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
}

fn collect_files(directory: &std::path::Path, extension: &str, files: &mut std::vec::Vec<std::path::PathBuf>) {
    let entries = std::fs::read_dir(directory);
    let entries = match entries {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => return,
    };
    for entry in entries {
        let entry = match entry {
            std::result::Result::Ok(value) => value,
            std::result::Result::Err(_) => continue,
        };
        let path = entry.path();
        if path.is_dir() {
            collect_files(path.as_path(), extension, files);
            continue;
        }
        if path.extension().and_then(std::ffi::OsStr::to_str) == std::option::Option::Some(extension) {
            files.push(path);
        }
    }
}

fn read_text(path: &std::path::Path) -> String {
    let source = std::fs::read_to_string(path);
    assert!(source.is_ok(), "unable to read {}", path.display());
    return match source {
        std::result::Result::Ok(value) => value,
        std::result::Result::Err(_) => String::new(),
    };
}

#[test]
fn frontend_avoids_native_dialogs_and_persistent_secret_storage() {
    let root = app_root();
    let mut typescript = std::vec::Vec::new();
    collect_files(root.join("frontend/ts").as_path(), "ts", &mut typescript);
    assert!(!typescript.is_empty());
    for path in typescript {
        let source = read_text(path.as_path());
        for forbidden in ["window.alert(", "window.confirm(", "window.prompt("] {
            assert!(!source.contains(forbidden), "{} uses forbidden browser-native dialog {forbidden}", path.display());
        }
    }
    let secret_reveal = read_text(root.join("frontend/ts/secret_reveal.ts").as_path());
    assert!(!secret_reveal.contains("localStorage"));
    assert!(!secret_reveal.contains("sessionStorage"));
    assert!(secret_reveal.contains("clearTransientSecretReveal"));
}

#[test]
fn tauri_commands_and_logging_adapters_remain_on_owned_boundaries() {
    let root = app_root();
    let manifest = read_text(root.join("Cargo.toml").as_path());
    assert!(manifest.contains("ksp-logging-lib"));
    assert!(manifest.contains("tauri-plugin-tracing"));
    assert!(!manifest.contains("tauri-plugin-log"));
    let source_root = root.join("src");
    let mut rust_files = std::vec::Vec::new();
    collect_files(source_root.as_path(), "rs", &mut rust_files);
    let mut command_attribute_count = 0usize;
    for path in rust_files {
        let source = read_text(path.as_path());
        let count = source.matches("#[tauri::command]").count();
        if path.file_name().and_then(std::ffi::OsStr::to_str) == std::option::Option::Some("tauri.rs") {
            command_attribute_count += count;
        } else {
            assert_eq!(count, 0, "{} declares a Tauri command outside tauri.rs", path.display());
        }
    }
    assert!(command_attribute_count > 0);
}